decidim-core 0.14.4 → 0.15.0

data/app/models/decidim/user_base_entity.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class serves as a base class for `Decidim::User` and `Decidim::UserGroup`
+  # so that we can set some shared logic.
+  # This class is not supposed to be used directly.
+  class UserBaseEntity < ApplicationRecord
+    self.table_name = "decidim_users"
+
+    include Nicknamizable
+    include Resourceable
+    include Decidim::Followable
+    include Decidim::Loggable
+
+    belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
+    has_many :notifications, foreign_key: "decidim_user_id", class_name: "Decidim::Notification", dependent: :destroy
+    has_many :following_follows, foreign_key: "decidim_user_id", class_name: "Decidim::Follow", dependent: :destroy
+
+    validates :avatar, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_avatar_size } }
+    mount_uploader :avatar, Decidim::AvatarUploader
+
+    validates :name, :nickname, format: { with: /\A(?!.*[<>?%&\^*#@\(\)\[\]\=\+\:\;\"\{\}\\\|])/ }
+
+    # Public: Returns a collection with all the entities this user is following.
+    #
+    # This can't be done as with a `has_many :following, through: :following_follows`
+    # since it's a polymorphic relation and Rails doesn't know how to load it. With
+    # this implementation we only query the database once for each kind of following.
+    #
+    # Returns an Array of Decidim::Followable
+    def following
+      @following ||= begin
+                       followings = following_follows.pluck(:decidim_followable_type, :decidim_followable_id)
+                       grouped_followings = followings.each_with_object({}) do |(type, following_id), all|
+                         all[type] ||= []
+                         all[type] << following_id
+                         all
+                       end
+
+                       grouped_followings.flat_map do |type, ids|
+                         type.constantize.where(id: ids)
+                       end
+                     end
+    end
+
+    def following_users
+      @following_users ||= following.select do |f|
+        f.is_a?(Decidim::User) || f.is_a?(Decidim::UserGroup)
+      end
+    end
+  end
+end

data/app/models/decidim/user_group.rb

@@ -2,27 +2,28 @@
 
 module Decidim
   # A UserGroup is an organization of citizens
-  class UserGroup < ApplicationRecord
+  class UserGroup < UserBaseEntity
     include Decidim::Traceable
-    include Decidim::Loggable
     include Decidim::DataPortability
 
-    belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
-
     has_many :memberships, class_name: "Decidim::UserGroupMembership", foreign_key: :decidim_user_group_id, dependent: :destroy
     has_many :users, through: :memberships, class_name: "Decidim::User", foreign_key: :decidim_user_id
 
     validates :name, presence: true, uniqueness: { scope: :decidim_organization_id }
-    validates :document_number, presence: true, uniqueness: { scope: :decidim_organization_id }
+    validates :document_number, presence: true
     validates :phone, presence: true
-    validates :avatar, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_avatar_size } }
 
     validate :correct_state
+    validate :unique_document_number
 
-    mount_uploader :avatar, Decidim::AvatarUploader
+    scope :verified, -> { where.not("extended_data->>'verified_at' IS ?", nil) }
+    scope :rejected, -> { where.not("extended_data->>'rejected_at' IS ?", nil) }
+    scope :pending, -> { where("extended_data->>'rejected_at' IS ? AND extended_data->>'verified_at' IS ?", nil, nil) }
 
-    scope :verified, -> { where.not(verified_at: nil) }
-    scope :rejected, -> { where.not(rejected_at: nil) }
+    def self.with_document_number(organization, number)
+      where(decidim_organization_id: organization.id)
+        .where("extended_data->>'document_number' = ?", number)
+    end
 
     def self.log_presenter_class_for(_log)
       Decidim::AdminLog::UserGroupPresenter
@@ -51,11 +52,49 @@ module Decidim
       Decidim::DataPortabilitySerializers::DataPortabilityUserGroupSerializer
     end
 
+    def document_number
+      extended_data["document_number"]
+    end
+
+    def phone
+      extended_data["phone"]
+    end
+
+    def rejected_at
+      extended_data["rejected_at"]
+    end
+
+    def verified_at
+      extended_data["verified_at"]
+    end
+
+    def reject!
+      extended_data["verified_at"] = nil
+      extended_data["rejected_at"] = Time.current
+      save!
+    end
+
+    def verify!
+      extended_data["verified_at"] = Time.current
+      extended_data["rejected_at"] = nil
+      save!
+    end
+
     private
 
     # Private: Checks if the state user group is correct.
     def correct_state
       errors.add(:base, :invalid) if verified? && rejected?
     end
+
+    def unique_document_number
+      is_repeated = self
+                    .class
+                    .with_document_number(organization, document_number)
+                    .where.not(id: id)
+                    .any?
+
+      errors.add(:document_number, :taken) if is_repeated
+    end
   end
 end

data/app/models/decidim/user_group_membership.rb

@@ -5,5 +5,13 @@ module Decidim
   class UserGroupMembership < ApplicationRecord
     belongs_to :user, class_name: "Decidim::User", foreign_key: :decidim_user_id
     belongs_to :user_group, class_name: "Decidim::UserGroup", foreign_key: :decidim_user_group_id
+
+    ROLES = %w(creator admin member requested invited).freeze
+    validates :role, inclusion: { in: ROLES }
+    validates :role, uniqueness: { scope: [:role, :decidim_user_group_id] }, if: :creator?
+
+    def creator?
+      role.to_s == "creator"
+    end
   end
 end

data/app/permissions/decidim/permissions.rb

@@ -18,6 +18,8 @@ module Decidim
       follow_action?
       notification_action?
       conversation_action?
+      user_group_action?
+      user_group_invitations_action?
 
       permission_action
     end
@@ -91,6 +93,25 @@ module Decidim
       toggle_allow(conversation.participants.include?(user))
     end
 
+    def user_group_action?
+      return unless permission_action.subject == :user_group
+      return allow! if [:join, :create].include?(permission_action.action)
+
+      user_group = context.fetch(:user_group)
+
+      if permission_action.action == :leave
+        user_can_leave_group = Decidim::UserGroupMembership.where(user: user, user_group: user_group).where.not(role: :creator).any?
+        return toggle_allow(user_can_leave_group)
+      end
+
+      user_manages_group = Decidim::UserGroups::ManageableUserGroups.for(user).include?(user_group)
+      toggle_allow(user_manages_group) if permission_action.action == :manage
+    end
+
+    def user_group_invitations_action?
+      allow! if permission_action.subject == :user_group_invitations
+    end
+
     def user_can_admin_component?
       new_permission_action = Decidim::PermissionAction.new(
         action: permission_action.action,

data/app/presenters/decidim/admin_log/organization_presenter.rb

@@ -61,8 +61,6 @@ module Decidim
           cta_button_path: :string,
           cta_button_text: :i18n,
           description: :i18n,
-          welcome_text: :i18n,
-          homepage_image: :string,
           logo: :string,
           header_snippets: :string,
           favicon: :string,

data/app/presenters/decidim/admin_log/participatory_space_private_user_presenter.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AdminLog
+    # This class holds the logic to present a `Decidim::ParticipatorySpacePrivateUserPresenter`
+    # for the `AdminLog` log.
+    #
+    # Usage should be automatic and you shouldn't need to call this class
+    # directly, but here's an example:
+    #
+    #    action_log = Decidim::ActionLog.last
+    #    view_helpers # => this comes from the views
+    #    ParticipatorySpacePrivateUserPresenter.new(action_log, view_helpers).present
+    class ParticipatorySpacePrivateUserPresenter < Decidim::Log::BasePresenter
+      private
+
+      def diff_fields_mapping
+        {
+          name: :string,
+          email: :string
+        }
+      end
+
+      def action_string
+        case action
+        when "invite", "delete"
+          "decidim.admin_log.participatory_space_private_user.#{action}"
+        else
+          super
+        end
+      end
+
+      def i18n_labels_scope
+        "activemodel.attributes.participatory_space_private_user"
+      end
+    end
+  end
+end

data/app/presenters/decidim/metric_charts_presenter.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A presenter to render metrics in pages
+  class MetricChartsPresenter < Rectify::Presenter
+    attribute :organization, Decidim::Organization
+
+    # Public: Render a collection of primary metrics.
+    def highlighted
+      highlighted_metrics = Decidim.metrics_registry.highlighted
+      safe_join(
+        highlighted_metrics.map do |metric|
+          render_metrics_data(metric.metric_name, klass: "column medium-4")
+        end
+      )
+    end
+
+    # Public: Render a collection of metrics that are not primary.
+    def not_highlighted
+      not_highlighted_metrics = Decidim.metrics_registry.not_highlighted
+      safe_join(
+        not_highlighted_metrics.in_groups_of(2, [:empty]).map do |metrics_group|
+          content_tag :div, class: "column medium-4" do
+            safe_join(
+              metrics_group.map do |metric|
+                render_metrics_data(metric.metric_name, klass: "column medium-6", graph_klass: "small")
+              end
+            )
+          end
+        end
+      )
+    end
+
+    private
+
+    def render_metrics_data(metric_name, opts = {})
+      content_tag :div, class: opts[:klass].presence || "column medium-6" do
+        content_tag :div,
+                    "",
+                    id: "#{metric_name}_chart",
+                    class: "areachart metric-chart #{opts[:graph_klass]}",
+                    data: {
+                      chart: "areachart",
+                      metric: metric_name,
+                      info: {
+                        title: I18n.t("decidim.metrics.#{metric_name}.title"),
+                        object: I18n.t("decidim.metrics.#{metric_name}.object")
+                      }
+                    }
+      end
+    end
+  end
+end

data/app/presenters/decidim/metric_object_presenter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  #
+  # Presenter for metric objects
+  #
+  class MetricObjectPresenter < SimpleDelegator
+    def attr_int(attr, default: 0)
+      return default unless __getobj__
+      __getobj__[attr] || default
+    end
+
+    def attr_string(attr, default: "")
+      return default unless __getobj__
+      __getobj__[attr].presence || default
+    end
+
+    def attr_date(attr, default: "")
+      return default unless __getobj__
+      __getobj__[attr].try(:strftime, "%Y-%m-%d") || default
+    end
+
+    def attr_translated(attr, locale: I18n.locale, default: "")
+      return default unless __getobj__
+      __getobj__[attr].try(:[], locale.to_s).presence || default
+    end
+  end
+end

data/app/presenters/decidim/user_group_presenter.rb

@@ -4,11 +4,7 @@ module Decidim
   #
   # Decorator for user groups
   #
-  class UserGroupPresenter < SimpleDelegator
-    def nickname
-      ""
-    end
-
+  class UserGroupPresenter < UserPresenter
     def deleted?
       false
     end
@@ -19,10 +15,22 @@ module Decidim
       "verified-badge"
     end
 
-    def profile_path
-      ""
+    delegate :url, to: :avatar, prefix: true
+
+    def can_be_contacted?
+      false
     end
 
-    delegate :url, to: :avatar, prefix: true
+    def officialization_text
+      I18n.t("decidim.profiles.default_officialization_text_for_user_groups")
+    end
+
+    def can_follow?
+      false
+    end
+
+    def members_count
+      Decidim::UserGroups::AcceptedUsers.for(__getobj__).count
+    end
   end
 end

data/app/presenters/decidim/user_presenter.rb

@@ -7,6 +7,7 @@ module Decidim
   class UserPresenter < SimpleDelegator
     include Rails.application.routes.mounted_helpers
     include ActionView::Helpers::UrlHelper
+    include Decidim::TranslatableAttributes
 
     #
     # nickname presented in a twitter-like style
@@ -46,5 +47,18 @@ module Decidim
     def following_count
       __getobj__.following_users.count
     end
+
+    def can_be_contacted?
+      true
+    end
+
+    def officialization_text
+      translated_attribute(officialized_as).presence ||
+        I18n.t("decidim.profiles.default_officialization_text_for_users")
+    end
+
+    def can_follow?
+      true
+    end
   end
 end

data/app/queries/decidim/metric_manage.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This class search for objects related to Metrics, and creates a new registry within
+  # his own parameters
+  class MetricManage
+    def self.for(day_string, organization)
+      new(day_string, organization)
+    end
+
+    def initialize(day_string, organization)
+      @day = day_string.present? ? Date.parse(day_string) : Time.zone.today - 1.day
+      raise ArgumentError, "[ERROR] Malformed `day` argument. Format must be `YYYY-MM-DD` and in the past" if @day > Time.zone.today
+      @day ||= Time.zone.today - 1.day
+      @organization = organization
+      @metric_name = metric_name
+    end
+
+    def metric_name
+      ""
+    end
+
+    def valid?
+      @day.present?
+    end
+
+    def save
+      return @registry if @registry
+
+      return if cumulative.zero?
+      @registry = Decidim::Metric.find_or_initialize_by(day: @day.to_s, metric_type: @metric_name, organization: @organization)
+      @registry.assign_attributes(cumulative: cumulative, quantity: quantity)
+      @registry.save!
+      @registry
+    end
+
+    private
+
+    def start_time
+      @start_time ||= @day.beginning_of_day
+    end
+
+    def end_time
+      @end_time ||= @day.end_of_day
+    end
+
+    def query
+      raise "Not implemented"
+    end
+
+    def cumulative
+      @cumulative ||= query.count
+    end
+
+    def quantity
+      @quantity ||= cumulative
+    end
+  end
+end