decidim-elections 0.23.1 → 0.24.0.rc2

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    # The data store for an Election-Trustee relation in the Decidim::Elections component.
+    class ElectionsTrustee < ApplicationRecord
+      belongs_to :election, foreign_key: "decidim_elections_election_id", class_name: "Decidim::Elections::Election", optional: true
+      belongs_to :trustee, foreign_key: "decidim_elections_trustee_id", class_name: "Decidim::Elections::Trustee", optional: true
+    end
+  end
+end

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

@@ -22,6 +22,25 @@ module Decidim
       def valid_max_selection?
         max_selections <= answers.count
       end
+
+      def vote_variation
+        if max_selections == 1
+          "one_of_m"
+        else
+          "n_of_m"
+        end
+      end
+
+      def total_votes
+        answers.sum(:votes_count)
+      end
+
+      def votes_percentage(answer_votes)
+        return 0 unless answer_votes.positive?
+
+        result = answer_votes.to_f / total_votes * 100.0
+        result.round
+      end
     end
   end
 end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    # The data store for a trustee in the Decidim::Elections component. It stores a
+    # public key and has a reference to Decidim::User.
+    class Trustee < ApplicationRecord
+      belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
+      has_many :elections_trustees, foreign_key: "decidim_elections_trustee_id", dependent: :destroy
+      has_many :elections, through: :elections_trustees
+      has_many :trustees_participatory_spaces, inverse_of: :trustee, foreign_key: "decidim_elections_trustee_id", dependent: :destroy
+
+      def self.trustee?(user)
+        exists?(user: user)
+      end
+
+      def self.for(user)
+        find_by(user: user)
+      end
+
+      def unique_id
+        name.parameterize
+      end
+    end
+  end
+end

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