decidim-elections 0.23.3 → 0.24.0.rc1

data/lib/decidim/votings/participatory_space.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+Decidim.register_participatory_space(:votings) do |participatory_space|
+  participatory_space.icon = "decidim/votings/icon.svg"
+  participatory_space.model_class_name = "Decidim::Votings::Voting"
+  participatory_space.permissions_class_name = "Decidim::Votings::Permissions"
+  participatory_space.stylesheet = "decidim/votings/votings"
+  participatory_space.query_type = "Decidim::Votings::VotingType"
+
+  participatory_space.participatory_spaces do |organization|
+    Decidim::Votings::Voting.where(organization: organization)
+  end
+
+  participatory_space.register_resource(:voting) do |resource|
+    resource.model_class_name = "Decidim::Votings::Voting"
+    resource.card = "decidim/votings/voting"
+    resource.searchable = true
+  end
+
+  participatory_space.context(:public) do |context|
+    context.engine = Decidim::Votings::Engine
+    context.layout = "layouts/decidim/votings"
+    context.helper = "Decidim::Votings::ApplicationHelper"
+  end
+
+  participatory_space.context(:admin) do |context|
+    context.engine = Decidim::Votings::AdminEngine
+    context.layout = "layouts/decidim/admin/voting"
+  end
+
+  participatory_space.exports :votings do |export|
+    export.collection do |voting|
+      Decidim::Votings::Voting.where(id: voting.id)
+    end
+
+    export.include_in_open_data = true
+
+    export.serializer Decidim::Votings::VotingSerializer
+  end
+
+  participatory_space.seeds do
+    organization = Decidim::Organization.first
+    seeds_root = File.join(__dir__, "..", "..", "..", "db", "seeds")
+
+    3.times do |n|
+      params = {
+        organization: organization,
+        title: Decidim::Faker::Localized.sentence(word_count: 5),
+        slug: Decidim::Faker::Internet.unique.slug(words: nil, glue: "-"),
+        description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+          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")),
+        published_at: 2.weeks.ago,
+        start_time: n.weeks.from_now,
+        end_time: (n + 1).weeks.from_now + 4.hours,
+        voting_type: Decidim::Votings::Voting.voting_types.values.sample,
+        promoted: n.odd?
+      }
+
+      voting = Decidim.traceability.perform_action!(
+        "publish",
+        Decidim::Votings::Voting,
+        organization.users.first,
+        visibility: "all"
+      ) do
+        Decidim::Votings::Voting.create!(params)
+      end
+      voting.add_to_index_as_search_resource
+
+      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|
+        Decidim::ContentBlock.create(
+          organization: organization,
+          scope_name: :voting_landing_page,
+          manifest_name: manifest_name,
+          weight: index,
+          scoped_resource_id: voting.id,
+          published_at: Time.current
+        )
+      end
+    end
+  end
+end
+
+Decidim.register_global_engine(
+  :decidim_votings_polling_officer_zone,
+  Decidim::Votings::PollingOfficerZoneEngine,
+  at: "/polling_officers"
+)

data/lib/decidim/votings/polling_officer_zone.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # This module contains all the domain logic associated to Decidim's Votings
+    # polling officer zone.
+    module PollingOfficerZone
+    end
+  end
+end

data/lib/decidim/votings/polling_officer_zone_engine.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # This is the engine that runs on the public interface for polling officers of `decidim-elections`.
+    # It mostly handles rendering the polling officers frontend zone.
+    class PollingOfficerZoneEngine < ::Rails::Engine
+      isolate_namespace Decidim::Votings::PollingOfficerZone
+
+      paths["db/migrate"] = nil
+      paths["lib/tasks"] = nil
+
+      routes do
+        resource :polling_officers, path: "/", only: [:show] do
+          resources :polling_stations, only: [:show]
+        end
+      end
+
+      def load_seed
+        nil
+      end
+
+      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)
+        end
+      end
+    end
+  end
+end

data/lib/decidim/votings/query_extensions.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # This module's job is to extend the API with custom fields related to
+    # decidim-votings.
+    module QueryExtensions
+      # Public: Extends a type with `decidim-votings`'s fields.
+      #
+      # type - A GraphQL::BaseType to extend.
+      #
+      # Returns nothing.
+      def self.included(type)
+        type.field :votings,
+                   [Decidim::Votings::VotingType],
+                   null: true,
+                   description: "Lists all votings" do
+          argument :filter, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputFilter, "This argument let's you filter the results", required: false
+          argument :order, Decidim::ParticipatoryProcesses::ParticipatoryProcessInputSort, "This argument let's you order the results", required: false
+        end
+
+        type.field :voting,
+                   Decidim::Votings::VotingType,
+                   null: true,
+                   description: "Finds a voting" do
+          argument :id, GraphQL::Types::ID, "The ID of the participatory space", required: false
+        end
+      end
+
+      def votings(filter: {}, order: {})
+        manifest = Decidim.participatory_space_manifests.select { |m| m.name == :votings }.first
+
+        Decidim::Core::ParticipatorySpaceListBase.new(manifest: manifest).call(object, { filter: filter, order: order }, context)
+      end
+
+      def voting(id: nil)
+        manifest = Decidim.participatory_space_manifests.select { |m| m.name == :votings }.first
+
+        Decidim::Core::ParticipatorySpaceFinderBase.new(manifest: manifest).call(object, { id: id }, context)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "decidim/dev/test/rspec_support/capybara_data_picker"
+
+module Capybara
+  module PollingOfficersPicker
+    include DataPicker
+
+    RSpec::Matchers.define :have_polling_officers_picked do |expected|
+      match do |polling_officers_picker|
+        data_picker = polling_officers_picker.data_picker
+
+        expected.each do |polling_officer|
+          expect(data_picker).to have_selector(".picker-values div input[value='#{polling_officer.id}']", visible: :all)
+          expect(data_picker).to have_selector(:xpath, "//div[contains(@class,'picker-values')]/div/a[text()[contains(.,\"#{translated(polling_officer.name)}\")]]")
+        end
+      end
+    end
+
+    RSpec::Matchers.define :have_polling_officers_not_picked do |expected|
+      match do |polling_officers_picker|
+        data_picker = polling_officers_picker.data_picker
+
+        expected.each do |polling_officer|
+          expect(data_picker).not_to have_selector(".picker-values div input[value='#{polling_officer.id}']", visible: :all)
+          expect(data_picker).not_to have_selector(:xpath, "//div[contains(@class,'picker-values')]/div/a[text()[contains(.,\"#{translated(polling_officer.name)}\")]]")
+        end
+      end
+    end
+
+    def polling_officers_pick(polling_officers_picker, polling_officers)
+      data_picker = polling_officers_picker.data_picker
+
+      expect(data_picker).to have_selector(".picker-prompt")
+      data_picker.find(".picker-prompt").click
+
+      polling_officers.each do |polling_officer|
+        data_picker_choose_value(polling_officer.id)
+      end
+      data_picker_close
+
+      expect(polling_officers_picker).to have_polling_officers_picked(polling_officers)
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include Capybara::PollingOfficersPicker, type: :system
+end

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

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "decidim/core/test/factories"
+require "decidim/forms/test/factories"
+
+FactoryBot.define do
+  sequence(:voting_slug) do |n|
+    "#{Decidim::Faker::Internet.slug(words: nil, glue: "-")}-#{n}"
+  end
+
+  factory :voting, class: "Decidim::Votings::Voting" do
+    organization
+    slug { generate(:voting_slug) }
+    title { generate_localized_title }
+    description { Decidim::Faker::Localized.wrapped("<p>", "</p>") { generate_localized_title } }
+    published_at { Time.current }
+    start_time { 1.day.from_now }
+    end_time { 3.days.from_now }
+    decidim_scope_id { create(:scope, organization: organization).id }
+    banner_image { Decidim::Dev.test_file("city2.jpeg", "image/jpeg") }
+    introductory_image { Decidim::Dev.test_file("city.jpeg", "image/jpeg") }
+    voting_type { "hybrid" }
+
+    trait :unpublished do
+      published_at { nil }
+    end
+
+    trait :published do
+      published_at { Time.current }
+    end
+
+    trait :upcoming do
+      start_time { 7.days.from_now }
+      end_time { 1.month.from_now + 7.days }
+    end
+
+    trait :ongoing do
+      start_time { 7.days.ago }
+      end_time { 1.month.from_now - 7.days }
+    end
+
+    trait :finished do
+      start_time { 1.month.ago - 7.days }
+      end_time { 7.days.ago }
+    end
+
+    trait :promoted do
+      promoted { true }
+    end
+
+    trait :online do
+      voting_type { "online" }
+    end
+
+    trait :in_person do
+      voting_type { "in_person" }
+    end
+
+    trait :hybrid do
+      voting_type { "hybrid" }
+    end
+  end
+
+  factory :polling_station, class: "Decidim::Votings::PollingStation" do
+    title { generate_localized_title }
+    location { Decidim::Faker::Localized.wrapped("<p>", "</p>") { generate_localized_title } }
+    location_hints { Decidim::Faker::Localized.wrapped("<p>", "</p>") { generate_localized_title } }
+    address { Faker::Lorem.sentence(word_count: 3) }
+    latitude { Faker::Address.latitude }
+    longitude { Faker::Address.longitude }
+    voting { create(:voting) }
+  end
+
+  factory :polling_officer, class: "Decidim::Votings::PollingOfficer" do
+    user { create :user, organization: voting.organization }
+    voting { create :voting }
+  end
+
+  factory :monitoring_committee_member, class: "Decidim::Votings::MonitoringCommitteeMember" do
+    user
+    voting { create :voting, organization: user.organization }
+  end
+end

data/lib/decidim/votings/voting_serializer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # This class serializes a Voting so it can be exported to CSV, JSON or other
+    # formats.
+    class VotingSerializer < Decidim::Exporters::Serializer
+      include Decidim::ApplicationHelper
+      include Decidim::ResourceHelper
+      include Decidim::TranslationsHelper
+
+      # Public: Initializes the serializer with a voting.
+      def initialize(voting)
+        @voting = voting
+      end
+
+      # Public: Exports a hash with the serialized data for this voting.
+      def serialize
+        {
+          participatory_space_id: voting.id,
+          url: url,
+          title: voting.title,
+          description: voting.description,
+          start_time: voting.start_time.to_s(:db),
+          end_time: voting.end_time.to_s(:db),
+          voting_type: translated_voting_type,
+          scope: {
+            id: voting.scope.try(:id),
+            name: voting.scope.try(:name)
+          },
+          banner_image_url: Decidim::Votings::VotingPresenter.new(voting).banner_image_url,
+          introductory_image_url: Decidim::Votings::VotingPresenter.new(voting).introductory_image_url
+        }
+      end
+
+      private
+
+      attr_reader :voting
+
+      def translated_voting_type
+        translation_hash = {}
+        voting.organization.available_locales.each do |locale|
+          translation_hash[locale] = I18n.t(voting.voting_type, scope: "decidim.votings.admin.votings.form.voting_type")
+        end
+
+        translation_hash
+      end
+
+      def url
+        Decidim::Votings::Engine.routes.url_helpers.voting_url(host: voting.organization.host, slug: voting.slug)
+      end
+    end
+  end
+end

data/lib/tasks/decidim_elections.rake

@@ -1,16 +1,79 @@
 # frozen_string_literal: true
 
 namespace :decidim_elections do
-  desc "Add a new client to the bulletin board"
-
   IDENTIFICATION_PRIVATE_KEY_SIZE = 4096
 
+  desc "Add a new client to the bulletin board"
   task :generate_identification_keys do
-    identification_private_key = OpenSSL::PKey::RSA.new(IDENTIFICATION_PRIVATE_KEY_SIZE)
+    identification_jwk_keypair = JWT::JWK.new(OpenSSL::PKey::RSA.new(IDENTIFICATION_PRIVATE_KEY_SIZE))
 
-    puts identification_private_key.to_s
+    puts "\nPRIVATE KEY:"
+    puts "\n"
+    puts Decidim::BulletinBoard::JwkUtils.private_export(identification_jwk_keypair).to_json
     puts "\n"
-    puts identification_private_key.public_key.to_s
+    puts "PUBLIC KEY:"
+    puts "\n"
+    puts identification_jwk_keypair.export.map { |k, v| "#{k}=#{v}" }.join("&")
     puts "\nAbove are the generated private and public keys.\n\nSee Decidim docs at docs/services/bulletin_board.md in order to set them up.\n\n"
   end
+
+  desc "Scheduled tasks"
+  task :scheduled_tasks, [] => :environment do
+    Decidim::Elections::ElectionsReadyToStart.for.each do |election|
+      puts "\nStarting vote period for election ##{election.id}:"
+      form = Decidim::Elections::Admin::VotePeriodForm.new.with_context(election: election, current_user: nil)
+      Decidim::Elections::Admin::StartVote.call(form) do
+        on(:ok) do
+          puts "\n✓ Voting period start requested.\n"
+        end
+
+        on(:invalid) do |message|
+          puts "\n✗ Voting period not started. Message: #{message}\n"
+        end
+      end
+      puts "\n"
+    end
+
+    Decidim::Elections::ElectionsFinishedToEnd.for.each do |election|
+      puts "\nEnding vote period for election ##{election.id}:"
+      form = Decidim::Elections::Admin::VotePeriodForm.new.with_context(election: election, current_user: nil)
+      Decidim::Elections::Admin::EndVote.call(form) do
+        on(:ok) do
+          puts "\n✓ Voting period end requested.\n"
+        end
+
+        on(:invalid) do |message|
+          puts "\n✗ Voting period not ended. Message: #{message}\n"
+        end
+      end
+      puts "\n"
+    end
+
+    Decidim::Elections::Votes::PendingVotes.for.each do |vote|
+      puts "\nChecking status for Vote ##{vote.id}:"
+      Decidim::Elections::Voter::UpdateVoteStatus.call(vote) do
+        on(:ok) do
+          puts "\n✓ Vote status updated\n"
+        end
+
+        on(:invalid) do |message|
+          puts "\n✗ Vote status failed. Message: #{message}\n"
+        end
+      end
+      puts "\n"
+    end
+
+    Decidim::Elections::Admin::PendingActions.for.each do |action|
+      puts "\nChecking status for action '#{action.action}' for election ##{action.election.id}:"
+      Decidim::Elections::Admin::UpdateActionStatus.call(action) do
+        on(:ok) do
+          puts "\n✓ Action status updated\n"
+        end
+        on(:invalid) do |message|
+          puts "\n✗ Update status failed. Message: #{message}\n"
+        end
+      end
+      puts "\n"
+    end
+  end
 end