decidim-accountability 0.29.2 → 0.30.0.rc1

data/app/controllers/decidim/accountability/admin/results_bulk_actions_controller.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Accountability
+    module Admin
+      class ResultsBulkActionsController < Admin::ApplicationController
+        include Decidim::ApplicationHelper
+        include Decidim::SanitizeHelper
+        include Decidim::Admin::ComponentTaxonomiesHelper
+
+        def update_taxonomies
+          enforce_permission_to :create, :bulk_update
+
+          Admin::UpdateResultTaxonomies.call(result_params[:taxonomies], result_ids, current_organization) do
+            on(:invalid_taxonomies) do
+              flash[:alert] = I18n.t(
+                "results.update_taxonomies.select_a_taxonomy",
+                scope: "decidim.accountability.admin"
+              )
+            end
+
+            on(:invalid_resources) do
+              flash[:alert] = I18n.t(
+                "results.update_taxonomies.select_a_result",
+                scope: "decidim.accountability.admin"
+              )
+            end
+
+            on(:update_resources_taxonomies) do |response|
+              if response[:successful].any?
+                flash[:notice] = t(
+                  "results.update_taxonomies.success",
+                  taxonomies: response[:taxonomies].map { |taxonomy| decidim_escape_translated(taxonomy.name) }.to_sentence,
+                  results: response[:successful].map { |resource| decidim_escape_translated(resource.title) }.to_sentence,
+                  scope: "decidim.accountability.admin"
+                )
+              end
+              if response[:errored].any?
+                flash[:alert] = t(
+                  "results.update_taxonomies.invalid",
+                  taxonomies: response[:taxonomies].map { |taxonomy| decidim_escape_translated(taxonomy.name) }.to_sentence,
+                  results: response[:errored].map { |resource| decidim_escape_translated(resource.title) }.to_sentence,
+                  scope: "decidim.accountability.admin"
+                )
+              end
+            end
+          end
+
+          redirect_to results_path
+        end
+
+        def update_status
+          enforce_permission_to :create, :bulk_update
+
+          UpdateResultStatus.call(result_params[:decidim_accountability_status_id], result_ids, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("results.update_status.success", scope: "decidim.accountability.admin")
+              redirect_to results_path
+            end
+
+            on(:invalid) do
+              flash[:alert] = I18n.t("results.update_status.invalid", scope: "decidim.accountability.admin")
+              redirect_to results_path
+            end
+          end
+        end
+
+        def update_dates
+          enforce_permission_to :create, :bulk_update
+
+          UpdateResultDates.call(result_params[:start_date], result_params[:end_date], result_ids, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("results.update_dates.success", scope: "decidim.accountability.admin")
+              redirect_to results_path
+            end
+
+            on(:invalid) do
+              flash[:alert] = I18n.t("results.update_dates.invalid", scope: "decidim.accountability.admin")
+              redirect_to results_path
+            end
+          end
+        end
+
+        private
+
+        def result_ids
+          result_params[:result_ids].map { |ids| ids.split(",") }.flatten.map(&:to_i)
+        end
+
+        def result_params
+          @result_params ||= params.require(:result_bulk_actions).permit(
+            :decidim_accountability_status_id,
+            :start_date,
+            :end_date,
+            result_ids: [],
+            taxonomies: []
+          )
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/accountability/admin/results_controller.rb

@@ -7,13 +7,15 @@ module Decidim
       class ResultsController < Admin::ApplicationController
         include Decidim::ApplicationHelper
         include Decidim::SanitizeHelper
+        include Decidim::Admin::ComponentTaxonomiesHelper
         include Decidim::Accountability::Admin::Filterable
+        include Decidim::Admin::HasTrashableResources
 
-        helper_method :results, :parent_result, :parent_results, :statuses, :present
+        helper_method :results, :parent_result, :parent_results, :statuses, :present, :bulk_actions_form
 
         def collection
           parent_id = params[:parent_id].presence
-          @collection ||= Result.where(component: current_component, parent_id:).page(params[:page]).per(15)
+          @collection ||= Result.where(component: current_component, parent_id:).page(params[:page]).per(15).order(created_at: :asc)
         end
 
         def new
@@ -65,19 +67,23 @@ module Decidim
           end
         end
 
-        def destroy
-          enforce_permission_to(:destroy, :result, result:)
+        private
 
-          Decidim::Commands::DestroyResource.call(result, current_user) do
-            on(:ok) do
-              flash[:notice] = I18n.t("results.destroy.success", scope: "decidim.accountability.admin")
+        def trashable_deleted_resource_type
+          :result
+        end
 
-              redirect_to results_path(parent_id: result.parent_id)
-            end
-          end
+        def trashable_deleted_resource
+          @trashable_deleted_resource ||= Result.with_deleted.where(component: current_component).find_by(id: params[:id])
         end
 
-        private
+        def trashable_deleted_collection
+          @trashable_deleted_collection = filtered_collection.only_deleted.deleted_at_desc
+        end
+
+        def find_parent_resource
+          parent_result
+        end
 
         def results
           @results ||= filtered_collection
@@ -98,6 +104,10 @@ module Decidim
         def statuses
           @statuses ||= Status.where(component: current_component)
         end
+
+        def bulk_actions_form
+          @bulk_actions_form ||= ResultBulkActionsForm.new(result_ids: [])
+        end
       end
     end
   end

data/app/controllers/decidim/accountability/results_controller.rb

@@ -8,7 +8,7 @@ module Decidim
       helper Decidim::TraceabilityHelper
       helper Decidim::Accountability::BreadcrumbHelper
 
-      helper_method :results, :result, :first_class_categories, :count_calculator
+      helper_method :results, :result, :first_class_taxonomies, :count_calculator
 
       before_action :set_controller_breadcrumb
 
@@ -16,6 +16,10 @@ module Decidim
         raise ActionController::RoutingError, "Not Found" unless result
       end
 
+      def home
+        @all_geocoded_results = results.geocoded
+      end
+
       private
 
       def results
@@ -38,17 +42,16 @@ module Decidim
       def default_filter_params
         {
           search_text_cont: "",
-          with_scope: "",
-          with_category: ""
+          taxonomies_part_of_contains: ""
         }
       end
 
-      def first_class_categories
-        @first_class_categories ||= current_participatory_space.categories.first_class
+      def first_class_taxonomies
+        @first_class_taxonomies ||= current_organization.taxonomies.where(parent_id: current_component.available_root_taxonomies, id: current_component.available_taxonomy_ids)
       end
 
-      def count_calculator(scope_id, category_id)
-        Decidim::Accountability::ResultsCalculator.new(current_component, scope_id, category_id).count
+      def count_calculator(taxonomy_id)
+        Decidim::Accountability::ResultsCalculator.new(current_component, taxonomy_id).count
       end
 
       def controller_breadcrumb_items

data/app/forms/decidim/accountability/admin/import_component_form.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Accountability
+    module Admin
+      # A form object to be used when admin users want to import results from
+      # another component into Accountability component.
+      class ImportComponentForm < Decidim::Form
+        include Decidim::TranslatableAttributes
+        include Decidim::HasTaxonomyFormAttributes
+
+        attribute :origin_component_id, Integer
+        attribute :proposal_state_id, Integer
+
+        validates :origin_component_id, presence: true
+        validates :filtered_items_count, numericality: { greater_than: 0 }, if: ->(form) { form.origin_component_id }
+
+        def origin_component
+          @origin_component ||= origin_components.find_by(id: origin_component_id)
+        end
+
+        def origin_components
+          @origin_components ||= current_participatory_space.components.where(manifest_name: %w(budgets proposals))
+        end
+
+        def origin_components_collection
+          origin_components.map do |component|
+            [component.name[I18n.locale.to_s], component.id]
+          end
+        end
+
+        def proposal_states_collection
+          Decidim::Proposals::ProposalState.where(component: origin_component).map do |state|
+            [translated_attribute(state.title), state.id]
+          end
+        end
+
+        delegate :count, to: :filtered_items, prefix: true
+
+        def filtered_items
+          if origin_component.manifest_name == "budgets"
+            filtered_budget_projects
+          elsif origin_component.manifest_name == "proposals"
+            filtered_proposals
+          else
+            raise "Invalid component"
+          end
+        end
+
+        def project_already_copied?(original_project)
+          original_project.linked_resources(:results, "included_projects").any? do |result|
+            result.component == current_component
+          end
+        end
+
+        def proposal_already_copied?(original_proposal)
+          original_proposal.linked_resources(:results, "included_proposals").any? do |result|
+            result.component == current_component
+          end
+        end
+
+        private
+
+        def filtered_budget_projects
+          scope = Decidim::Budgets::Project.joins(:budget).selected.where(budget: { component: origin_component })
+          scope = filter_taxonomies(scope)
+          scope.reject { |project| project_already_copied?(project) }
+        end
+
+        def filtered_proposals
+          scope = Decidim::Proposals::Proposal.where(component: origin_component).not_hidden
+          scope = scope.where(decidim_proposals_proposal_state_id: proposal_state_id) if proposal_state_id
+          scope = filter_taxonomies(scope)
+          scope.reject { |proposal| proposal_already_copied?(proposal) }
+        end
+
+        def filter_taxonomies(scope)
+          if taxonomy_sets.any?
+            scope.with_any_taxonomies(*taxonomy_sets)
+          else
+            scope
+          end
+        end
+
+        def taxonomy_sets
+          @taxonomy_sets ||= taxonomies.compact.map do |taxonomy_id|
+            taxonomy = Decidim::Taxonomy.find(taxonomy_id)
+            root_taxonomy_id = taxonomy.root_taxonomy.id
+
+            return nil if !root_taxonomy_id || !taxonomy_id
+
+            [root_taxonomy_id, [taxonomy_id]]
+          end.compact
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/accountability/admin/result_bulk_actions_form.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Accountability
+    module Admin
+      # This class holds a Form to create/update results from Decidim's admin panel.
+      class ResultBulkActionsForm < Decidim::Form
+        include Decidim::TranslationsHelper
+        include Decidim::HasTaxonomyFormAttributes
+
+        attribute :result_ids, Array[Integer]
+        attribute :start_date, Decidim::Attributes::LocalizedDate
+        attribute :end_date, Decidim::Attributes::LocalizedDate
+        attribute :decidim_accountability_status_id, Integer
+      end
+    end
+  end
+end

data/app/forms/decidim/accountability/admin/result_form.rb

@@ -5,14 +5,13 @@ module Decidim
     module Admin
       # This class holds a Form to create/update results from Decidim's admin panel.
       class ResultForm < Decidim::Form
-        include TranslatableAttributes
-        include TranslationsHelper
+        include Decidim::TranslatableAttributes
+        include Decidim::TranslationsHelper
+        include Decidim::HasTaxonomyFormAttributes
 
         translatable_attribute :title, String
         translatable_attribute :description, Decidim::Attributes::RichText
 
-        attribute :decidim_scope_id, Integer
-        attribute :decidim_category_id, Integer
         attribute :proposal_ids, Array[Integer]
         attribute :project_ids, Array[Integer]
         attribute :start_date, Decidim::Attributes::LocalizedDate
@@ -22,25 +21,26 @@ module Decidim
         attribute :parent_id, Integer
         attribute :external_id, String
         attribute :weight, Float
+        attribute :address, String
+        attribute :latitude, Float
+        attribute :longitude, Float
 
         validates :title, translatable_presence: true
 
         validates :progress, numericality: { greater_than_or_equal_to: 0, less_than_or_equal_to: 100 }, if: ->(form) { form.progress.present? }
 
-        validates :scope, presence: true, if: ->(form) { form.decidim_scope_id.present? }
-        validates :decidim_scope_id, scope_belongs_to_component: true, if: ->(form) { form.decidim_scope_id.present? }
-
-        validates :category, presence: true, if: ->(form) { form.decidim_category_id.present? }
-
         validates :parent, presence: true, if: ->(form) { form.parent_id.present? }
         validates :status, presence: true, if: ->(form) { form.decidim_accountability_status_id.present? }
 
-        delegate :categories, to: :current_component
+        validates :address, geocoding: true, if: ->(form) { form.has_address? && !form.geocoded? }
 
         def map_model(model)
           self.proposal_ids = model.linked_resources(:proposals, "included_proposals").pluck(:id)
           self.project_ids = model.linked_resources(:projects, "included_projects").pluck(:id)
-          self.decidim_category_id = model.category.try(:id)
+        end
+
+        def participatory_space_manifest
+          @participatory_space_manifest ||= current_component.participatory_space.manifest.name
         end
 
         def proposals
@@ -55,22 +55,16 @@ module Decidim
                                &.select(:title, :id)&.map { |a| [a.title[I18n.locale.to_s], a.id] }
         end
 
-        # Finds the Scope from the given decidim_scope_id, uses participatory space scope if missing.
-        #
-        # Returns a Decidim::Scope
-        def scope
-          @scope ||= @attributes["decidim_scope_id"].value ? current_component.scopes.find_by(id: @attributes["decidim_scope_id"].value) : current_component.scope
+        def geocoding_enabled?
+          Decidim::Map.available?(:geocoding) && current_component.settings.geocoding_enabled?
         end
 
-        # Scope identifier
-        #
-        # Returns the scope identifier related to the result
-        def decidim_scope_id
-          super || scope&.id
+        def has_address?
+          geocoding_enabled? && address.present?
         end
 
-        def category
-          @category ||= categories.find_by(id: decidim_category_id)
+        def geocoded?
+          latitude.present? && longitude.present?
         end
 
         def parent

data/app/helpers/decidim/accountability/admin/application_helper.rb

@@ -6,7 +6,6 @@ module Decidim
       # Custom helpers, scoped to the accountability admin engine.
       #
       module ApplicationHelper
-        include Decidim::Admin::ResourceScopeHelper
         include Decidim::PaginateHelper
       end
     end

data/app/helpers/decidim/accountability/application_helper.rb

@@ -7,6 +7,7 @@ module Decidim
     module ApplicationHelper
       include PaginateHelper
       include Decidim::Comments::CommentsHelper
+      include Decidim::MapHelper
 
       def display_percentage(number)
         return if number.blank?
@@ -18,38 +19,6 @@ module Decidim
         (defined?(current_component) && translated_attribute(current_component&.name).presence) || t("decidim.components.accountability.name")
       end
 
-      def filter_items_for(participatory_space:, category:)
-        [
-          {
-            url: url_for(filter: { with_category: category.try(:id) }),
-            text: t("results.filters.all", scope: "decidim.accountability"),
-            icon: "apps-2-line",
-            active: current_scope.blank?,
-            sr_text: Decidim::Scope.model_name.human(count: 2)
-          },
-          *(
-            if participatory_space.scope
-              [{
-                url: url_for(filter: { with_scope: participatory_space.scope.id, with_category: category.try(:id) }),
-                text: translated_attribute(participatory_space.scope.name),
-                icon: resource_type_icon_key(participatory_space.scope.class),
-                active: participatory_space.scope.id.to_s == current_scope.to_s,
-                sr_text: Decidim::Scope.model_name.human(count: 1)
-              }]
-            end
-          ),
-          *participatory_space.subscopes.map do |scope|
-            {
-              url: url_for(filter: { with_scope: scope.id, with_category: category.try(:id) }),
-              text: translated_attribute(scope.name),
-              icon: resource_type_icon_key(scope.class),
-              active: scope.id.to_s == current_scope.to_s,
-              sr_text: Decidim::Scope.model_name.human(count: 1)
-            }
-          end
-        ]
-      end
-
       def apply_accountability_pack_tags
         append_stylesheet_pack_tag("decidim_accountability", media: "all")
         append_javascript_pack_tag("decidim_accountability")

data/app/helpers/decidim/accountability/breadcrumb_helper.rb

@@ -5,28 +5,24 @@ module Decidim
     # Helpers needed to render the navigation breadcrumbs in results.
     #
     module BreadcrumbHelper
-      def current_scope
-        params[:filter][:with_scope] if params[:filter]
+      def progress_calculator(taxonomy_id)
+        Decidim::Accountability::ResultsCalculator.new(current_component, taxonomy_id).progress
       end
 
-      def progress_calculator(scope_id, category_id)
-        Decidim::Accountability::ResultsCalculator.new(current_component, scope_id, category_id).progress
-      end
-
-      def category
-        return if (category_id = params.dig(:filter, :with_category)).blank?
+      def taxonomy
+        return if (taxonomy_id = params.dig(:filter, :taxonomies_part_of_contains)).blank?
 
-        @category ||= current_participatory_space.categories.find(category_id.is_a?(Array) ? category_id.first : category_id)
+        @taxonomy ||= current_organization.taxonomies.find(taxonomy_id.is_a?(Array) ? taxonomy_id.first : taxonomy_id)
       end
 
-      def parent_categories(category)
-        return [] if category&.parent.blank?
+      def parent_taxonomies(taxonomy)
+        return [] if taxonomy&.parent.blank? || taxonomy&.parent&.root?
 
-        [*parent_categories(category.parent), category.parent]
+        [*parent_taxonomies(taxonomy.parent), taxonomy.parent]
       end
 
-      def categories_hierarchy
-        parent_categories(category)
+      def taxonomies_hierarchy
+        parent_taxonomies(taxonomy)
       end
     end
   end

data/app/jobs/decidim/accountability/admin/import_projects_job.rb

@@ -28,11 +28,13 @@ module Decidim
           params = {
             title: project.title,
             description: project.description,
-            category: project.category,
-            scope: project.scope || project.budget.scope,
+            taxonomies: project.taxonomies,
             component:,
             status:,
-            progress: status&.progress || 0
+            progress: status&.progress || 0,
+            address: project.address,
+            latitude: project.latitude,
+            longitude: project.longitude
           }
           @result = Decidim.traceability.create!(
             Result,

data/app/jobs/decidim/accountability/admin/import_proposals_job.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Accountability
+    module Admin
+      class ImportProposalsJob < ApplicationJob
+        queue_as :default
+
+        def perform(proposals, component, user)
+          proposals.map do |id|
+            original_proposal = Decidim::Proposals::Proposal.find_by(id:)
+
+            new_result = create_result_from_proposal!(original_proposal, statuses(component).first, component, user)
+            new_result.link_resources([original_proposal], "included_proposals")
+
+            copy_attachments(original_proposal, new_result)
+          end.compact
+          Decidim::Accountability::ImportProposalsMailer.import(user, component, proposals.count).deliver_now
+        end
+
+        private
+
+        def create_result_from_proposal!(proposal, status, component, user)
+          params = {
+            title: proposal.title,
+            description: proposal.body,
+            taxonomies: proposal.taxonomies,
+            component:,
+            status:,
+            progress: status&.progress || 0,
+            address: proposal.address,
+            latitude: proposal.latitude,
+            longitude: proposal.longitude
+          }
+          @result = Decidim.traceability.create!(
+            Result,
+            user,
+            params,
+            visibility: "all"
+          )
+        end
+
+        def copy_attachments(proposal, result)
+          proposal.attachments.each do |attachment|
+            new_attachment = Decidim::Attachment.new(
+              {
+                # Attached to needs to be always defined before the file is set
+                attached_to: result
+              }.merge(
+                attachment.attributes.slice("content_type", "description", "file_size", "title", "weight")
+              )
+            )
+
+            if attachment.file.attached?
+              new_attachment.file = attachment.file.blob
+            else
+              new_attachment.attached_uploader(:file).remote_url = attachment.attached_uploader(:file)
+            end
+
+            new_attachment.save!
+          end
+        end
+
+        def statuses(component)
+          Decidim::Accountability::Status.where(component:).order(:progress)
+        end
+      end
+    end
+  end
+end

data/app/mailers/decidim/accountability/import_proposals_mailer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Accountability
+    # This mailer sends a notification email containing the result of importing
+    # proposals to the results.
+    class ImportProposalsMailer < Decidim::ApplicationMailer
+      include Decidim::TranslatableAttributes
+      helper Decidim::TranslationsHelper
+
+      # Public: Sends a notification email with the result of proposals import selected proposals to Accountability
+      #
+      # user   - The user to be notified.
+      #
+      # Returns nothing.
+      def import(user, component, proposals)
+        @user = user
+        @organization = user.organization
+        @component = component
+        @proposals = proposals
+
+        with_user(user) do
+          mail(to: "#{user.name} <#{user.email}>", subject: I18n.t("decidim.accountability.import_proposals_mailer.import.subject"))
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,7 @@ module Decidim
     # title, description and any other useful information to render a custom result.
     class Result < Accountability::ApplicationRecord
       include Decidim::Resourceable
+      include Decidim::Taxonomizable
       include Decidim::HasAttachments
       include Decidim::HasAttachmentCollections
       include Decidim::HasComponent
@@ -20,6 +21,7 @@ module Decidim
       include Decidim::Searchable
       include Decidim::TranslatableResource
       include Decidim::FilterableResource
+      include Decidim::SoftDeletable
 
       component_manifest_name "accountability"
 
@@ -45,10 +47,16 @@ module Decidim
         datetime: :start_date
       )
 
+      geocoded_by :address
+
       def self.log_presenter_class_for(_log)
         Decidim::Accountability::AdminLog::ResultPresenter
       end
 
+      def presenter
+        Decidim::Accountability::ResultPresenter.new(self)
+      end
+
       def update_parent_progress
         return if parent.blank?
 
@@ -83,7 +91,7 @@ module Decidim
       end
 
       def self.ransackable_scopes(_auth_object = nil)
-        [:with_category, :with_scope]
+        [:with_any_taxonomies]
       end
 
       ransacker :id_string do
@@ -94,6 +102,20 @@ module Decidim
       # Create the :search_text ransacker alias for searching from both of these.
       ransacker_i18n_multi :search_text, [:title, :description]
 
+      def self.ransackable_attributes(auth_object = nil)
+        base = %w(search_text title description)
+
+        return base unless auth_object&.admin?
+
+        base + %w(id_string created_at id progress)
+      end
+
+      def self.ransackable_associations(auth_object = nil)
+        return [] unless auth_object&.admin?
+
+        %w(taxonomies status)
+      end
+
       private
 
       # Private: When a row uses weight 1 and there is more than one, weight should not be considered