decidim-elections 0.24.3 → 0.25.0.rc4

data/lib/decidim/votings/participatory_space.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 Decidim.register_participatory_space(:votings) do |participatory_space|
-  participatory_space.icon = "decidim/votings/icon.svg"
+  participatory_space.icon = "media/images/decidim_votings.svg"
   participatory_space.model_class_name = "Decidim::Votings::Voting"
   participatory_space.permissions_class_name = "Decidim::Votings::Permissions"
   participatory_space.stylesheet = "decidim/votings/votings"
@@ -51,7 +51,12 @@ Decidim.register_participatory_space(:votings) do |participatory_space|
           Decidim::Faker::Localized.paragraph(sentence_count: 3)
         end,
         scope: n.positive? ? nil : Decidim::Scope.reorder(Arel.sql("RANDOM()")).first,
-        banner_image: File.new(File.join(seeds_root, "city.jpeg")),
+        banner_image: ActiveStorage::Blob.create_after_upload!(
+          io: File.open(File.join(seeds_root, "city.jpeg")),
+          filename: "banner_image.jpeg",
+          content_type: "image/jpeg",
+          metadata: nil
+        ), # Keep after organization
         published_at: 2.weeks.ago,
         start_time: n.weeks.from_now,
         end_time: (n + 1).weeks.from_now + 4.hours,
@@ -69,6 +74,52 @@ Decidim.register_participatory_space(:votings) do |participatory_space|
       end
       voting.add_to_index_as_search_resource
 
+      unless voting.online_voting?
+        3.times do
+          params = {
+            voting: voting,
+            title: Decidim::Faker::Localized.sentence(word_count: 5),
+            address: Faker::Address.full_address,
+            latitude: Faker::Address.latitude,
+            longitude: Faker::Address.longitude,
+            location: Decidim::Faker::Localized.sentence,
+            location_hints: Decidim::Faker::Localized.sentence
+          }
+
+          polling_station = Decidim.traceability.create!(
+            Decidim::Votings::PollingStation,
+            organization.users.first,
+            params,
+            visibility: "all"
+          )
+
+          email = "voting_#{voting.id}_president_#{polling_station.id}@example.org"
+
+          user = Decidim::User.find_or_initialize_by(email: email)
+          user.update!(
+            name: Faker::Name.name,
+            nickname: Faker::Twitter.unique.screen_name,
+            password: "decidim123456",
+            password_confirmation: "decidim123456",
+            organization: organization,
+            confirmed_at: Time.current,
+            locale: I18n.default_locale,
+            tos_agreement: true
+          )
+
+          Decidim.traceability.create!(
+            Decidim::Votings::PollingOfficer,
+            organization.users.first,
+            {
+              voting: voting,
+              user: user,
+              presided_polling_station: polling_station
+            },
+            visibility: "all"
+          )
+        end
+      end
+
       landing_page_content_blocks = [:header, :description, :elections, :polling_stations, :attachments_and_folders, :stats, :metrics]
 
       landing_page_content_blocks.each.with_index(1) do |manifest_name, index|
@@ -81,6 +132,102 @@ Decidim.register_participatory_space(:votings) do |participatory_space|
           published_at: Time.current
         )
       end
+
+      2.times do
+        Decidim::Category.create!(
+          name: Decidim::Faker::Localized.sentence(word_count: 5),
+          description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+            Decidim::Faker::Localized.paragraph(sentence_count: 3)
+          end,
+          participatory_space: voting
+        )
+      end
+
+      Decidim.component_manifests.each do |manifest|
+        manifest.seed!(voting.reload)
+      end
+
+      unless voting.online_voting?
+        voting.reload.published_elections.finished.each do |election|
+          polling_officer = voting.polling_officers.sample
+          ps_closure = Decidim::Votings::PollingStationClosure.create!(
+            election: election,
+            polling_officer: polling_officer,
+            polling_station: polling_officer.polling_station,
+            signed_at: Time.current,
+            phase: :complete
+          )
+
+          valid_ballots = Faker::Number.number(digits: 3)
+          Decidim::Elections::Result.create!(
+            value: valid_ballots,
+            closurable: ps_closure,
+            question: nil,
+            answer: nil,
+            result_type: :valid_ballots
+          )
+
+          null_ballots = Faker::Number.number(digits: 1)
+          Decidim::Elections::Result.create!(
+            value: null_ballots,
+            closurable: ps_closure,
+            question: nil,
+            answer: nil,
+            result_type: :null_ballots
+          )
+
+          blank_ballots = Faker::Number.number(digits: 2)
+          Decidim::Elections::Result.create!(
+            value: blank_ballots,
+            closurable: ps_closure,
+            question: nil,
+            answer: nil,
+            result_type: :blank_ballots
+          )
+
+          Decidim::Elections::Result.create!(
+            value: valid_ballots + null_ballots + blank_ballots,
+            closurable: ps_closure,
+            question: nil,
+            answer: nil,
+            result_type: :total_ballots
+          )
+
+          election.questions.each do |question|
+            question_pending = valid_ballots
+            question.answers.shuffle.each do |answer|
+              answer_value = Faker::Number.between(from: 0, to: question_pending)
+              Decidim::Elections::Result.create!(
+                value: answer_value,
+                closurable: ps_closure,
+                question: question,
+                answer: answer,
+                result_type: :valid_answers
+              )
+              question_pending -= answer_value
+            end
+
+            next unless question.nota_option?
+
+            Decidim::Elections::Result.create!(
+              value: question_pending,
+              closurable: ps_closure,
+              question: question,
+              answer: nil,
+              result_type: :blank_answers
+            )
+          end
+        end
+      end
+
+      (1..2).each do |i|
+        ballot_style = voting.ballot_styles.create!(code: "DISTRICT#{i}")
+        voting.elections.each do |election|
+          election.questions.sample(1 + rand(election.questions.count)).each do |question|
+            ballot_style.ballot_style_questions.create!(question: question)
+          end
+        end
+      end
     end
   end
 end

data/lib/decidim/votings/polling_officer_zone_engine.rb

@@ -11,8 +11,16 @@ module Decidim
       paths["lib/tasks"] = nil
 
       routes do
-        resource :polling_officers, path: "/", only: [:show] do
-          resources :polling_stations, only: [:show]
+        resources :polling_officers, path: "/", only: [:index] do
+          resources :elections, only: [:index] do
+            resource :closure do
+              member do
+                post :certify
+                post :sign
+              end
+            end
+            resources :in_person_votes, only: [:new, :create, :show, :update]
+          end
         end
       end
 
@@ -22,10 +30,11 @@ module Decidim
 
       initializer "decidim_elections.polling_officer_zone.menu" do
         Decidim.menu :user_menu do |menu|
-          menu.item I18n.t("menu.polling_officer_zone", scope: "decidim.votings.polling_officer_zone"),
-                    decidim.decidim_votings_polling_officer_zone_path,
-                    active: :inclusive,
-                    if: Decidim::Votings::PollingOfficer.polling_officer?(current_user)
+          menu.add_item :decidim_votings_polling_officer_zone,
+                        I18n.t("menu.polling_officer_zone", scope: "decidim.votings.polling_officer_zone"),
+                        decidim.decidim_votings_polling_officer_zone_path,
+                        active: :inclusive,
+                        if: Decidim::Votings::PollingOfficer.polling_officer?(current_user)
         end
       end
     end

data/lib/decidim/votings/test/factories.rb

@@ -3,6 +3,14 @@
 require "decidim/core/test/factories"
 require "decidim/forms/test/factories"
 
+def format_birthdate(birthdate)
+  format("%04d%02d%02d", birthdate.year, birthdate.month, birthdate.day) # rubocop:disable Style/FormatStringToken
+end
+
+def hash_for(*data)
+  Digest::SHA256.hexdigest(data.join("."))
+end
+
 FactoryBot.define do
   sequence(:voting_slug) do |n|
     "#{Decidim::Faker::Internet.slug(words: nil, glue: "-")}-#{n}"
@@ -20,6 +28,7 @@ FactoryBot.define do
     banner_image { Decidim::Dev.test_file("city2.jpeg", "image/jpeg") }
     introductory_image { Decidim::Dev.test_file("city.jpeg", "image/jpeg") }
     voting_type { "hybrid" }
+    census_contact_information { nil }
 
     trait :unpublished do
       published_at { nil }
@@ -61,6 +70,15 @@ FactoryBot.define do
     end
   end
 
+  factory :voting_election, parent: :election do
+    transient do
+      voting { create(:voting) }
+      base_id { 20_000 }
+    end
+
+    component { create(:elections_component, organization: organization, participatory_space: voting) }
+  end
+
   factory :polling_station, class: "Decidim::Votings::PollingStation" do
     title { generate_localized_title }
     location { Decidim::Faker::Localized.wrapped("<p>", "</p>") { generate_localized_title } }
@@ -74,10 +92,155 @@ FactoryBot.define do
   factory :polling_officer, class: "Decidim::Votings::PollingOfficer" do
     user { create :user, organization: voting.organization }
     voting { create :voting }
+
+    trait :president do
+      presided_polling_station { create :polling_station, voting: voting }
+    end
   end
 
   factory :monitoring_committee_member, class: "Decidim::Votings::MonitoringCommitteeMember" do
     user
     voting { create :voting, organization: user.organization }
   end
+
+  factory :dataset, class: "Decidim::Votings::Census::Dataset" do
+    voting { create(:voting) }
+    file { "file.csv" }
+    status { "init_data" }
+    csv_row_raw_count { 1 }
+    csv_row_processed_count { 1 }
+
+    trait :with_data do
+      after(:create) do |dataset|
+        create_list(:datum, 5, dataset: dataset)
+      end
+    end
+
+    trait :with_access_code_data do
+      after(:create) do |dataset|
+        create_list(:datum, 5, :with_access_code, dataset: dataset)
+      end
+    end
+
+    trait :data_created do
+      status { "data_created" }
+    end
+
+    trait :codes_generated do
+      with_access_code_data
+      status { "codes_generated" }
+    end
+
+    trait :frozen do
+      status { "freeze" }
+    end
+  end
+
+  factory :datum, class: "Decidim::Votings::Census::Datum" do
+    dataset
+
+    transient do
+      document_number { Faker::IDNumber.spanish_citizen_number }
+      document_type { %w(DNI NIE PASSPORT).sample }
+      birthdate { Faker::Date.birthday(min_age: 18, max_age: 65) }
+    end
+
+    hashed_in_person_data { hash_for(document_number, document_type, format_birthdate(birthdate)) }
+    hashed_check_data { hash_for(document_number, document_type, format_birthdate(birthdate), postal_code) }
+
+    full_name { Faker::Name.name }
+    full_address { Faker::Address.full_address }
+    postal_code { Faker::Address.postcode }
+    mobile_phone_number { Faker::PhoneNumber.cell_phone }
+    email { Faker::Internet.email }
+
+    trait :with_access_code do
+      access_code { Faker::Alphanumeric.alphanumeric(number: 8) }
+      hashed_online_data { hash_for hashed_check_data, access_code }
+    end
+  end
+
+  factory :ballot_style, class: "Decidim::Votings::BallotStyle" do
+    code { Faker::Lorem.word.upcase }
+    voting { create(:voting) }
+
+    trait :with_questions do
+      transient do
+        election { create(:election, :complete, component: create(:elections_component, participatory_space: voting)) }
+      end
+    end
+
+    trait :with_ballot_style_questions do
+      with_questions
+
+      after(:create) do |ballot_style, evaluator|
+        evaluator.election.questions.first(2).map { |question| create(:ballot_style_question, question: question, ballot_style: ballot_style) }
+      end
+    end
+  end
+
+  factory :ballot_style_question, class: "Decidim::Votings::BallotStyleQuestion" do
+    question
+    ballot_style
+  end
+
+  factory :in_person_vote, class: "Decidim::Votings::InPersonVote" do
+    transient do
+      voting { create(:voting) }
+      component { create(:elections_component, participatory_space: voting) }
+    end
+
+    election { create(:election, component: component) }
+    sequence(:voter_id) { |n| "voter_#{n}" }
+    status { "pending" }
+    message_id { "decidim-test-authority.2.vote.in_person+v.5826de088371d1b15b38f00c8203871caec07041ed0c8fb0c6fb875f0df763b6" }
+    polling_station { polling_officer.polling_station }
+    polling_officer { create(:polling_officer, :president, voting: voting) }
+
+    trait :accepted do
+      status { "accepted" }
+    end
+
+    trait :rejected do
+      status { "rejected" }
+    end
+  end
+
+  factory :ps_closure, class: "Decidim::Votings::PollingStationClosure" do
+    transient do
+      number_of_votes { Faker::Number.number(digits: 2) }
+    end
+
+    election { create(:voting_election, :complete) }
+    polling_station { polling_officer.polling_station }
+    polling_officer { create(:polling_officer, :president, voting: election.participatory_space) }
+    polling_officer_notes { Faker::Lorem.paragraph }
+    monitoring_committee_notes { nil }
+    signed_at { nil }
+    phase { :count }
+    validated_at { nil }
+
+    trait :with_results do
+      phase { :signature }
+
+      after :create do |closure, evaluator|
+        total_votes = evaluator.number_of_votes
+        create_list(:in_person_vote, evaluator.number_of_votes, :accepted, voting: closure.election.participatory_space, election: closure.election)
+
+        closure.election.questions.each do |question|
+          max = total_votes
+          question.answers.each do |answer|
+            value = Faker::Number.between(from: 0, to: max)
+            closure.results << create(:election_result, closurable: closure, election: closure.election, question: question, answer: answer, value: value)
+            max -= value
+          end
+          value = Faker::Number.between(from: 0, to: max)
+          closure.results << create(:election_result, :null_ballots, election: closure.election, question: question, value: value)
+          max -= value
+          closure.results << create(:election_result, :blank_ballots, election: closure.election, question: question, value: max)
+        end
+        closure.results << create(:election_result, :total_ballots, closurable: closure, election: closure.election, value: total_votes)
+      end
+    end
+  end
 end

data/lib/decidim/votings/voting_serializer.rb

@@ -36,6 +36,7 @@ module Decidim
       private
 
       attr_reader :voting
+      alias resource voting
 
       def translated_voting_type
         translation_hash = {}

data/lib/decidim/votings.rb

@@ -3,14 +3,31 @@
 require "decidim/votings/admin"
 require "decidim/votings/api"
 require "decidim/votings/polling_officer_zone"
+require "decidim/votings/census_admin"
+require "decidim/votings/census"
 require "decidim/votings/engine"
 require "decidim/votings/admin_engine"
 require "decidim/votings/polling_officer_zone_engine"
 require "decidim/votings/participatory_space"
+require "decidim/votings/census_engine"
+require "decidim/votings/census_admin_engine"
+require "rack/attack"
 
 module Decidim
   # This namespace holds the logic of the `Votings` space.
   module Votings
     autoload :VotingSerializer, "decidim/votings/voting_serializer"
+
+    include ActiveSupport::Configurable
+
+    # Max requests in a time period to check the census. Only applied in production and test.
+    config_accessor :check_census_max_requests do
+      5
+    end
+
+    # Time window in which the throttling is applied.
+    config_accessor :throttling_period do
+      1.minute
+    end
   end
 end

data/lib/tasks/decidim_voting_census.rake

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+namespace :decidim_votings_census do
+  # Removes the census access code export files older than the configured expiry time.
+  desc "Deletes the census access codes export file `Decidim::Votings::Census.census_access_codes_export_expiry_time` from now."
+  task delete_census_access_codes_export: :environment do
+    puts "DELETE CENSUS ACCESS CODES EXPORT: -------------- START"
+    attachments = ActiveStorage::Attachment.joins(:blob).where(
+      name: "access_codes_file",
+      record_type: "Decidim::Votings::Census::Dataset"
+    ).where(
+      "active_storage_blobs.created_at < ?", Decidim::Votings::Census.census_access_codes_export_expiry_time.ago
+    )
+    attachments.each do |attachment|
+      delete_census_access_codes_export_file attachment
+    end
+    puts "DELETE CENSUS ACCESS CODES EXPORT: --------------- END"
+  end
+
+  def delete_census_access_codes_export_file(attachment)
+    puts "------"
+    puts "!! deleting: #{attachment.filename}"
+    attachment.purge
+    puts "ok----"
+  end
+end