comunit-base 0.37.200628.0

data/app/models/site.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Network site
+#
+# Attributes:
+#   active [Boolean]
+#   created_at [DateTime]
+#   data [JSONB]
+#   deleted [Boolean]
+#   description [String], optional
+#   host [String]
+#   image [SimpleImageUploader], optional
+#   name [String]
+#   updated_at [DateTime]
+#   users_count [Integer]
+#   uuid [UUID]
+class Site < ApplicationRecord
+  mount_uploader :image, SimpleImageUploader
+
+  has_many :users, dependent: :nullify
+
+  scope :active, -> { where(active: true, deleted: false) }
+  scope :list_for_administration, -> { order('name asc') }
+
+  def self.synchronization_parameters
+    ignored = %w(id users_count)
+    column_names.reject { |c| ignored.include?(c) }
+  end
+end

data/app/models/team.rb

@@ -0,0 +1,72 @@
+class Team < ApplicationRecord
+  include Toggleable
+  include RequiredUniqueName
+  include RequiredUniqueSlug
+
+  SLUG_PATTERN = /\A[-_a-z0-9]+\z/
+
+  toggleable :visible
+
+  has_many :team_privileges, dependent: :destroy
+  has_many :privileges, through: :team_privileges
+
+  after_initialize :set_next_priority
+  before_validation { self.slug = Canonizer.transliterate(name.to_s) if slug.blank? }
+
+  validates_format_of :slug, with: SLUG_PATTERN
+
+  scope :visible, -> { where(visible: true) }
+  scope :ordered_by_priority, -> { order('priority asc') }
+
+  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 description visible)
+  end
+
+  # @param [Privilege] privilege
+  def has_privilege?(privilege)
+    team_privileges.where(privilege: privilege).exists?
+  end
+
+  # @param [Privilege] privilege
+  def add_privilege(privilege)
+    TeamPrivilege.find_or_create_by(privilege: privilege, team: self)
+  end
+
+  # @param [Privilege] privilege
+  def remove_privilege(privilege)
+    team_privileges.where(privilege: privilege).destroy_all
+  end
+
+  def users
+    ids = UserPrivilege.where(privilege_id: privilege_ids).pluck(:user_id)
+    User.where(id: ids.uniq).order('surname asc, name asc, slug asc')
+  end
+
+  # @param [Integer] delta
+  def change_priority(delta)
+    new_priority = priority + delta
+    adjacent     = Team.find_by(priority: new_priority)
+    if adjacent.is_a?(Team) && (adjacent.id != id)
+      adjacent.update!(priority: priority)
+    end
+    self.update(priority: new_priority)
+
+    Team.ordered_by_priority.map { |e| [e.id, e.priority] }.to_h
+  end
+
+  private
+
+  def set_next_priority
+    if id.nil? && priority == 1
+      self.priority = Team.maximum(:priority).to_i + 1
+    end
+  end
+end

data/app/models/team_privilege.rb

@@ -0,0 +1,6 @@
+class TeamPrivilege < ApplicationRecord
+  belongs_to :team, counter_cache: true
+  belongs_to :privilege
+
+  validates_uniqueness_of :privilege_id, scope: [:team_id]
+end

data/app/models/theme.rb

@@ -0,0 +1,26 @@
+class Theme < ApplicationRecord
+  has_many :theme_post_categories, dependent: :destroy
+  # has_many :theme_news_categories, dependent: :destroy
+  has_many :post_categories, through: :theme_post_categories
+  # has_many :news_categories, through: :theme_news_categories
+
+  validates_presence_of :name, :slug
+  validates_uniqueness_of :name, :slug
+
+  scope :ordered_by_name, -> { order 'name asc' }
+
+  def self.page_for_administration
+    ordered_by_name
+  end
+
+  def self.entity_parameters
+    %i[name slug]
+  end
+
+  # @param [Integer] limit
+  # @param [Region] region
+  # @param [Integer] page
+  def entries(limit = 5, region = nil, page = 1)
+    Post.in_region(region).with_category_ids(post_category_ids).visible.recent.page(page).per(limit)
+  end
+end

data/app/models/theme_news_category.rb

@@ -0,0 +1,4 @@
+class ThemeNewsCategory < ApplicationRecord
+  belongs_to :theme, counter_cache: :news_categories_count
+  belongs_to :news_category
+end

data/app/models/theme_post_category.rb

@@ -0,0 +1,4 @@
+class ThemePostCategory < ApplicationRecord
+  belongs_to :theme, counter_cache: :post_categories_count
+  belongs_to :post_category
+end

data/app/models/user_group.rb

@@ -0,0 +1,6 @@
+class UserGroup < ApplicationRecord
+  belongs_to :user
+  belongs_to :group, counter_cache: :users_count
+
+  validates_uniqueness_of :user_id, scope: [:group_id]
+end

data/app/models/user_link.rb

@@ -0,0 +1,69 @@
+class UserLink < ApplicationRecord
+  include Toggleable
+
+  PER_PAGE = 10
+
+  toggleable :visible
+
+  belongs_to :agent, optional: true
+  belongs_to :followee, class_name: User.to_s, counter_cache: :follower_count
+  belongs_to :follower, class_name: User.to_s, counter_cache: :followee_count
+
+  validates_uniqueness_of :followee, scope: [:follower]
+
+  scope :visible, -> { where(visible: true) }
+  scope :recent, -> { order('id desc') }
+  scope :with_follower, -> (user) { where(follower: user) }
+  scope :with_followee, -> (user) { where(followee: user) }
+
+  # @param [Integer] page
+  def self.page_for_user(page)
+    recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [User] follower
+  # @param [User] followee
+  def self.follow(follower, followee)
+    if follower.is_a?(User) && followee.is_a?(User)
+      criteria = { follower_id: follower.id, followee_id: followee.id }
+      link = find_or_create_by(criteria)
+      link.reciprocal.update(visible: true) if link.mutual?
+      link
+    else
+      raise "#{follower.class}, #{followee.class}"
+    end
+  end
+
+  # @param [User] follower
+  # @param [User] followee
+  def self.unfollow(follower, followee)
+    with_follower(follower).with_followee(followee).destroy_all
+  end
+
+  # @param [Symbol] side
+  # @param [Hash] filter
+  def self.filtered(side, filter)
+    link = joins(side).where("users.id = user_links.#{side}_id")
+    unless filter[:screen_name].blank?
+      link = link.where('users.screen_name ilike ?', "%#{filter[:screen_name]}%")
+    end
+    unless filter[:name].blank?
+      link = link.where('users.name ilike ?', "%#{filter[:name]}%")
+    end
+    unless filter[:surname].blank?
+      link = link.where('users.surname ilike ?', "%#{filter[:surname]}%")
+    end
+    unless filter[:online].blank?
+      link = link.where('users.last_seen >= ?', 3.minutes.ago)
+    end
+    link
+  end
+
+  def mutual?
+    reciprocal.exists?
+  end
+
+  def reciprocal
+    UserLink.where(follower: followee, followee: follower)
+  end
+end

data/app/models/user_message.rb

@@ -0,0 +1,86 @@
+class UserMessage < ApplicationRecord
+  include Toggleable
+
+  PER_PAGE = 20
+
+  toggleable :read_by_receiver, :deleted_by_sender, :deleted_by_receiver
+
+  belongs_to :agent, optional: true
+  belongs_to :sender, class_name: User.to_s
+  belongs_to :receiver, class_name: User.to_s
+
+  validates_presence_of :body
+
+  scope :recent, -> { order('id desc') }
+  scope :unread, -> { where(read_by_receiver: false) }
+  scope :with_sender, -> (user) { where(sender_id: user) unless user.blank? }
+  scope :with_receiver, -> (user) { where(receiver_id: user) unless user.blank? }
+  scope :visible_to_sender, -> { where(deleted_by_sender: false) }
+  scope :visible_to_receiver, -> { where(deleted_by_receiver: false) }
+  scope :visible_to_user, -> (user) { where('(sender_id = ? and deleted_by_sender = false) or (receiver_id = ? and deleted_by_receiver = false)', user, user) }
+  scope :owned_by, -> (user) { where('sender_id = ? and deleted_by_sender = false or receiver_id = ?', user, user) unless user.blank? }
+  scope :filtered, -> (f) { owned_by(f[:user_id]).with_sender(f[:sender_id]).with_receiver(f[:receiver_id]) }
+
+  # @param [Integer] page
+  # @param [Hash] filter
+  def self.page_for_administration(page, filter = {})
+    filtered(filter).recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [User] user
+  # @param [Integer] page
+  def self.page_for_owner(user, page)
+    visible_to_user(user).recent.page(page).per(PER_PAGE)
+  end
+
+  # @param [User] user
+  # @param [User] other_user
+  # @param [Integer] page
+  def self.dialog_page(user, other_user, page)
+    clause      = 'sender_id = ? and receiver_id = ?'
+    as_sender   = "(#{clause} and deleted_by_sender = false)"
+    as_receiver = "(#{clause} and deleted_by_receiver = false)"
+    where("#{as_sender} or #{as_receiver}", user, other_user, other_user, user).
+        recent.page(page).per(PER_PAGE)
+  end
+
+  def self.entity_parameters
+    %i(body)
+  end
+
+  def self.creation_parameters
+    entity_parameters + %i(receiver_id)
+  end
+
+  # @param [User] user
+  def destroy_by_user(user)
+    if sender?(user)
+      update(deleted_by_sender: true)
+      receiver.slug
+    elsif receiver?(user)
+      update(deleted_by_receiver: true)
+      sender.slug
+    end
+  end
+
+  # @param [User] user
+  def visible_to?(user)
+    if sender?(user)
+      !deleted_by_sender?
+    elsif receiver?(user)
+      !deleted_by_receiver?
+    else
+      false
+    end
+  end
+
+  # @param [User] user
+  def sender?(user)
+    user == sender
+  end
+
+  # @param [User] user
+  def receiver?(user)
+    user == receiver
+  end
+end

data/app/models/zen_category.rb

@@ -0,0 +1,21 @@
+class ZenCategory < ApplicationRecord
+  include RequiredUniqueName
+
+  has_many :post_zen_categories, dependent: :delete_all
+  has_many :posts, through: :post_zen_categories
+
+  # @param [Post] post
+  def post?(post)
+    post_zen_categories.where(post: post).exists?
+  end
+
+  # @param [Post] post
+  def add_post(post)
+    post_zen_categories.create(post: post)
+  end
+
+  # @param [Post] post
+  def remove_post(post)
+    post_zen_categories.where(post: post).destroy_all
+  end
+end

data/app/services/biovision/components/campaigns_component.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    # Component for election campaigns
+    class CampaignsComponent < BaseComponent
+      SLUG = 'campaigns'
+
+      def user_parameters?
+        false
+      end
+    end
+  end
+end

data/app/services/biovision/components/decisions_component.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    # Decisions
+    class DecisionsComponent < BaseComponent
+    end
+  end
+end

data/app/services/biovision/components/deeds_component.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    # Deed handler
+    class DeedsComponent < BaseComponent
+      # @param [Deed] deed
+      def editable?(deed)
+        return false if deed.nil? || user.nil?
+
+        deed.owned_by?(user) || allow?
+      end
+    end
+  end
+end

data/app/services/biovision/components/regions_component.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Biovision
+  module Components
+    # Handler for regions component
+    class RegionsComponent < BaseComponent
+      SLUG = 'regions'
+
+      def self.privilege_names
+        %w[manager]
+      end
+
+      def self.default_country_id
+        Country.first&.id
+      end
+
+      def allow_regions?
+        return true if allow?('manager')
+
+        RegionUser.where(user: user).exists?
+      end
+
+      def allowed_region_ids
+        return nil if allow?('manager')
+        return nil if RegionUser.where(user: user, region_id: nil).exists?
+
+        parent_region_ids = RegionUser.where(user: user).pluck(:region_id)
+        parent_region_ids + RegionUser.allowed_region_ids(user)
+      end
+    end
+  end
+end

data/app/services/comunit/network/handler.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Comunit
+  module Network
+    # Base entity handler for synchronization
+    class Handler
+      include Logging
+      include Sending
+
+      MAIN_HOST = 'https://comunit.online'
+
+      attr_accessor :entity, :data
+
+      # @param [ApplicationRecord] entity
+      def initialize(entity)
+        @entity = entity
+      end
+
+      # @param [Hash] data
+      def self.[](data)
+        instance = new(nil)
+        instance.data = data
+        instance
+      end
+
+      # @param [ApplicationRecord] entity
+      # @param [TrueClass|FalseClass] wrap
+      def self.relationship_data(entity, wrap = true)
+        return nil if entity.nil?
+
+        data = { id: entity.uuid, type: entity.class.table_name }
+        wrap ? { data: data } : data
+      end
+
+      def self.ignored_attributes
+        %w[data id image]
+      end
+
+      def self.permitted_attributes
+        %i[created_at uuid]
+      end
+
+      def push
+        return if entity.nil?
+
+        log_info("Pushing #{entity.class} #{entity.uuid}")
+        path = "#{MAIN_HOST}/comunit/#{entity.class.table_name}/#{entity.uuid}"
+        rest(:put, path, data: prepare_model_data)
+      end
+
+      # @param [String] uuid
+      def pull(uuid)
+        @entity = entity_class.find_or_initialize_by(uuid: uuid)
+        log_info "Pulling #{@entity.class} #{uuid}"
+
+        if data.dig(:comunit, :site_id) == ENV['SITE_ID']
+          log_info 'Entity has the same origin site, skipping'
+        else
+          pull_and_validate
+        end
+      end
+
+      # @param [Integer] id
+      def amend(id)
+        @entity = entity_class.find_by(id: id)
+        if @entity.nil?
+          log_info "Could not find #{entity_class} #{id}"
+        else
+          log_info "Amending #{@entity.class} #{id}"
+          pull_and_validate
+        end
+      end
+
+      def pull_and_validate
+        pull_data
+        log_info "Validation status after pull: #{@entity.valid?}"
+        if @entity.valid?
+          @entity.save && after_pull
+        else
+          log_error @entity.errors.messages
+        end
+      end
+
+      def prepare_model_data
+        {
+          id: entity.uuid,
+          type: entity.class.table_name,
+          attributes: attributes_for_remote,
+          relationships: relationships_for_remote,
+          meta: meta_for_remote
+        }
+      end
+
+      def entity_class
+        self.class.to_s.demodulize.gsub(/Handler$/, '').safe_constantize
+      end
+
+      protected
+
+      def after_pull
+        true
+      end
+
+      # Attributes for remote post create/update
+      #
+      # @return [Hash]
+      def attributes_for_remote
+        ignored = self.class.ignored_attributes
+
+        @entity.attributes.reject do |a, _|
+          ignored.include?(a) || a.end_with?('_count', '_id', '_cache')
+        end
+      end
+
+      def relationships_for_remote
+        nil
+      end
+
+      def meta_for_remote
+        {}
+      end
+
+      def pull_data
+        apply_attributes
+      end
+
+      def apply_attributes
+        permitted = self.class.permitted_attributes
+        input = @data.dig(:attributes).to_h
+
+        attributes = input.select { |a, _| permitted.include?(a.to_sym) }
+        @entity.assign_attributes(attributes)
+        apply_comunit
+      end
+
+      # @param [Symbol] key
+      def dig_related_id(key)
+        data.dig(:relationships, key, :data, :id)
+      end
+
+      def apply_comunit
+        @entity.data['comunit'] = data.dig(:data, :comunit)
+      end
+
+      def apply_user
+        @entity.user = User.find_by(uuid: dig_related_id(:user))
+      end
+
+      def apply_agent
+        @entity.agent = Agent[data.dig(:meta, :agent)]
+      end
+
+      def apply_image
+        image_path = data.dig(:meta, :image_path)
+
+        return if image_path.blank? || !File.exist?(image_path)
+
+        @entity.image = Pathname.new(image_path).open
+      end
+    end
+  end
+end