decidim-challenges 0.5.0

data/app/controllers/decidim/solutions/admin/solutions_controller.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Solutions
+    module Admin
+      # Controller that allows managing admin problems.
+      #
+      class SolutionsController < Decidim::Solutions::Admin::ApplicationController
+        include Decidim::ApplicationHelper
+
+        helper Challenges::ApplicationHelper
+        helper Decidim::PaginateHelper
+
+        helper_method :solution, :solution, :form_presenter
+
+        def index
+          enforce_permission_to :read, :solutions
+          @solutions = solutions
+        end
+
+        def show
+          enforce_permission_to :show, :solution
+          @solution = Decidim::Solutions::Solution.find(params[:id])
+        end
+
+        def new
+          enforce_permission_to :create, :solution
+          @form = form(Decidim::Solutions::Admin::SolutionsForm).instance
+        end
+
+        def edit
+          enforce_permission_to(:edit, :solution, solution:)
+          @form = form(Decidim::Solutions::Admin::SolutionsForm).from_model(solution)
+        end
+
+        def create
+          enforce_permission_to :create, :solution
+          @form = form(Decidim::Solutions::Admin::SolutionsForm).from_params(params.merge({ author_id: current_user.id }))
+
+          Decidim::Solutions::Admin::CreateSolution.call(@form) do
+            on(:ok) do
+              flash[:notice] = I18n.t("solutions.create.success", scope: "decidim.solutions.admin")
+              redirect_to solutions_path(assembly_slug: -1, component_id: -1)
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("solutions.create.error", scope: "decidim.solutions.admin")
+              render action: "new"
+            end
+          end
+        end
+
+        def update
+          enforce_permission_to(:edit, :solution, solution:)
+          @form = form(Decidim::Solutions::Admin::SolutionsForm).from_params(params.merge({ author_id: current_user.id }))
+
+          Decidim::Solutions::Admin::UpdateSolution.call(@form, solution) do
+            on(:ok) do |_solution|
+              flash[:notice] = t("solutions.update.success", scope: "decidim.solutions.admin")
+              redirect_to solutions_path(assembly_slug: -1, component_id: -1)
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = t("solutions.update.error", scope: "decidim.solutions.admin")
+              render :edit
+            end
+          end
+        end
+
+        def destroy
+          enforce_permission_to(:destroy, :solution, solution:)
+
+          Decidim::Solutions::Admin::DestroySolution.call(solution, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("solutions.destroy.success", scope: "decidim.solutions.admin")
+              redirect_to solutions_path(assembly_slug: -1, component_id: -1)
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = t("solutions.destroy.error", scope: "decidim.solutions.admin")
+              redirect_to solutions_path(assembly_slug: -1, component_id: -1)
+            end
+          end
+        end
+
+        private
+
+        def collection
+          @collection ||= Solution.where(component: current_component)
+        end
+
+        def solutions
+          @solutions ||= collection.page(params[:page]).per(10)
+        end
+
+        def solution
+          @solution ||= collection.find(params[:id])
+        end
+
+        def form_presenter
+          @form_presenter ||= present(@form, presenter_class: Decidim::Solutions::SolutionPresenter)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Solutions
+    # This controller is the abstract class from which all other controllers of
+    # this engine inherit.
+    #
+    # Note that it inherits from `Decidim::Components::BaseController`, which
+    # override its layout and provide all kinds of useful methods.
+    class ApplicationController < Decidim::Components::BaseController
+    end
+  end
+end

data/app/controllers/decidim/solutions/solutions_controller.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Solutions
+    # Controller that allows browsing solutions.
+    #
+    class SolutionsController < Decidim::Solutions::ApplicationController
+      include Decidim::ApplicationHelper
+      include FilterResource
+      include Paginable
+      include OrderableSolutions
+      include FormFactory
+      include WithSdgs
+      include WithDefaultFilters
+
+      helper Decidim::CheckBoxesTreeHelper
+      helper Decidim::Sdgs::SdgsHelper
+      helper Decidim::ShowFiltersHelper
+      helper SolutionsHelper
+      helper Decidim::Challenges::ApplicationHelper
+
+      helper_method :solutions, :form_presenter, :has_sdgs?, :has_problem?, :default_filter_scope_params
+
+      def index
+        @solutions = search.result
+        @solutions = reorder(@solutions)
+        @solutions = paginate(@solutions)
+      end
+
+      def show
+        @solution = solution
+        if @solution.problem.present?
+          @sectorial_scope = sectorial_scope
+          @technological_scope = technological_scope
+        end
+        @sdg_index = sdg_index if @solution.problem.present? || @solution.challenge.present?
+        @challenge_scope = challenge_scope
+      end
+
+      def new
+        enforce_permission_to :create, :solution
+        @form = form(Decidim::Solutions::SolutionsForm).instance
+      end
+
+      def create
+        enforce_permission_to :create, :solution
+        @form = form(Decidim::Solutions::SolutionsForm).from_params(params.merge({ author_id: current_user.id }))
+
+        Decidim::Solutions::CreateSolution.call(@form) do
+          on(:ok) do
+            flash[:notice] = I18n.t("solutions.create.success", scope: "decidim.solutions")
+            redirect_to solutions_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("solutions.create.error", scope: "decidim.solutions")
+            render action: "new"
+          end
+        end
+      end
+
+      private
+
+      def default_filter_params
+        {
+          search_text_cont: "",
+          with_any_territorial_scope: default_filter_scope_params,
+          with_any_sdgs_codes: [],
+          related_to: "",
+        }
+      end
+
+      def solutions
+        @solutions ||= reorder(paginate(search.result))
+      end
+
+      def solution
+        @solution ||= Solution.find(params[:id])
+      end
+
+      def sdg_index
+        challenge = @solution.problem ? @solution.problem.challenge : @solution.challenge
+        @sdg_index ||= challenge.sdg_code ? (1 + Decidim::Sdgs::Sdg.index_from_code(challenge.sdg_code.to_sym)).to_s.rjust(2, "0") : nil
+      end
+
+      def challenge_scope
+        @challenge_scope ||= if @solution.problem.present?
+                               current_organization.scopes.find_by(id: @solution.problem.challenge.decidim_scope_id)
+                             else
+                               current_organization.scopes.find_by(id: @solution.challenge&.decidim_scope_id)
+                             end
+      end
+
+      def sectorial_scope
+        @sectorial_scope ||= current_organization.scopes.find_by(id: @solution.problem.decidim_sectorial_scope_id)
+      end
+
+      def technological_scope
+        @technological_scope ||= current_organization.scopes.find_by(id: @solution.problem.decidim_technological_scope_id)
+      end
+
+      def search_collection
+        ::Decidim::Solutions::Solution.where(component: current_component).published
+      end
+
+      def form_presenter
+        @form_presenter ||= present(@form, presenter_class: Decidim::Solutions::SolutionPresenter)
+      end
+
+      def has_problem?
+        current_participatory_space.components.where(manifest_name: "problems").present? && @solution.problem.present?
+      end
+    end
+  end
+end

data/app/forms/decidim/challenges/admin/challenge_surveys_form.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Challenges
+    module Admin
+      # This class holds a Form to update challenges surveys from Decidim's admin panel.
+      class ChallengeSurveysForm < Decidim::Form
+        mimic :challenge
+
+        attribute :survey_enabled, Boolean
+
+        # We need this method to ensure the form object will always have an ID,
+        # and thus its `to_param` method will always return a significant value.
+        # If we remove this method, get an error onn the `update` action and try
+        # to resubmit the form, the form will not hold an ID, so the `to_param`
+        # method will return an empty string and Rails will treat this as a
+        # `create` action, thus raising an error since this action is not defined
+        # for the controller we're using.
+        #
+        # TL;DR: if you remove this method, we'll get errors, so don't.
+        def id
+          return super if super.present?
+
+          challenge.id
+        end
+
+        private
+
+        def challenge
+          @challenge ||= context[:challenge]
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/challenges/admin/challenges_form.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Challenges
+    module Admin
+      # A form object used to create challenges from the admin dashboard.
+      #
+      class ChallengesForm < Decidim::Form
+        include TranslatableAttributes
+        include Decidim::Sdgs::SdgsHelper
+        include Decidim::HasUploadValidations
+
+        mimic :challenge
+
+        translatable_attribute :title, String do |field, _locale|
+          validates field, length: { in: 5..150 }, if: proc { |resource| resource.send(field).present? }
+        end
+        translatable_attribute :local_description, String
+        translatable_attribute :global_description, String
+
+        attribute :decidim_component_id, Integer
+        attribute :decidim_scope_id, Integer
+        attribute :tags, String
+        attribute :sdg_code, String
+        attribute :state, Integer
+        attribute :end_date, Decidim::Attributes::LocalizedDate
+        attribute :start_date, Decidim::Attributes::LocalizedDate
+        attribute :coordinating_entities, String
+        attribute :collaborating_entities, String
+
+        attribute :card_image
+        attribute :remove_card_image, Boolean, default: false
+
+        validates :title, :local_description, :global_description, translatable_presence: true
+        validates :scope, presence: true, if: ->(form) { form.decidim_scope_id.present? }
+        validate :valid_state
+
+        validates :start_date, presence: true, date: { before_or_equal_to: :end_date }
+        validates :end_date, presence: true, date: { after_or_equal_to: :start_date }
+
+        validates :card_image,
+                  presence: false,
+                  passthru: { to: Decidim::Attachment }
+
+        alias organization current_organization
+
+        def select_states_collection
+          Decidim::Challenges::Challenge::VALID_STATES.map.with_index do |state, idx|
+            [I18n.t(state, scope: "decidim.challenges.states"), idx]
+          end
+        end
+
+        def select_sdg_collection
+          Decidim::Sdgs::Sdg::SDGS.map do |sdg_code|
+            [I18n.t("#{sdg_code}.objectives.subtitle", scope: "decidim.components.sdgs"), sdg_code]
+          end
+        end
+
+        # Finds the Scope from the given decidim_scope_id, uses participatory space scope if missing.
+        #
+        # Returns a Decidim::Scope
+        def scope
+          @scope ||= current_organization.scopes.find_by(id: decidim_scope_id)
+        end
+
+        def map_model(model); end
+
+        private
+
+        def valid_state
+          return if state && Decidim::Challenges::Challenge::VALID_STATES[state].present?
+
+          errors.add(:state, :invalid)
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/problems/admin/problems_form.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Problems
+    module Admin
+      # A form object used to create problems from the admin dashboard.
+      #
+      class ProblemsForm < Decidim::Form
+        include TranslatableAttributes
+
+        mimic :problem
+
+        translatable_attribute :title, String do |field, _locale|
+          validates field, length: { in: 5..150 }, if: proc { |resource| resource.send(field).present? }
+        end
+        translatable_attribute :description, String
+
+        attribute :decidim_challenges_challenge_id, Integer
+        attribute :decidim_sectorial_scope_id, Integer
+        attribute :decidim_technological_scope_id, Integer
+        attribute :tags, String
+        attribute :causes, String
+        attribute :groups_affected, String
+        attribute :state, Integer
+        attribute :end_date, Decidim::Attributes::LocalizedDate
+        attribute :start_date, Decidim::Attributes::LocalizedDate
+        attribute :proposing_entities, String
+        attribute :collaborating_entities, String
+
+        validates :title, :description, translatable_presence: true
+        validates :sectorial_scope, presence: true, if: ->(form) { form.decidim_sectorial_scope_id.present? }
+        validates :technological_scope, presence: true, if: ->(form) { form.decidim_technological_scope_id.present? }
+        validate :valid_state
+        validates :decidim_challenges_challenge_id, presence: true
+
+        validates :start_date, presence: true, date: { before_or_equal_to: :end_date }
+        validates :end_date, presence: true, date: { after_or_equal_to: :start_date }
+
+        alias organization current_organization
+
+        # Return a problem's valid states list
+        def select_states_collection
+          Decidim::Problems::Problem::VALID_STATES.map.with_index do |state, idx|
+            [I18n.t(state, scope: "decidim.problems.states"), idx]
+          end
+        end
+
+        # Return a challenge's list filtered by participatory's space component
+        def select_challenge_collection
+          participatory_space = Decidim::Component.find(current_component.id).participatory_space
+          challenge_component = Decidim::Component.where(participatory_space:).where(manifest_name: "challenges")
+          Decidim::Challenges::Challenge.where(component: challenge_component).map do |ch|
+            [translated_attribute(ch.title), ch.id]
+          end
+        end
+
+        # Finds the Sectorial Scope from the given decidim_sectorial_scope_id
+        #
+        # Returns a Decidim::Scope
+        def sectorial_scope
+          @sectorial_scope ||= current_organization.scopes.find_by(id: decidim_sectorial_scope_id)
+        end
+
+        # Finds the Technological Scope from the given decidim_technological_scope_id
+        #
+        # Returns a Decidim::Scope
+        def technological_scope
+          @technological_scope ||= current_organization.scopes.find_by(id: decidim_technological_scope_id)
+        end
+
+        # Finds the Challenge from the given decidim_challenges_challenge_id
+        #
+        # Returns a Decidim::Challenges::Challenge
+        def challenge
+          @challenge ||= @decidim_challenges_challenge_id ? Decidim::Challenges::Challenge.find(@decidim_challenges_challenge_id) : false
+        end
+
+        def map_model(model); end
+
+        private
+
+        def valid_state
+          return if state.present? && Decidim::Problems::Problem::VALID_STATES[state].present?
+
+          errors.add(:state, :invalid)
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/solutions/admin/solutions_form.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Solutions
+    module Admin
+      # A form object used to create solutions from the admin dashboard.
+      #
+      class SolutionsForm < Decidim::Form
+        include TranslatableAttributes
+
+        mimic :solution
+
+        translatable_attribute :title, String do |field, _locale|
+          validates field, length: { in: 5..150 }, if: proc { |resource| resource.send(field).present? }
+        end
+        translatable_attribute :description, String
+
+        attribute :decidim_problems_problem_id, Integer
+        attribute :decidim_challenges_challenge_id, Integer
+        attribute :author_id, Integer
+        attribute :tags, String
+        translatable_attribute :objectives, String
+        translatable_attribute :indicators, String
+        translatable_attribute :beneficiaries, String
+        translatable_attribute :requirements, String
+        translatable_attribute :financing_type, String
+
+        validates :title, :description, translatable_presence: true
+        validates :decidim_challenges_challenge_id, presence: false
+        validates :decidim_problems_problem_id, presence: false
+        validates :author_id, presence: true
+
+        alias organization current_organization
+
+        # Return a problem's list filtered by participatory's space component
+        def select_problem_collection
+          participatory_space = Decidim::Component.find(current_component.id).participatory_space
+          problem_component = Decidim::Component.where(participatory_space:).where(manifest_name: "problems")
+          Decidim::Problems::Problem.where(component: problem_component).map do |p|
+            [translated_attribute(p.title), p.id]
+          end
+        end
+
+        # Return a challenges's list filtered by participatory's space component
+        def select_challenge_collection
+          participatory_space = Decidim::Component.find(current_component.id).participatory_space
+          challenge_component = Decidim::Component.where(participatory_space:).where(manifest_name: "challenges")
+          Decidim::Challenges::Challenge.where(component: challenge_component).map do |p|
+            [translated_attribute(p.title), p.id]
+          end
+        end
+
+        # Finds the Problem from the given decidim_problems_problem_id
+        #
+        # Returns a Decidim::Problems::Problem
+        def problem
+          @problem ||= decidim_problems_problem_id.present? ? Decidim::Problems::Problem.find(decidim_problems_problem_id) : false
+        end
+
+        # Finds the Challenge from the given decidim_challenges_challenge_id
+        #
+        # Returns a Decidim::Challenges::Challenge
+        def challenge
+          @challenge ||= @problem.present? ? Decidim::Challenges::Challenge.find(@problem.challenge.id) : false
+        end
+
+        def map_model(model); end
+      end
+    end
+  end
+end

data/app/forms/decidim/solutions/solutions_form.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Solutions
+    # A form object to be used when public users want to create a solution.
+    #
+    class SolutionsForm < Decidim::Form
+      include Decidim::AttachmentAttributes
+      include Decidim::HasUploadValidations
+
+      mimic :solution
+
+      attribute :title, String
+      attribute :description, Decidim::Attributes::CleanString
+      attribute :project_status, String
+      attribute :project_url, String
+      attribute :coordinating_entity, String
+      attribute :decidim_challenges_challenge_id, Integer
+      attribute :decidim_problems_problem_id, Integer
+      attribute :author_id, Integer
+      attribute :attachment, AttachmentForm
+
+      attachments_attribute :documents
+
+      validates :title, :description, presence: true, etiquette: true
+      validates :project_status, :coordinating_entity, presence: true
+      validates :decidim_challenges_challenge_id, :author_id, presence: true
+      validates :decidim_problems_problem_id, presence: false
+
+      def map_model(model)
+        self.title = translated_attribute(model.title)
+        self.description = translated_attribute(model.description)
+
+        self.documents = model.attachments
+        return unless model.categorization
+      end
+
+      # Finds the Challenge from the given decidim_challenges_challenge_id
+      #
+      # Returns a Decidim::Challenges::Challenge
+      def challenge
+        @challenge ||= @problem.present? ? Decidim::Challenges::Challenge.find(@problem.challenge.id) : Decidim::Challenges::Challenge.find(@decidim_challenges_challenge_id)
+      end
+
+      def author
+        Decidim::User.find(author_id)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Challenges
+    # Custom helpers, scoped to the challenges engine.
+    #
+    module ApplicationHelper
+      def component_name
+        i18n_key = "decidim.components.challenges.name"
+        (defined?(current_component) && translated_attribute(current_component&.name).presence) || t(i18n_key)
+      end
+
+      def filter_custom_state_values
+        Decidim::CheckBoxesTreeHelper::TreeNode.new(
+          Decidim::CheckBoxesTreeHelper::TreePoint.new("", t("decidim.challenges.challenges_helper.filter_state_values.all")),
+          [
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("proposal", t("decidim.challenges.challenges_helper.filter_state_values.proposal")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("execution", t("decidim.challenges.challenges_helper.filter_state_values.execution")),
+            Decidim::CheckBoxesTreeHelper::TreePoint.new("finished", t("decidim.challenges.challenges_helper.filter_state_values.finished")),
+          ]
+        )
+      end
+    end
+  end
+end

data/app/helpers/decidim/challenges/challenge_cells_helper.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Challenges
+    # Custom helpers, scoped to the challenges engine.
+    #
+    module ChallengeCellsHelper
+      include Decidim::Challenges::ApplicationHelper
+      include Decidim::Challenges::Engine.routes.url_helpers
+      include Decidim::LayoutHelper
+      include Decidim::ApplicationHelper
+      include Decidim::TranslationsHelper
+      include Decidim::ResourceReferenceHelper
+      include Decidim::TranslatableAttributes
+      include Decidim::CardHelper
+      include WithSdgs
+
+      delegate :title, :state, :published_state?, :withdrawn?, :amendable?, :emendation?, to: :model
+
+      def has_actions?
+        return context[:has_actions] if context[:has_actions].present?
+
+        challenges_controller? && index_action? && current_settings.votes_enabled? && !model.draft?
+      end
+
+      def has_footer?
+        return context[:has_footer] if context[:has_footer].present?
+
+        challenges_controller? && index_action? && current_settings.votes_enabled? && !model.draft?
+      end
+
+      def challenges_controller?
+        context[:controller].instance_of?(::Decidim::Challenges::ChallengesController)
+      end
+
+      def index_action?
+        context[:controller].action_name == "index"
+      end
+
+      def current_settings
+        model.component.current_settings
+      end
+
+      def component_settings
+        model.component.settings
+      end
+
+      def current_component
+        model.component
+      end
+
+      def from_context
+        options[:from]
+      end
+    end
+  end
+end

data/app/helpers/decidim/challenges/challenges_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Challenges
+    # Custom helpers, scoped to the challenges engine.
+    #
+    module ChallengesHelper
+      def filter_sections
+        items = []
+        items.append(method: :with_any_state, collection: filter_custom_state_values, label_scope: "decidim.shared.filters", id: "state")
+        items.append(method: :related_to, collection: linked_classes_filter_values_for(Decidim::Challenges::Challenge), label_scope: "decidim.shared.filters", id: "related_to",
+                     type: :radio_buttons)
+        if current_participatory_space.has_subscopes?
+          items.append(method: :with_any_scope, collection: filter_global_scopes_values, label_scope: "decidim.shared.filters",
+                       id: "scope")
+        end
+
+        items.reject { |item| item[:collection].blank? }
+      end
+
+      def challenge_associated_solutions(challenge)
+        solutions_component = Decidim::Component.find_by(participatory_space: challenge.participatory_space, manifest_name: "solutions")
+        return [] unless solutions_component&.published?
+
+        problems_component = Decidim::Component.find_by(participatory_space: challenge.participatory_space, manifest_name: "problems")
+        if problems_component&.published?
+          challenge.problems.published.map { |problem| problem.solutions.published }.flatten
+        else
+          challenge.solutions.published
+        end
+      end
+
+      def truncate_description(description)
+        translated_description = raw translated_attribute description
+        decidim_sanitize(html_truncate(translated_description, length: 200))
+      end
+    end
+  end
+end