decidim-elections 0.23.6 → 0.24.0.rc1

data/app/controllers/decidim/votings/admin/votings_controller.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # This controller allows to create or update a voting.
+      class VotingsController < Admin::ApplicationController
+        include Decidim::Votings::Admin::Filterable
+        helper_method :votings, :current_voting, :current_participatory_space
+
+        def index
+          enforce_permission_to :read, :votings
+          @votings = filtered_collection
+        end
+
+        def new
+          enforce_permission_to :create, :voting
+          @form = form(VotingForm).instance
+        end
+
+        def create
+          enforce_permission_to :create, :voting
+          @form = form(VotingForm).from_params(params)
+
+          CreateVoting.call(@form) do
+            on(:ok) do
+              flash[:notice] = I18n.t("votings.create.success", scope: "decidim.votings.admin")
+              redirect_to votings_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("votings.create.invalid", scope: "decidim.votings.admin")
+              render action: "new"
+            end
+          end
+        end
+
+        def edit
+          enforce_permission_to :update, :voting, voting: current_voting
+          @form = form(VotingForm).from_model(current_voting)
+          render layout: "decidim/admin/voting"
+        end
+
+        def update
+          enforce_permission_to :update, :voting, voting: current_voting
+          @form = form(VotingForm).from_params(params, voting_id: current_voting.id)
+
+          UpdateVoting.call(current_voting, @form) do
+            on(:ok) do |voting|
+              flash[:notice] = I18n.t("votings.update.success", scope: "decidim.votings.admin")
+              redirect_to edit_voting_path(voting)
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("votings.update.invalid", scope: "decidim.votings.admin")
+              render action: "edit"
+            end
+          end
+        end
+
+        def publish
+          enforce_permission_to :publish, :voting, voting: current_voting
+
+          PublishVoting.call(current_voting, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("votings.publish.success", scope: "decidim.votings.admin")
+              redirect_to edit_voting_path(voting)
+            end
+          end
+        end
+
+        def unpublish
+          enforce_permission_to :unpublish, :voting, voting: current_voting
+
+          UnpublishVoting.call(current_voting, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("votings.unpublish.success", scope: "decidim.votings.admin")
+              redirect_to edit_voting_path(voting)
+            end
+          end
+        end
+
+        def available_polling_officers
+          respond_to do |format|
+            format.json do
+              if (term = params[:term].to_s).present?
+                query = current_voting.available_polling_officers.joins(:user)
+                query = if term.start_with?("@")
+                          query.where("nickname ILIKE ?", "#{term.delete("@")}%")
+                        else
+                          query.where("name ILIKE ?", "%#{term}%").or(
+                            query.where("email ILIKE ?", "%#{term}%")
+                          )
+                        end
+                render json: query.all.collect { |u| { value: u.id, label: "#{u.name} (@#{u.nickname}) #{u.email}" } }
+              else
+                render json: []
+              end
+            end
+          end
+        end
+
+        def polling_officers_picker
+          render :polling_officers_picker, layout: false
+        end
+
+        private
+
+        def votings
+          @votings ||= OrganizationVotings.new(current_user.organization).query
+        end
+
+        def current_voting
+          @current_voting ||= votings.where(slug: params[:slug]).or(
+            votings.where(id: params[:slug])
+          ).first
+        end
+
+        alias collection votings
+        alias current_participatory_space current_voting
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/admin/votings_landing_page_content_blocks_controller.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # Controller that allows to edit the content of the landing page content blocks
+      class VotingsLandingPageContentBlocksController < Decidim::Votings::Admin::ApplicationController
+        include Decidim::Admin::LandingPageContentBlocks
+
+        layout "decidim/admin/voting"
+
+        helper_method :current_participatory_space
+
+        private
+
+        def content_block_scope
+          :voting_landing_page
+        end
+
+        def scoped_resource
+          @scoped_resource ||= Voting.find_by(slug: params[:voting_slug])
+        end
+
+        def enforce_permission_to_update_resource
+          enforce_permission_to :manage_landing_page, :voting, voting: current_participatory_space
+        end
+
+        def edit_resource_landing_page_path
+          edit_voting_landing_page_path(scoped_resource)
+        end
+
+        def resource_landing_page_content_block_path
+          voting_landing_page_content_block_path(scoped_resource, params[:id])
+        end
+
+        def submit_button_text
+          t("landing_page.content_blocks.edit.update", scope: "decidim.votings.admin")
+        end
+
+        alias current_participatory_space scoped_resource
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/admin/votings_landing_page_controller.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module Admin
+      # Controller that allows to (de)activate the content blocks from a voting landing page
+      class VotingsLandingPageController < Decidim::Votings::Admin::ApplicationController
+        include Decidim::Admin::LandingPage
+
+        layout "decidim/admin/voting"
+
+        helper_method :current_participatory_space
+
+        def content_block_scope
+          :voting_landing_page
+        end
+
+        def scoped_resource
+          @scoped_resource ||= Voting.find_by(slug: params[:voting_slug])
+        end
+
+        def enforce_permission_to_update_resource
+          enforce_permission_to :manage_landing_page, :voting, voting: scoped_resource
+        end
+
+        def resource_sort_url
+          voting_landing_page_path(scoped_resource)
+        end
+
+        def active_content_blocks_title
+          t("landing_page.edit.active_content_blocks", scope: "decidim.votings.admin")
+        end
+
+        def inactive_content_blocks_title
+          t("landing_page.edit.inactive_content_blocks", scope: "decidim.votings.admin")
+        end
+
+        def resource_content_block_cell
+          "decidim/votings/content_block"
+        end
+
+        alias current_participatory_space scoped_resource
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/application_controller.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # A controller that holds the logic to show votings in a
+    # public layout.
+    class ApplicationController < Decidim::ApplicationController
+      include NeedsPermission
+
+      register_permissions(::Decidim::Votings::ApplicationController,
+                           Decidim::Votings::Permissions,
+                           Decidim::Admin::Permissions,
+                           Decidim::Permissions)
+
+      private
+
+      def permission_class_chain
+        ::Decidim.permissions_registry.chain_for(::Decidim::Votings::ApplicationController)
+      end
+
+      def permission_scope
+        :public
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/polling_officer_zone/application_controller.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module PollingOfficerZone
+      # This controller is the abstract class from which all polling_officer_zone
+      # controllers in their public engines should inherit from.
+
+      class ApplicationController < ::Decidim::ApplicationController
+        include Decidim::UserProfile
+
+        helper_method :polling_officers
+
+        private
+
+        def polling_officers
+          @polling_officers ||= Decidim::Votings::PollingOfficer.for(current_user)
+        end
+
+        def permission_scope
+          :polling_officer_zone
+        end
+
+        def permission_class_chain
+          [
+            Decidim::Votings::Permissions,
+            Decidim::Permissions
+          ]
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/polling_officer_zone/polling_officers_controller.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module PollingOfficerZone
+      # Exposes the polling officer zone for polling officer users
+      class PollingOfficersController < Decidim::Votings::PollingOfficerZone::ApplicationController
+        helper Decidim::Admin::IconLinkHelper
+        helper_method :polling_stations
+
+        def show
+          enforce_permission_to :view, :polling_officers, polling_officers: polling_officers
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/polling_officer_zone/polling_stations_controller.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    module PollingOfficerZone
+      # Space to manage the elections for a Polling Station Officer
+      class PollingStationsController < Decidim::Votings::PollingOfficerZone::ApplicationController
+        helper_method :polling_station
+
+        def show
+          enforce_permission_to :view, :polling_station, polling_officers: polling_officers
+        end
+
+        private
+
+        def polling_station
+          @polling_station ||= Decidim::Votings::PollingStation.find(params[:id])
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/votings/votings_controller.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Votings
+    # A controller that holds the logic to show votings in a
+    # public layout.
+    class VotingsController < Decidim::Votings::ApplicationController
+      layout "layouts/decidim/voting", only: :show
+
+      include ParticipatorySpaceContext
+      include NeedsVoting
+      include FilterResource
+      include Paginable
+      include Decidim::Votings::Orderable
+
+      helper_method :published_votings, :paginated_votings, :filter, :promoted_votings, :only_finished_votings?
+
+      helper Decidim::FiltersHelper
+      helper Decidim::OrdersHelper
+      helper Decidim::SanitizeHelper
+      helper Decidim::PaginateHelper
+      helper Decidim::IconHelper
+      helper Decidim::WidgetUrlsHelper
+      helper Decidim::ResourceHelper
+
+      def index
+        raise ActionController::RoutingError, "Not Found" if published_votings.none?
+
+        enforce_permission_to :read, :votings
+        redirect_to voting_path(single) if single?
+      end
+
+      def show
+        raise ActionController::RoutingError, "Not Found" unless current_voting
+
+        enforce_permission_to :read, :voting, voting: current_voting
+      end
+
+      private
+
+      def current_participatory_space_manifest
+        @current_participatory_space_manifest ||= Decidim.find_participatory_space_manifest(:votings)
+      end
+
+      def published_votings
+        @published_votings ||= Voting.where(organization: current_organization).published
+      end
+
+      def paginated_votings
+        @paginated_votings ||= paginate(search.results.published)
+        @paginated_votings = reorder(@paginated_votings)
+      end
+
+      def promoted_votings
+        @promoted_votings ||= OrganizationPromotedVotings.new(current_organization)
+      end
+
+      def finished_votings
+        @finished_votings ||= search_klass.new(search_params.merge(state: ["finished"])).results
+      end
+
+      def only_finished_votings?
+        return if finished_votings.blank?
+
+        published_votings.count == finished_votings.count
+      end
+
+      def search_klass
+        VotingSearch
+      end
+
+      def default_filter_params
+        {
+          search_text: "",
+          state: [""]
+        }
+      end
+
+      def context_params
+        {
+          organization: current_organization,
+          current_user: current_user
+        }
+      end
+
+      # Public: Checks if the component has only one election resource.
+      #
+      # Returns Boolean.
+      def single?
+        published_votings.one?
+      end
+
+      def single
+        published_votings.first if single?
+      end
+    end
+  end
+end

data/app/events/decidim/elections/trustees/notify_new_trustee_event.rb

@@ -0,0 +1,28 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Elections
+    module Trustees
+      class NotifyNewTrusteeEvent < Decidim::Events::SimpleEvent
+        # This event sends a notification when a new trustee gets created.
+
+        delegate :organization, to: :user, prefix: false
+        delegate :url_helpers, to: "Decidim::Core::Engine.routes"
+
+        i18n_attributes :resource_name, :trustee_zone_url
+
+        def resource_name
+          @resource_name ||= translated_attribute(participatory_space.title)
+        end
+
+        def participatory_space
+          @participatory_space ||= resource
+        end
+
+        def trustee_zone_url
+          url_helpers.decidim_elections_trustee_zone_url(host: organization.host)
+        end
+      end
+    end
+  end
+end

data/app/events/decidim/elections/trustees/notify_trustee_new_election_event.rb

@@ -0,0 +1,14 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Elections
+    module Trustees
+      class NotifyTrusteeNewElectionEvent < Decidim::Events::SimpleEvent
+        # This event sends a notification when a new trustee gets an election.
+        def resource_name
+          @resource_name ||= translated_attribute(election.title)
+        end
+      end
+    end
+  end
+end

data/app/events/decidim/elections/votes/vote_accepted_event.rb

@@ -0,0 +1,24 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Elections
+    module Votes
+      class VoteAcceptedEvent < Decidim::Events::SimpleEvent
+        # This event sends a notification with the vote hash and further instructions
+        i18n_attributes :resource_name, :encrypted_vote_hash, :verify_url
+
+        def resource_name
+          @resource_name ||= translated_attribute(resource.title)
+        end
+
+        def encrypted_vote_hash
+          extra[:vote]["encrypted_vote_hash"]
+        end
+
+        def verify_url
+          Decidim::EngineRouter.main_proxy(resource.component).verify_election_vote_url(resource)
+        end
+      end
+    end
+  end
+end

data/app/events/decidim/votings/polling_officers/polling_station_assigned_event.rb

@@ -0,0 +1,44 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Votings
+    module PollingOfficers
+      class PollingStationAssignedEvent < Decidim::Events::SimpleEvent
+        # This event sends a notification when a polling station is assigned to a polling officer
+
+        delegate :organization, to: :user, prefix: false
+        delegate :url_helpers, to: "Decidim::Core::Engine.routes"
+
+        i18n_attributes :polling_station_name, :polling_officer_zone_url, :role
+
+        def polling_station_name
+          @polling_station_name ||= translated_attribute(polling_station.title)
+        end
+
+        def polling_officer_zone_url
+          url_helpers.decidim_votings_polling_officer_zone_url(host: organization.host)
+        end
+
+        def role
+          I18n.t(polling_officer.role, scope: "decidim.votings.polling_officers.roles")
+        end
+
+        private
+
+        def polling_officer
+          @polling_officer ||= Decidim::Votings::PollingOfficer.find_by(id: extra[:polling_officer_id])
+        end
+
+        def polling_station
+          @polling_station ||=
+            case polling_officer.role
+            when :president
+              polling_officer.presided_polling_station
+            when :manager
+              polling_officer.managed_polling_station
+            end
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/elections/admin/action_form.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    module Admin
+      # This class holds a form to perform an action on the BB.
+      class ActionForm < Decidim::Form
+        validates :pending_action, absence: true
+
+        def messages
+          @messages ||= {}
+        end
+
+        def current_step
+          @current_step ||= election.bb_status
+        end
+
+        def election
+          @election ||= context[:election]
+        end
+
+        def pending_action
+          return @pending_action if defined?(@pending_action)
+
+          @pending_action = election.actions.pending.first
+        end
+
+        def bulletin_board
+          @bulletin_board ||= context[:bulletin_board] || Decidim::Elections.bulletin_board
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/elections/admin/answer_form.rb

@@ -6,15 +6,16 @@ module Decidim
       # This class holds a Form to create/update answers from Decidim's admin panel.
       class AnswerForm < Decidim::Form
         include TranslatableAttributes
+        include AttachmentAttributes
 
         translatable_attribute :title, String
         translatable_attribute :description, String
         attribute :proposal_ids, Array[Integer]
         attribute :attachment, AttachmentForm
-        attribute :photos, Array[String]
-        attribute :add_photos, Array
         attribute :weight, Integer, default: 0
 
+        attachments_attribute :photos
+
         validates :title, translatable_presence: true
         validate :notify_missing_attachment_if_errored
 

data/app/forms/decidim/elections/admin/election_form.rb

@@ -6,14 +6,15 @@ module Decidim
       # This class holds a Form to create/update elections from Decidim's admin panel.
       class ElectionForm < Decidim::Form
         include TranslatableAttributes
+        include AttachmentAttributes
 
         translatable_attribute :title, String
         translatable_attribute :description, String
         attribute :start_time, Decidim::Attributes::TimeWithZone
         attribute :end_time, Decidim::Attributes::TimeWithZone
         attribute :attachment, AttachmentForm
-        attribute :photos, Array[String]
-        attribute :add_photos, Array
+
+        attachments_attribute :photos
 
         validates :title, translatable_presence: true
         validates :description, translatable_presence: true

data/app/forms/decidim/elections/admin/setup_form.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Elections
+    module Admin
+      # This class holds a form to setup elections from Decidim's admin panel.
+      class SetupForm < Decidim::Form
+        mimic :setup
+
+        attribute :trustee_ids, Array[Integer]
+
+        validate do
+          validations.each do |message, t_args, valid|
+            errors.add(message, I18n.t("steps.create_election.errors.#{message}", **t_args, scope: "decidim.elections.admin")) unless valid
+          end
+        end
+
+        def current_step; end
+
+        def pending_action; end
+
+        def trustee_ids
+          choose_random_trustees
+        end
+
+        def trustees
+          ids = trustee_ids
+          @trustees ||= Decidim::Elections::Trustees::ByParticipatorySpaceTrusteeIds.new(ids).to_a.sort_by(&:id)
+        end
+
+        def validations
+          @validations ||= [
+            [:minimum_questions, {}, election.questions.any?],
+            [:minimum_answers, {}, election.minimum_answers?],
+            [:max_selections, {}, election.valid_questions?],
+            [:published, {}, election.published_at.present?],
+            [:time_before, { hours: Decidim::Elections.setup_minimum_hours_before_start }, election.minimum_hours_before_start?],
+            [:trustees_number, { number: bulletin_board.number_of_trustees }, participatory_space_trustees_with_public_key.size >= bulletin_board.number_of_trustees]
+          ].freeze
+        end
+
+        def messages
+          @messages ||= validations.map do |message, t_args, _valid|
+            [message, I18n.t("steps.create_election.requirements.#{message}", **t_args, scope: "decidim.elections.admin")]
+          end.to_h
+        end
+
+        def participatory_space_trustees
+          @participatory_space_trustees ||= Decidim::Elections::Trustees::ByParticipatorySpace.new(election.component.participatory_space).to_a
+        end
+
+        def election
+          @election ||= context[:election]
+        end
+
+        def bulletin_board
+          @bulletin_board ||= context[:bulletin_board] || Decidim::Elections.bulletin_board
+        end
+
+        private
+
+        def choose_random_trustees
+          return @trustee_ids if @trustee_ids.any? || defined?(@trustees)
+
+          @trustees = if participatory_space_trustees_with_public_key.count >= bulletin_board.number_of_trustees
+                        participatory_space_trustees_with_public_key.sample(bulletin_board.number_of_trustees)
+                      else
+                        []
+                      end
+          @trustee_ids = @trustees.pluck(:id)
+        end
+
+        def participatory_space_trustees_with_public_key
+          @participatory_space_trustees_with_public_key ||= participatory_space_trustees.filter { |trustee| trustee.public_key.present? }
+        end
+      end
+    end
+  end
+end