decidim-elections 0.23.6 → 0.24.0.rc1

data/app/models/decidim/elections/trustees_participatory_space.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    # The data store for a trustee participatory space in the Decidim::Elections component. It has a reference
+    # to a trustee (user), a polymorphic reference to participatory spaces and stores the status (considered)
+    # for the trustee.
+    class TrusteesParticipatorySpace < ApplicationRecord
+      belongs_to :trustee, foreign_key: "decidim_elections_trustee_id", class_name: "Decidim::Elections::Trustee", inverse_of: :trustees_participatory_spaces
+      belongs_to :participatory_space, foreign_type: "participatory_space_type", polymorphic: true
+    end
+  end
+end

data/app/models/decidim/elections/vote.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    # The data store for a Vote in the Decidim::Election component. It stores the hash computed from the `encrypted_vote` associated to a particular `voter_id`.
+    class Vote < ApplicationRecord
+      enum status: [:pending, :accepted, :rejected].map { |status| [status, status.to_s] }.to_h
+
+      belongs_to :election, foreign_key: "decidim_elections_election_id", class_name: "Decidim::Elections::Election"
+      belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
+
+      validates :voter_id, :encrypted_vote_hash, presence: true
+    end
+  end
+end

data/app/models/decidim/votings/monitoring_committee_member.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    class MonitoringCommitteeMember < ApplicationRecord
+      include Traceable
+      include Loggable
+
+      belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User", optional: true
+      belongs_to :voting, foreign_key: "decidim_votings_voting_id", class_name: "Decidim::Votings::Voting", inverse_of: :monitoring_committee_members
+
+      validate :user_and_voting_same_organization
+
+      private
+
+      # Private: check if the voting and the user have the same organization
+      def user_and_voting_same_organization
+        return if !voting || !user
+
+        errors.add(:voting, :invalid) unless user.organization == voting.organization
+      end
+    end
+  end
+end

data/app/models/decidim/votings/polling_officer.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    class PollingOfficer < ApplicationRecord
+      include Traceable
+      include Loggable
+
+      belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
+      belongs_to :voting, foreign_key: "decidim_votings_voting_id", class_name: "Decidim::Votings::Voting", inverse_of: :polling_officers
+      belongs_to :managed_polling_station,
+                 class_name: "Decidim::Votings::PollingStation",
+                 inverse_of: :polling_station_managers,
+                 optional: true
+      belongs_to :presided_polling_station,
+                 class_name: "Decidim::Votings::PollingStation",
+                 inverse_of: :polling_station_president,
+                 optional: true
+
+      validates :user, uniqueness: { scope: :voting }
+      validate :user_and_voting_same_organization
+      validate :either_president_or_manager
+
+      delegate :name, :nickname, :email, to: :user
+
+      # Allow ransacker to search by presided/managed polling station title
+      %w(managed_station presided_station).each do |table|
+        ransacker "#{table}_title".to_sym do
+          Arel::Nodes::InfixOperation.new("->>", Arel.sql("#{table}.title"), Arel::Nodes.build_quoted(I18n.locale.to_s))
+        end
+      end
+
+      # Allow ransacker to search by user attributes
+      [:name, :email, :nickname].each do |field|
+        ransacker field do
+          Arel.sql("decidim_users.#{field}")
+        end
+      end
+
+      def self.polling_officer?(user)
+        exists?(user: user)
+      end
+
+      def self.for(user)
+        where(user: user)
+      end
+
+      def role
+        return :president if presided_polling_station.present?
+        return :manager if managed_polling_station.present?
+
+        :unassigned
+      end
+
+      def polling_station
+        presided_polling_station || managed_polling_station
+      end
+
+      private
+
+      # Private: check if the voting and the user have the same organization
+      def user_and_voting_same_organization
+        return if voting.nil? || user.nil?
+
+        errors.add(:voting, :different_organization) unless user.organization == voting.organization
+      end
+
+      # Private: check if the voting and the user have the same organization
+      def either_president_or_manager
+        return if presided_polling_station.nil? || managed_polling_station.nil?
+
+        errors.add(:presided_polling_station, :president_and_manager)
+      end
+    end
+  end
+end

data/app/models/decidim/votings/polling_station.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # The data store for a PollingStation in the Votings::Voting partecipatory space.
+    class PollingStation < ApplicationRecord
+      include Traceable
+      include Loggable
+      include Decidim::TranslatableResource
+
+      translatable_fields :title, :location, :location_hints
+
+      belongs_to :voting, foreign_key: "decidim_votings_voting_id", class_name: "Decidim::Votings::Voting", inverse_of: :polling_stations
+      has_many :polling_station_managers,
+               foreign_key: "managed_polling_station_id",
+               class_name: "Decidim::Votings::PollingOfficer",
+               inverse_of: :managed_polling_station,
+               dependent: :nullify
+      has_one :polling_station_president,
+              foreign_key: "presided_polling_station_id",
+              class_name: "Decidim::Votings::PollingOfficer",
+              inverse_of: :presided_polling_station,
+              dependent: :nullify
+
+      validate :polling_station_managers_same_voting
+      validate :polling_station_president_same_voting
+
+      # Allow ransacker to search for a key in a hstore column (`title`.`en`)
+      ransacker :title do |parent|
+        Arel::Nodes::InfixOperation.new("->>", parent.table[:title], Arel::Nodes.build_quoted(I18n.locale.to_s))
+      end
+
+      [:manager, :president].each do |role|
+        [:name, :email, :nickname].each do |field|
+          ransacker "#{role}_#{field}".to_sym do
+            Arel.sql("#{role}_user.#{field}")
+          end
+        end
+      end
+
+      geocoded_by :address
+
+      def missing_officers?
+        polling_station_president.nil? || polling_station_managers.empty?
+      end
+
+      private
+
+      # Private: check if the president is in the same voting
+      def polling_station_president_same_voting
+        return if polling_station_president.nil?
+
+        errors.add(:polling_station_president, :different_voting) unless voting == polling_station_president.voting
+      end
+
+      # Private: check if the managers are in the same voting
+      def polling_station_managers_same_voting
+        return if polling_station_managers.empty?
+
+        errors.add(:polling_station_managers, :different_voting) unless polling_station_managers.all? { |manager| manager.voting == voting }
+      end
+    end
+  end
+end

data/app/models/decidim/votings/voting.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    class Voting < ApplicationRecord
+      include Traceable
+      include Loggable
+      include Decidim::Followable
+      include Decidim::Participable
+      include Decidim::ParticipatorySpaceResourceable
+      include Decidim::Randomable
+      include Decidim::Searchable
+      include Decidim::TranslatableResource
+      include Decidim::ScopableParticipatorySpace
+      include Decidim::Publicable
+      include Decidim::HasUploadValidations
+      include Decidim::HasAttachments
+      include Decidim::HasAttachmentCollections
+
+      enum voting_type: [:in_person, :online, :hybrid].map { |type| [type, type.to_s] }.to_h, _suffix: :voting
+
+      translatable_fields :title, :description
+
+      belongs_to :organization,
+                 foreign_key: "decidim_organization_id",
+                 class_name: "Decidim::Organization"
+
+      has_many :components, as: :participatory_space, dependent: :destroy
+      has_many :polling_stations, foreign_key: "decidim_votings_voting_id", class_name: "Decidim::Votings::PollingStation", inverse_of: :voting, dependent: :destroy
+      has_many :polling_officers, foreign_key: "decidim_votings_voting_id", class_name: "Decidim::Votings::PollingOfficer", inverse_of: :voting, dependent: :destroy
+      has_many :monitoring_committee_members,
+               foreign_key: "decidim_votings_voting_id",
+               class_name: "Decidim::Votings::MonitoringCommitteeMember",
+               inverse_of: :voting,
+               dependent: :destroy
+
+      validates :slug, uniqueness: { scope: :organization }
+      validates :slug, presence: true, format: { with: Decidim::Votings::Voting.slug_format }
+
+      validates_upload :banner_image
+      mount_uploader :banner_image, Decidim::BannerImageUploader
+
+      validates_upload :introductory_image
+      mount_uploader :introductory_image, Decidim::BannerImageUploader
+
+      scope :upcoming, -> { published.where("start_time > ?", Time.now.utc) }
+      scope :active, lambda {
+        published
+          .where("start_time <= ?", Time.now.utc)
+          .where("end_time >= ?", Time.now.utc)
+      }
+      scope :finished, -> { published.where("end_time < ?", Time.now.utc) }
+      scope :order_by_most_recent, -> { order(created_at: :desc) }
+      scope :promoted, -> { published.where(promoted: true) }
+
+      def upcoming?
+        start_time > Time.now.utc
+      end
+
+      def active?
+        start_time <= Time.now.utc && end_time >= Time.now.utc
+      end
+
+      def finished?
+        end_time < Time.now.utc
+      end
+
+      def period_status
+        if finished?
+          :finished
+        elsif active?
+          :ongoing
+        else
+          :upcoming
+        end
+      end
+
+      searchable_fields({
+                          scope_id: :decidim_scope_id,
+                          participatory_space: :itself,
+                          A: :title,
+                          B: :description,
+                          datetime: :published_at
+                        },
+                        index_on_create: ->(_voting) { false },
+                        index_on_update: ->(voting) { voting.visible? })
+
+      def self.log_presenter_class_for(_log)
+        Decidim::Votings::AdminLog::VotingPresenter
+      end
+
+      # Allow ransacker to search for a key in a hstore column (`title`.`en`)
+      ransacker :title do |parent|
+        Arel::Nodes::InfixOperation.new("->>", parent.table[:title], Arel::Nodes.build_quoted(I18n.locale.to_s))
+      end
+
+      def to_param
+        slug
+      end
+
+      def cta_button_text_key
+        return :vote if published? && active?
+
+        :more_info
+      end
+
+      def attachment_context
+        :admin
+      end
+
+      def scopes_enabled
+        true
+      end
+
+      def needs_elections?
+        !in_person_voting? && !has_elections?
+      end
+
+      def polling_stations_with_missing_officers?
+        !online_voting? && polling_stations.any?(&:missing_officers?)
+      end
+
+      def available_polling_officers
+        polling_officers
+          .where(presided_polling_station_id: nil)
+          .where(managed_polling_station_id: nil)
+      end
+
+      private
+
+      def has_elections?
+        components.where(manifest_name: :elections).any? do |component|
+          Decidim::Elections::Election.where(component: component).any?
+        end
+      end
+    end
+  end
+end

data/app/permissions/decidim/elections/admin/permissions.rb

@@ -10,19 +10,43 @@ module Decidim
           case permission_action.subject
           when :question, :answer
             case permission_action.action
-            when :create, :update, :delete
-              allow_if_not_started
-            when :import_proposals
-              allow_if_not_started
+            when :create, :update, :delete, :import_proposals
+              allow_if_not_blocked
+            when :select
+              allow_if_results
+            end
+          when :steps
+            case permission_action.action
+            when :read, :update
+              allow!
             end
           when :election
             case permission_action.action
             when :create, :read
               allow!
             when :delete, :update, :unpublish
-              allow_if_not_started
+              allow_if_not_blocked
             when :publish
-              allow_if_valid_and_not_started
+              allow_if_valid_and_not_blocked
+            end
+          when :trustee_participatory_space
+            case permission_action.action
+            when :create, :update
+              allow!
+            when :delete
+              allow_if_not_related_to_any_election
+            end
+          when :questionnaire
+            case permission_action.action
+            when :export_answers
+              permission_action.allow!
+            when :update
+              toggle_allow(feedback_form.present?)
+            end
+          when :questionnaire_answers
+            case permission_action.action
+            when :index, :show, :export_response
+              permission_action.allow!
             end
           end
 
@@ -39,12 +63,28 @@ module Decidim
           @question ||= context.fetch(:question, nil)
         end
 
-        def allow_if_not_started
-          toggle_allow(election && !election.started?)
+        def trustee_participatory_space
+          @trustee_participatory_space ||= context.fetch(:trustee_participatory_space, nil)
+        end
+
+        def allow_if_results
+          toggle_allow(election && election.results?)
+        end
+
+        def allow_if_not_blocked
+          toggle_allow(election && !election.blocked?)
+        end
+
+        def allow_if_valid_and_not_blocked
+          toggle_allow(election && !election.blocked? && election.valid_questions?)
+        end
+
+        def allow_if_not_related_to_any_election
+          toggle_allow(trustee_participatory_space.trustee.elections.empty?)
         end
 
-        def allow_if_valid_and_not_started
-          toggle_allow(election && !election.started? && election.valid_questions?)
+        def feedback_form
+          @feedback_form ||= context.fetch(:questionnaire, nil)
         end
       end
     end

data/app/permissions/decidim/elections/permissions.rb

@@ -4,14 +4,18 @@ module Decidim
   module Elections
     class Permissions < Decidim::DefaultPermissions
       def permissions
-        # Anonymous users can only view elections
-        toggle_allow(can_view?) if permission_action.scope == :public && permission_action.subject == :election && permission_action.action == :view
+        check_view_election_permissions
+
+        toggle_allow(can_answer_feedback?) if permission_action.scope == :public && permission_action.subject == :questionnaire && permission_action.action == :answer
 
         return permission_action unless user
 
         # Delegate the admin permission checks to the admin permissions class
         return Decidim::Elections::Admin::Permissions.new(user, permission_action, context).permissions if permission_action.scope == :admin
 
+        # Delegate the trustee_zone permission checks to the trustee zone permissions class
+        return Decidim::Elections::TrusteeZone::Permissions.new(user, permission_action, context).permissions if permission_action.scope == :trustee_zone
+
         return permission_action if permission_action.scope != :public
         return permission_action if permission_action.subject != :election
 
@@ -27,6 +31,14 @@ module Decidim
 
       private
 
+      def check_view_election_permissions
+        return unless permission_action.scope == :public &&
+                      permission_action.action == :view &&
+                      permission_action.subject == :election
+
+        toggle_allow(can_view?)
+      end
+
       def can_view?
         election.published? || user&.admin?
       end
@@ -43,6 +55,12 @@ module Decidim
         authorized?(:vote, resource: election)
       end
 
+      def can_answer_feedback?
+        return unless user && election
+
+        authorized_to_vote? && !election.questionnaire.answered_by?(user)
+      end
+
       def election
         @election ||= context[:election]
       end

data/app/permissions/decidim/elections/trustee_zone/permissions.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    module TrusteeZone
+      class Permissions < Decidim::DefaultPermissions
+        def permissions
+          return permission_action unless permission_action.scope == :trustee_zone
+
+          case permission_action.subject
+          when :trustee, :election
+            toggle_allow(trustee_for_user?) if [:view, :update].member?(permission_action.action)
+          when :user
+            allow! if permission_action.action == :update_profile
+          end
+
+          permission_action
+        end
+
+        private
+
+        def trustee_for_user?
+          trustee && trustee.user == user
+        end
+
+        def trustee
+          @trustee ||= context.fetch(:trustee, nil)
+        end
+      end
+    end
+  end
+end

data/app/permissions/decidim/votings/admin/permissions.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      class Permissions < Decidim::DefaultPermissions
+        def permissions
+          return permission_action unless user
+          return permission_action unless permission_action.scope == :admin
+
+          return permission_action if voting && !voting.is_a?(Decidim::Votings::Voting)
+
+          unless user.admin?
+            disallow!
+            return permission_action
+          end
+
+          user_can_enter_space_area?
+
+          if read_admin_dashboard_action?
+            allow!
+            return permission_action
+          end
+
+          allowed_read_participatory_space?
+          allowed_action_on_component?
+          allowed_voting_action?
+
+          permission_action
+        end
+
+        private
+
+        def user_can_enter_space_area?
+          return unless permission_action.action == :enter &&
+                        permission_action.subject == :space_area &&
+                        context.fetch(:space_name, nil) == :votings
+
+          allow!
+        end
+
+        def read_admin_dashboard_action?
+          permission_action.action == :read &&
+            permission_action.subject == :admin_dashboard
+        end
+
+        def allowed_read_participatory_space?
+          return unless permission_action.action == :read &&
+                        permission_action.subject == :participatory_space
+
+          allow!
+        end
+
+        def allowed_action_on_component?
+          return unless permission_action.subject == :component
+
+          allow!
+        end
+
+        def allowed_voting_action?
+          return unless
+          [
+            :votings, :voting,
+            :polling_station, :polling_stations,
+            :polling_officer, :polling_officers,
+            :monitoring_committee_member, :monitoring_committee_members
+          ].member? permission_action.subject
+
+          case permission_action.subject
+          when :votings
+            toggle_allow(user.admin?) if permission_action.action == :read
+          when :voting
+            case permission_action.action
+            when :read, :create, :publish, :unpublish
+              allow!
+            when :update, :preview, :manage_landing_page
+              toggle_allow(voting.present?)
+            end
+          when :polling_station
+            case permission_action.action
+            when :create
+              allow!
+            when :update, :delete
+              toggle_allow(polling_station.present?)
+            end
+          when :polling_stations
+            toggle_allow(user.admin?) if permission_action.action == :read
+          when :polling_officer
+            case permission_action.action
+            when :create
+              allow!
+            when :delete
+              toggle_allow(polling_officer.present?)
+            end
+          when :polling_officers
+            toggle_allow(user.admin?) if permission_action.action == :read
+          when :monitoring_committee_member
+            case permission_action.action
+            when :create
+              allow!
+            when :delete
+              toggle_allow(monitoring_committee_member.present?)
+            end
+          when :monitoring_committee_members
+            toggle_allow(user.admin?) if permission_action.action == :read
+          end
+        end
+
+        def voting
+          @voting ||= context.fetch(:voting, nil) || context.fetch(:participatory_space, nil)
+        end
+
+        def polling_station
+          @polling_station ||= context.fetch(:polling_station, nil)
+        end
+
+        def polling_officer
+          @polling_officer ||= context.fetch(:polling_officer, nil)
+        end
+
+        def monitoring_committee_member
+          @monitoring_committee_member ||= context.fetch(:monitoring_committee_member, nil)
+        end
+      end
+    end
+  end
+end

data/app/permissions/decidim/votings/permissions.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    class Permissions < Decidim::DefaultPermissions
+      def permissions
+        allowed_public_anonymous_action?
+
+        return permission_action unless user
+
+        return Decidim::Votings::Admin::Permissions.new(user, permission_action, context).permissions if permission_action.scope == :admin
+
+        # Delegate the polling_officer_zone permission checks to the polling officer zone permissions class
+        return Decidim::Votings::PollingOfficerZone::Permissions.new(user, permission_action, context).permissions if permission_action.scope == :polling_officer_zone
+
+        permission_action
+      end
+
+      private
+
+      def voting
+        @voting ||= context.fetch(:voting, nil)
+      end
+
+      def allowed_public_anonymous_action?
+        return unless permission_action.action == :read
+        return unless permission_action.scope == :public
+
+        case permission_action.subject
+        when :votings
+          allow!
+        when :voting
+          toggle_allow(voting.published? || user&.admin?)
+        when :participatory_space
+          allow!
+        end
+      end
+    end
+  end
+end