decidim 0.4.4 → 0.5.0

data/decidim-core/app/models/decidim/participatory_process_step.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A ParticipatoryProcess is composed of many steps that hold different
+  # features that will show up in the depending on what step is currently
+  # active.
+  class ParticipatoryProcessStep < ApplicationRecord
+    belongs_to :participatory_process, foreign_key: "decidim_participatory_process_id", class_name: "Decidim::ParticipatoryProcess"
+    has_one :organization, through: :participatory_process
+
+    validates :start_date, date: { before: :end_date, allow_blank: true, if: proc { |obj| obj.end_date.present? } }
+    validates :end_date, date: { after: :start_date, allow_blank: true, if: proc { |obj| obj.start_date.present? } }
+
+    validates :active, uniqueness: { scope: :decidim_participatory_process_id }, if: proc { |step| step.active? }
+
+    validates :position, numericality: { greater_than_or_equal_to: 0, only_integer: true }, allow_blank: true
+    validates :position, uniqueness: { scope: :decidim_participatory_process_id }
+
+    before_create :set_position
+
+    private
+
+    # Internal: Sets the position of the step if it is `nil`. That means that
+    # when the step is the first of the process, and no position is set
+    # manually, it will be set to 0, and when it is not the only one it will be
+    # set to the last step's position + 1.
+    #
+    # Note: This allows manual positioning, but there is a validation that
+    # forbids two steps from the same proccess to have the same position. Take
+    # that into account. It would be best if you did not use manual
+    # positioning.
+    def set_position
+      return if position.present?
+      return self.position = 0 if participatory_process.steps.select(&:persisted?).empty?
+
+      self.position = participatory_process.steps.pluck(:position).last + 1
+    end
+  end
+end

data/decidim-core/app/models/decidim/participatory_process_user_role.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Defines a relation between a user and a participatory process, and what
+  # kind of relation does the user has.
+  class ParticipatoryProcessUserRole < ApplicationRecord
+    belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User", optional: true
+    belongs_to :participatory_process, foreign_key: "decidim_participatory_process_id", class_name: "Decidim::ParticipatoryProcess", optional: true
+
+    ROLES = %w(admin collaborator moderator).freeze
+    validates :role, inclusion: { in: ROLES }, uniqueness: { scope: [:user, :participatory_process] }
+    validate :user_and_participatory_process_same_organization
+
+    private
+
+    # Private: check if the process and the user have the same organization
+    def user_and_participatory_process_same_organization
+      return if !participatory_process || !user
+      errors.add(:participatory_process, :invalid) unless user.organization == participatory_process.organization
+    end
+  end
+end

data/decidim-core/app/models/decidim/report.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A reportable can be reported one time for each user.
+  class Report < ApplicationRecord
+    REASONS = %w(spam offensive does_not_belong).freeze
+
+    belongs_to :moderation, foreign_key: "decidim_moderation_id", class_name: "Decidim::Moderation"
+    belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
+
+    validates :reason, presence: true
+    validates :user, uniqueness: { scope: :decidim_moderation_id }
+    validates :reason, inclusion: { in: REASONS }
+    validate :user_and_moderation_same_organization
+
+    private
+
+    # Private: check if the moderation and the user have the same organization
+    def user_and_moderation_same_organization
+      return if !moderation || !user
+      errors.add(:moderation, :invalid) unless user.organization == moderation.organization
+    end
+  end
+end

data/decidim-core/app/models/decidim/resource_link.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A ResourceLink allows linking resources (other entities in Decidim) between
+  # them without them having to know each other.
+  #
+  # In order to group the relations between resources you need to specify a name.
+  #
+  # Some examples could be: proposals that have been created in a meeting or
+  # projects that are a result of merging diffrent proposals.
+  class ResourceLink < ApplicationRecord
+    belongs_to :from, polymorphic: true
+    belongs_to :to, polymorphic: true
+
+    validates :name, presence: true, uniqueness: { scope: [:from, :to] }
+
+    validate :same_organization
+
+    private
+
+    def same_organization
+      return if from.try(:organization) == to.try(:organization)
+
+      errors.add(:from, :invalid)
+      errors.add(:to, :invalid)
+    end
+  end
+end

data/decidim-core/app/models/decidim/scope.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Scopes are used in some entities through Decidim to help users know which is
+  # the scope of a participatory process.
+  # (i.e. does it affect the whole city or just a district?)
+  class Scope < ApplicationRecord
+    belongs_to :organization,
+               foreign_key: "decidim_organization_id",
+               class_name: "Decidim::Organization",
+               inverse_of: :scopes
+
+    belongs_to :scope_type,
+               foreign_key: "scope_type_id",
+               class_name: "Decidim::ScopeType",
+               inverse_of: :scopes,
+               optional: true
+
+    belongs_to :parent,
+               foreign_key: "parent_id",
+               class_name: "Decidim::Scope",
+               inverse_of: :children,
+               optional: true
+
+    has_many :children,
+             foreign_key: "parent_id",
+             class_name: "Decidim::Scope",
+             inverse_of: :parent
+
+    before_validation :update_part_of, on: :update
+
+    validates :name, :code, :organization, presence: true
+    validates :code, uniqueness: { scope: :organization }
+    validate :forbid_cycles
+
+    after_create_commit :create_part_of
+
+    # Scope to return only the top level scopes.
+    #
+    # Returns an ActiveRecord::Relation.
+    def self.top_level
+      where parent_id: nil
+    end
+
+    def descendants
+      organization.scopes.where("? = ANY(decidim_scopes.part_of)", id)
+    end
+
+    # Gets the scopes from the part_of list
+    #
+    # Returns an ActiveRecord::Relation.
+    def part_of_scopes
+      organization.scopes.where(id: part_of)
+    end
+
+    private
+
+    def forbid_cycles
+      errors.add(:parent_id, :cycle_detected) if parent && parent.part_of.include?(id)
+    end
+
+    def create_part_of
+      self[:part_of] = calculate_part_of
+      save if changed?
+    end
+
+    def update_part_of
+      self[:part_of] = calculate_part_of
+    end
+
+    def calculate_part_of
+      if parent
+        [id] + parent.part_of
+      else
+        [id]
+      end
+    end
+  end
+end

data/decidim-core/app/models/decidim/scope_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Scope types allows to use different types of scopes in participatory process
+  # (municipalities, provinces, states, countries, etc.)
+  class ScopeType < ApplicationRecord
+    belongs_to :organization,
+               foreign_key: "decidim_organization_id",
+               class_name: "Decidim::Organization",
+               inverse_of: :scope_types
+
+    has_many :scopes, foreign_key: "decidim_scope_type_id", class_name: "Decidim::Scope", inverse_of: :scope_type
+
+    validates :name, presence: true
+  end
+end

data/decidim-core/app/models/decidim/static_page.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A page is used to add static content to the website, it can be useful so
+  # organization can add their own terms and conditions, privacy policy or
+  # other pages they might need from an admin panel.
+  #
+  # Pages with a default slug cannot be destroyed and its slug cannot be
+  # modified.
+  class StaticPage < ApplicationRecord
+    belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization", inverse_of: :static_pages
+
+    validates :slug, presence: true, uniqueness: { scope: :organization }
+    validates :slug, format: { with: /\A[a-z0-9-]+/ }
+
+    # These pages will be created by default when registering an organization
+    # and cannot be deleted.
+    DEFAULT_PAGES = %w(faq terms-and-conditions accessibility).freeze
+
+    before_destroy :can_be_destroyed?
+    before_update :can_update_slug?
+
+    # Whether this is slug of a default page or not.
+    #
+    # slug - The String with the value of the slug.
+    #
+    # Returns Boolean.
+    def self.default?(slug)
+      DEFAULT_PAGES.include?(slug)
+    end
+
+    # Whether this is page is a default one or not.
+    #
+    # Returns Boolean.
+    def default?
+      self.class.default?(slug)
+    end
+
+    # Customize to_param so when we want to create a link to a page we use the
+    # slug instead of the id.
+    #
+    # Returns a String.
+    def to_param
+      slug
+    end
+
+    private
+
+    def can_be_destroyed?
+      throw(:abort) if default?
+    end
+
+    def can_update_slug?
+      throw(:abort) if slug_changed? && self.class.default?(slug_was)
+    end
+  end
+end

data/decidim-core/app/models/decidim/user.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require_dependency "devise/models/decidim_validatable"
+
+module Decidim
+  # A User is a citizen that wants to join the platform to participate.
+  class User < ApplicationRecord
+    MAXIMUM_AVATAR_FILE_SIZE = 5.megabytes
+    ROLES = %w(admin user_manager).freeze
+
+    devise :invitable, :database_authenticatable, :registerable, :confirmable,
+           :recoverable, :rememberable, :trackable, :decidim_validatable,
+           :omniauthable, omniauth_providers: [:facebook, :twitter, :google_oauth2],
+                          request_keys: [:env], reset_password_keys: [:decidim_organization_id, :email]
+
+    belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
+    has_many :authorizations, foreign_key: "decidim_user_id", class_name: "Decidim::Authorization", inverse_of: :user
+    has_many :identities, foreign_key: "decidim_user_id", class_name: "Decidim::Identity"
+    has_many :memberships, class_name: "Decidim::UserGroupMembership", foreign_key: :decidim_user_id
+    has_many :user_groups, through: :memberships, class_name: "Decidim::UserGroup", foreign_key: :decidim_user_group_id
+
+    validates :name, presence: true, unless: -> { deleted? }
+    validates :locale, inclusion: { in: Decidim.available_locales.map(&:to_s) }, allow_blank: true
+    validates :tos_agreement, acceptance: true, allow_nil: false, on: :create
+    validates :avatar, file_size: { less_than_or_equal_to: MAXIMUM_AVATAR_FILE_SIZE }
+    validates :email, uniqueness: { scope: :organization }, unless: -> { deleted? || managed? }
+    validate :all_roles_are_valid
+
+    mount_uploader :avatar, Decidim::AvatarUploader
+
+    scope :not_deleted, -> { where(deleted_at: nil) }
+    scope :managed, -> { where(managed: true) }
+
+    # Public: Allows customizing the invitation instruction email content when
+    # inviting a user.
+    #
+    # Returns a String.
+    attr_accessor :invitation_instructions
+
+    # Checks if the user has the given `role` or not.
+    #
+    # role - a String or a Symbol that represents the role that is being
+    #   checked
+    #
+    # Returns a boolean.
+    def role?(role)
+      roles.include?(role.to_s)
+    end
+
+    # Public: Returns the active role of the user
+    def active_role
+      admin ? "admin" : roles.first
+    end
+
+    # Public: returns the user's name or the default one
+    def name
+      super || I18n.t("decidim.anonymous_user")
+    end
+
+    # Check if the user account has been deleted or not
+    def deleted?
+      deleted_at.present?
+    end
+
+    # Check if the user exists with the given email and the current organization
+    #
+    # warden_conditions - A hash with the authentication conditions
+    #                   * email - a String that represents user's email.
+    #                   * env - A Hash containing environment variables.
+    # Returns a User.
+    def self.find_for_authentication(warden_conditions)
+      organization = warden_conditions.dig(:env, "decidim.current_organization")
+      where(
+        email: warden_conditions[:email],
+        decidim_organization_id: organization.id
+      ).first
+    end
+
+    protected
+
+    # Overrides devise email required validation.
+    # If the user has been deleted or it is managed the email field is not required anymore.
+    def email_required?
+      return false if deleted? || managed?
+      super
+    end
+
+    # Overrides devise password required validation.
+    # If the user is managed the password field is not required anymore.
+    def password_required?
+      return false if managed?
+      super
+    end
+
+    private
+
+    # Changes default Devise behaviour to use ActiveJob to send async emails.
+    def send_devise_notification(notification, *args)
+      devise_mailer.send(notification, self, *args).deliver_later
+    end
+
+    def all_roles_are_valid
+      errors.add(:roles, :invalid) unless roles.all? { |role| ROLES.include?(role) }
+    end
+  end
+end

data/decidim-core/app/models/decidim/user_group.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A UserGroup is an organization of citizens
+  class UserGroup < ApplicationRecord
+    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
+    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 :phone, presence: true
+    validates :avatar, file_size: { less_than_or_equal_to: 5.megabytes }
+
+    validate :correct_state
+
+    mount_uploader :avatar, Decidim::AvatarUploader
+
+    scope :verified, -> { where.not(verified_at: nil) }
+    scope :rejected, -> { where.not(rejected_at: nil) }
+
+    # Public: Checks if the user group is verified.
+    def verified?
+      verified_at.present?
+    end
+
+    # Public: Checks if the user group is rejected.
+    def rejected?
+      rejected_at.present?
+    end
+
+    # Public: Checks if the user group is pending.
+    def pending?
+      verified_at.blank? && rejected_at.blank?
+    end
+
+    private
+
+    # Private: Checks if the state user group is correct.
+    def correct_state
+      errors.add(:base, :invalid) if verified? && rejected?
+    end
+  end
+end

data/decidim-core/app/models/decidim/user_group_membership.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A UserGroupMembership associate user with user groups
+  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
+  end
+end

data/decidim-core/app/presenters/decidim/home_stats_presenter.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A presenter to render statistics in the homepage.
+  class HomeStatsPresenter < Rectify::Presenter
+    attribute :organization, Decidim::Organization
+
+    # Public: Render a collection of primary stats.
+    def highlighted
+      highlighted_stats = Decidim.stats.only([:users_count, :processes_count]).with_context(organization).map { |name, data| [name, data] }
+      highlighted_stats = highlighted_stats.concat(global_stats(priority: StatsRegistry::HIGH_PRIORITY))
+      highlighted_stats = highlighted_stats.concat(feature_stats(priority: StatsRegistry::HIGH_PRIORITY))
+      highlighted_stats = highlighted_stats.reject(&:empty?)
+      highlighted_stats = highlighted_stats.reject { |_name, data| data.zero? }
+
+      safe_join(
+        highlighted_stats.in_groups_of(2, false).map do |stats|
+          content_tag :div, class: "home-pam__highlight" do
+            safe_join(
+              stats.map do |name, data|
+                render_stats_data(name, data)
+              end
+            )
+          end
+        end
+      )
+    end
+
+    # Public: Render a collection of stats that are not primary.
+    def not_highlighted
+      not_highlighted_stats = global_stats(priority: StatsRegistry::MEDIUM_PRIORITY)
+      not_highlighted_stats = not_highlighted_stats.concat(feature_stats(priority: StatsRegistry::MEDIUM_PRIORITY))
+      not_highlighted_stats = not_highlighted_stats.reject(&:empty?)
+      not_highlighted_stats = not_highlighted_stats.reject { |_name, data| data.zero? }
+
+      safe_join(
+        not_highlighted_stats.in_groups_of(3, [:empty]).map do |stats|
+          content_tag :div, class: "home-pam__lowlight" do
+            safe_join(
+              stats.map do |name, data|
+                render_stats_data(name, data)
+              end
+            )
+          end
+        end
+      )
+    end
+
+    private
+
+    def global_stats(conditions)
+      Decidim.stats.except([:users_count, :processes_count])
+             .filter(conditions)
+             .with_context(published_features)
+             .map { |name, data| [name, data] }
+    end
+
+    def feature_stats(conditions)
+      Decidim.feature_manifests.map do |feature|
+        feature.stats.filter(conditions).with_context(published_features).map { |name, data| [name, data] }.flatten
+      end
+    end
+
+    def render_stats_data(name, data)
+      content_tag :div, "", class: "home-pam__data" do
+        if name == :empty
+          "&nbsp;".html_safe
+        else
+          safe_join([
+                      content_tag(:h4, I18n.t(name, scope: "pages.home.statistics"), class: "home-pam__title"),
+                      content_tag(:span, " #{number_with_delimiter(data)}", class: "home-pam__number #{name}")
+                    ])
+        end
+      end
+    end
+
+    def published_features
+      @published_features ||= Feature.where(participatory_process: OrganizationPublishedParticipatoryProcesses.new(organization).query).published
+    end
+  end
+end