decidim-elections 0.24.3 → 0.25.0.rc1

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

@@ -7,7 +7,7 @@ module Decidim
       belongs_to :election, foreign_key: "decidim_elections_election_id", class_name: "Decidim::Elections::Election"
 
       enum status: [:pending, :accepted, :rejected]
-      enum action: [:start_key_ceremony, :start_vote, :end_vote, :start_tally]
+      enum action: [:start_key_ceremony, :start_vote, :end_vote, :start_tally, :publish_results]
     end
   end
 end

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

@@ -16,6 +16,7 @@ module Decidim
       belongs_to :question, foreign_key: "decidim_elections_question_id", class_name: "Decidim::Elections::Question", inverse_of: :answers
       has_one :election, through: :question, foreign_key: "decidim_elections_election_id", class_name: "Decidim::Elections::Election"
       has_one :component, through: :election, foreign_key: "decidim_component_id", class_name: "Decidim::Component"
+      has_many :results, foreign_key: "decidim_elections_answer_id", class_name: "Decidim::Elections::Result", dependent: :destroy
 
       default_scope { order(weight: :asc, id: :asc) }
 
@@ -25,6 +26,26 @@ module Decidim
       def proposals
         linked_resources(:proposals, "related_proposals")
       end
+
+      def slug
+        "answer-#{id}"
+      end
+
+      # Sum all valid results from different origins (PollingStations or BulletinBoard)
+      def results_total
+        @results_total ||= results.valid_answers.sum(:value)
+      end
+
+      # A result percentage relative to the question
+      # Returns a Float.
+      def results_percentage
+        @results_percentage ||= begin
+          return 0 unless results_total.positive?
+
+          result = results_total.to_f / question.results_total * 100.0
+          result.round
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    # The data store for an Election Closure.
+    class BulletinBoardClosure < ApplicationRecord
+      belongs_to :election,
+                 foreign_key: "decidim_elections_election_id",
+                 class_name: "Decidim::Elections::Election",
+                 inverse_of: :bb_closure
+
+      has_many :results,
+               foreign_type: "closurable_type",
+               class_name: "Decidim::Elections::Result",
+               dependent: :destroy,
+               as: :closurable
+    end
+  end
+end

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

@@ -16,8 +16,8 @@ module Decidim
       include Decidim::Forms::HasQuestionnaire
 
       translatable_fields :title, :description
-      enum bb_status: [:created, :key_ceremony, :key_ceremony_ended, :vote, :vote_ended, :tally, :tally_ended, :results_published]
-        .map { |status| [status, status.to_s] }.to_h, _prefix: :bb
+
+      enum bb_status: [:created, :key_ceremony, :key_ceremony_ended, :vote, :vote_ended, :tally, :tally_ended, :results_published].index_with(&:to_s), _prefix: :bb
 
       component_manifest_name "elections"
 
@@ -26,6 +26,7 @@ module Decidim
       has_many :trustees, through: :elections_trustees
       has_many :votes, foreign_key: "decidim_elections_election_id", class_name: "Decidim::Elections::Vote", dependent: :restrict_with_exception
       has_many :actions, foreign_key: "decidim_elections_election_id", class_name: "Decidim::Elections::Action", dependent: :restrict_with_exception
+      has_one :bb_closure, foreign_key: "decidim_elections_election_id", class_name: "Decidim::Elections::BulletinBoardClosure", dependent: :destroy
 
       scope :active, lambda {
         where("start_time <= ?", Time.current)
@@ -95,11 +96,11 @@ module Decidim
         bb_results_published?
       end
 
-      # Public: Checks if the election results present
+      # Public: Checks if the election results are present
       #
       # Returns a boolean.
       def results?
-        bb_tally_ended?
+        bb_tally_ended? || results_published?
       end
 
       # Public: Checks if the election questions are valid

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

@@ -11,7 +11,7 @@ module Decidim
 
       belongs_to :election, foreign_key: "decidim_elections_election_id", class_name: "Decidim::Elections::Election", inverse_of: :questions
       has_many :answers, foreign_key: "decidim_elections_question_id", class_name: "Decidim::Elections::Answer", inverse_of: :question, dependent: :destroy
-
+      has_many :results, foreign_key: "decidim_elections_question_id", class_name: "Decidim::Elections::Result", dependent: :destroy
       has_one :component, through: :election, foreign_key: "decidim_component_id", class_name: "Decidim::Component"
 
       default_scope { order(weight: :asc, id: :asc) }
@@ -23,23 +23,34 @@ module Decidim
         max_selections <= answers.count
       end
 
-      def vote_variation
-        if max_selections == 1
-          "one_of_m"
-        else
-          "n_of_m"
-        end
+      # Public: Checks if the question accepts a blank/NOTA as an answer
+      #
+      # Returns a boolean.
+      def nota_option?
+        @nota_option ||= min_selections.zero?
       end
 
-      def total_votes
-        answers.sum(:votes_count)
+      def blank_votes
+        @blank_votes ||= results.blank_answers.sum(:value)
       end
 
-      def votes_percentage(answer_votes)
-        return 0 unless answer_votes.positive?
+      def results_total
+        @results_total ||= answers.sum(&:results_total) + blank_votes
+      end
+
+      # A result percentage relative to the question
+      # Returns a Float.
+      def blank_votes_percentage
+        @blank_votes_percentage ||= begin
+          return 0 unless results_total.positive?
+
+          result = blank_votes.to_f / results_total * 100.0
+          result.round
+        end
+      end
 
-        result = answer_votes.to_f / total_votes * 100.0
-        result.round
+      def slug
+        "question-#{id}"
       end
     end
   end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    # The data store for a Result in the Decidim::Elections component.
+    class Result < ApplicationRecord
+      enum result_type: [:valid_answers, :blank_answers, :valid_ballots, :blank_ballots, :null_ballots, :total_ballots]
+
+      belongs_to :closurable, polymorphic: true
+      belongs_to :question,
+                 foreign_key: "decidim_elections_question_id",
+                 class_name: "Decidim::Elections::Question",
+                 optional: true,
+                 inverse_of: :results
+      belongs_to :answer,
+                 foreign_key: "decidim_elections_answer_id",
+                 class_name: "Decidim::Elections::Answer",
+                 optional: true,
+                 inverse_of: :results
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ module Decidim
     # public key and has a reference to Decidim::User.
     class Trustee < ApplicationRecord
       belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
+      belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
       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
@@ -18,9 +19,17 @@ module Decidim
         find_by(user: user)
       end
 
-      def unique_id
+      def slug
         name.parameterize
       end
+
+      # The bulletin_board_slug is used as `unique_id` on the Bulletin Board, where
+      # the "authority.name" gets added as identification. If the organization
+      # name would be missing, it could result in an error, when two organizations
+      # inside the same "authority" have a trustee with the same name.
+      def bulletin_board_slug
+        "#{organization.name.parameterize}-#{slug}"
+      end
     end
   end
 end

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

@@ -4,10 +4,10 @@ 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
+      enum status: [:pending, :accepted, :rejected].index_with(&:to_s)
 
       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"
+      belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User", optional: true
 
       validates :voter_id, :encrypted_vote_hash, presence: true
     end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    class BallotStyle < ApplicationRecord
+      belongs_to :voting, foreign_key: :decidim_votings_voting_id, class_name: "Decidim::Votings::Voting"
+
+      has_many :ballot_style_questions,
+               class_name: "Decidim::Votings::BallotStyleQuestion",
+               foreign_key: :decidim_votings_ballot_style_id,
+               inverse_of: :ballot_style,
+               dependent: :delete_all
+      has_many :questions, through: :ballot_style_questions
+      has_many :census_data,
+               foreign_key: "decidim_votings_ballot_style_id",
+               class_name: "Decidim::Votings::Census::Datum",
+               inverse_of: :ballot_style,
+               dependent: :nullify
+
+      def slug
+        "#{voting.slug}_#{code.parameterize}-#{id}"
+      end
+
+      def questions_for(election)
+        questions.where(election: election)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    class BallotStyleQuestion < ApplicationRecord
+      # This is a join table between Decidim::Votings::BallotStyle and Decidim::Elections::Question
+      belongs_to :ballot_style, class_name: "Decidim::Votings::BallotStyle", foreign_key: :decidim_votings_ballot_style_id
+      belongs_to :question, class_name: "Decidim::Elections::Question", foreign_key: :decidim_elections_question_id
+    end
+  end
+end

data/app/models/decidim/votings/census/dataset.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Census
+      class Dataset < ApplicationRecord
+        include Traceable
+        include Loggable
+
+        # The data store for a whole Census for a voting.
+        belongs_to :voting, foreign_key: :decidim_votings_voting_id,
+                            class_name: "Decidim::Votings::Voting"
+        has_many :data,
+                 foreign_key: "decidim_votings_census_dataset_id",
+                 class_name: "Decidim::Votings::Census::Datum",
+                 dependent: :destroy
+
+        has_one_attached :access_codes_file
+
+        delegate :organization, to: :voting
+
+        enum status: [:init_data, :creating_data, :data_created, :generating_codes, :codes_generated, :exporting_codes, :freeze]
+
+        validates :file, presence: true
+
+        def self.log_presenter_class_for(_log)
+          Decidim::Votings::Census::AdminLog::DatasetPresenter
+        end
+      end
+    end
+  end
+end

data/app/models/decidim/votings/census/datum.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Census
+      class Datum < ApplicationRecord
+        include Decidim::RecordEncryptor
+
+        encrypt_attribute :full_name, type: :string
+        encrypt_attribute :full_address, type: :string
+        encrypt_attribute :postal_code, type: :string
+        encrypt_attribute :mobile_phone_number, type: :string
+        encrypt_attribute :email, type: :string
+
+        belongs_to :dataset, counter_cache: :data_count,
+                             foreign_key: "decidim_votings_census_dataset_id",
+                             class_name: "Decidim::Votings::Census::Dataset"
+        belongs_to :ballot_style, optional: true,
+                                  class_name: "Decidim::Votings::BallotStyle",
+                                  foreign_key: :decidim_votings_ballot_style_id
+
+        validates :full_name,
+                  :full_address,
+                  :postal_code,
+                  :hashed_in_person_data,
+                  :hashed_check_data,
+                  presence: true
+
+        validates :hashed_in_person_data, uniqueness: { scope: :dataset }
+        validates :hashed_check_data, uniqueness: { scope: :dataset }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # The data store for in person Votes in the Decidim::Votings space.
+    class InPersonVote < ApplicationRecord
+      enum status: [:pending, :accepted, :rejected]
+
+      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", optional: true
+
+      belongs_to :polling_station,
+                 foreign_key: "decidim_votings_polling_station_id",
+                 class_name: "Decidim::Votings::PollingStation"
+      belongs_to :polling_officer,
+                 foreign_key: "decidim_votings_polling_officer_id",
+                 class_name: "Decidim::Votings::PollingOfficer"
+
+      validates :voter_id, presence: true
+    end
+  end
+end

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

@@ -21,7 +21,16 @@ module Decidim
               class_name: "Decidim::Votings::PollingOfficer",
               inverse_of: :presided_polling_station,
               dependent: :nullify
-
+      has_many :in_person_votes,
+               foreign_key: "decidim_votings_polling_station_id",
+               class_name: "Decidim::Votings::InPersonVote",
+               inverse_of: :polling_station,
+               dependent: :restrict_with_exception
+      has_many :closures,
+               foreign_key: "decidim_votings_polling_station_id",
+               class_name: "Decidim::Votings::PollingStationClosure",
+               inverse_of: :polling_station,
+               dependent: :restrict_with_exception
       validate :polling_station_managers_same_voting
       validate :polling_station_president_same_voting
 
@@ -44,6 +53,14 @@ module Decidim
         polling_station_president.nil? || polling_station_managers.empty?
       end
 
+      def slug
+        "polling_station_#{id}"
+      end
+
+      def closure_for(election)
+        closures.find_by(election: election)
+      end
+
       private
 
       # Private: check if the president is in the same voting

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # The data store for a Polling Station Closure.
+    class PollingStationClosure < ApplicationRecord
+      include Decidim::HasAttachments
+      enum phase: [:count, :results, :certificate, :signature, :complete], _suffix: true
+
+      belongs_to :election,
+                 foreign_key: "decidim_elections_election_id",
+                 class_name: "Decidim::Elections::Election"
+      belongs_to :polling_station,
+                 foreign_key: "decidim_votings_polling_station_id",
+                 class_name: "Decidim::Votings::PollingStation"
+      belongs_to :polling_officer,
+                 foreign_key: "decidim_votings_polling_officer_id",
+                 class_name: "Decidim::Votings::PollingOfficer",
+                 optional: true
+      has_many :results,
+               foreign_type: "closurable_type",
+               class_name: "Decidim::Elections::Result",
+               dependent: :destroy,
+               as: :closurable
+
+      delegate :organization, to: :election
+
+      # Public: Checks if the closure has been signed by the polling officer or not.
+      #
+      # Returns Boolean.
+      def signed?
+        signed_at.present?
+      end
+
+      # Public: Checks if the closure has been validated by the monitoring committee or not.
+      #
+      # Returns Boolean.
+      def validated?
+        validated_at.present?
+      end
+    end
+  end
+end

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

@@ -17,15 +17,23 @@ module Decidim
       include Decidim::HasAttachments
       include Decidim::HasAttachmentCollections
 
-      enum voting_type: [:in_person, :online, :hybrid].map { |type| [type, type.to_s] }.to_h, _suffix: :voting
+      enum voting_type: [:in_person, :online, :hybrid].index_with(&:to_s), _suffix: :voting
 
       translatable_fields :title, :description
 
       belongs_to :organization,
                  foreign_key: "decidim_organization_id",
                  class_name: "Decidim::Organization"
-
+      has_one :dataset,
+              foreign_key: "decidim_votings_voting_id",
+              class_name: "Decidim::Votings::Census::Dataset",
+              dependent: :destroy
       has_many :components, as: :participatory_space, dependent: :destroy
+      has_many :categories,
+               foreign_key: "decidim_participatory_space_id",
+               foreign_type: "decidim_participatory_space_type",
+               dependent: :destroy,
+               as: :participatory_space
       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,
@@ -33,15 +41,16 @@ module Decidim
                class_name: "Decidim::Votings::MonitoringCommitteeMember",
                inverse_of: :voting,
                dependent: :destroy
+      has_many :ballot_styles, foreign_key: "decidim_votings_voting_id", class_name: "Decidim::Votings::BallotStyle", 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
+      has_one_attached :banner_image
+      validates_upload :banner_image, uploader: Decidim::BannerImageUploader
 
-      validates_upload :introductory_image
-      mount_uploader :introductory_image, Decidim::BannerImageUploader
+      has_one_attached :introductory_image
+      validates_upload :introductory_image, uploader: Decidim::BannerImageUploader
 
       scope :upcoming, -> { published.where("start_time > ?", Time.now.utc) }
       scope :active, lambda {
@@ -112,10 +121,6 @@ module Decidim
         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
@@ -126,12 +131,30 @@ module Decidim
           .where(managed_polling_station_id: nil)
       end
 
-      private
+      def has_ballot_styles?
+        ballot_styles.exists?
+      end
 
-      def has_elections?
-        components.where(manifest_name: :elections).any? do |component|
-          Decidim::Elections::Election.where(component: component).any?
-        end
+      def elections
+        Decidim::Elections::Election.where(component: components)
+      end
+
+      def published_elections
+        Decidim::Elections::Election.where(component: components.published).published
+      end
+
+      # Methods for Votings Space <-> Elections Component interaction
+
+      def complete_election_data(election, election_data)
+        election_data[:polling_stations] = polling_stations.map(&:slug)
+        election_data[:ballot_styles] = ballot_styles.map do |ballot_style|
+          questions = ballot_style.questions_for(election)
+          [ballot_style.slug, questions.map(&:slug)] if questions.any?
+        end.compact.to_h
+      end
+
+      def vote_flow_for(election)
+        Decidim::Votings::CensusVoteFlow.new(election)
       end
     end
   end