decidim-proposals 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f981594ab6257e9cf721a9ffd76368d8c86c96f8
-  data.tar.gz: e857387adb235b90d3f758f57565712fccca1334
+  metadata.gz: 72d9615abcde37945383d87bb3f7c74126d66b3c
+  data.tar.gz: 588e35fae074a55307aab6789d6d3af25db87d9a
 SHA512:
-  metadata.gz: 6ed1c5ea32849f63efe358f438fc878b833528030d6d12d0669953e5419866c8a24a5c1f9dfb2c56f76e6f854a19487920c4bc0354f8db5853bfdc48aa7c9717
-  data.tar.gz: efb15ffb3ad5e9fbfea35fa780a0966e9b5d44899c7c8dde74dd1ce418bea634b268b2a9e7faf5cbfd349b067139add3f128dabd06cbdfca3428aedb3ffbd134
+  metadata.gz: a883d5c8a999da8fb3f0bda1811678905858d1693f69b846b975b66f2c25cbdbf0bfa7c671ceb991519f2b68972ae2cef71bd08be7a21f03cda07a5dfbe6cc9e
+  data.tar.gz: d0882dff25bb3c47491036de7988d4e1fd392e6d1806e49a287ebcd4cf02e9e70a6a64b829e07102e16607ea31363ba17afb1dbed0968450df66e02ba2033330

data/app/assets/stylesheets/decidim/proposals/social_share.css.scss

@@ -1,6 +1,11 @@
 /*= require social-share-button */
 $size: 45px;
 
+.share-link:hover {
+  text-decoration: underline;
+  cursor: pointer;
+}
+
 .social-share-button {
   display: inline-block;
   vertical-align: top;

data/app/commands/decidim/proposals/admin/answer_proposal.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+module Decidim
+  module Proposals
+    module Admin
+      # A command with all the business logic when an admin answers a proposal.
+      class AnswerProposal < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        # proposal - The proposal to write the answer for.
+        def initialize(form, proposal)
+          @form = form
+          @proposal = proposal
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          answer_proposal
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form, :proposal
+
+        def answer_proposal
+          proposal.update_attributes!(
+            state: @form.state,
+            answer: @form.answer,
+            answered_at: Time.current
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/proposals/create_proposal.rb

@@ -36,6 +36,7 @@ module Decidim
           category: form.category,
           scope: form.scope,
           author: @current_user,
+          decidim_user_group_id: form.user_group_id,
           feature: form.feature
         )
       end

data/app/controllers/decidim/proposals/admin/proposal_answers_controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+module Decidim
+  module Proposals
+    module Admin
+      # This controller allows admins to answer proposals in a participatory process.
+      class ProposalAnswersController < Admin::ApplicationController
+        helper_method :proposal
+
+        def edit
+          @form = form(Admin::ProposalAnswerForm).from_model(proposal)
+        end
+
+        def update
+          @form = form(Admin::ProposalAnswerForm).from_params(params)
+
+          Admin::AnswerProposal.call(@form, proposal) do
+            on(:ok) do
+              flash[:notice] = I18n.t("proposals.answer.success", scope: "decidim.proposals.admin")
+              redirect_to proposals_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("proposals.answer.invalid", scope: "decidim.proposals.admin")
+              render action: "edit"
+            end
+          end
+        end
+
+        private
+
+        def proposal
+          @proposals ||= Proposal.where(feature: current_feature).find(params[:id])
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/proposals/admin/proposals_controller.rb

@@ -4,6 +4,7 @@ module Decidim
     module Admin
       # This controller allows admins to manage proposals in a participatory process.
       class ProposalsController < Admin::ApplicationController
+        helper Proposals::ApplicationHelper
         helper_method :proposals
 
         def new

data/app/controllers/decidim/proposals/proposal_votes_controller.rb

@@ -4,21 +4,32 @@ module Decidim
   module Proposals
     # Exposes the proposal vote resource so users can vote proposals.
     class ProposalVotesController < Decidim::Proposals::ApplicationController
+      include ProposalVotesHelper
+
+      helper_method :proposal
+
       before_action :authenticate_user!
-      before_action :check_current_settings!
 
       def create
-        @proposal = Proposal.where(feature: current_feature).find(params[:proposal_id])
-        @proposal.votes.create!(author: current_user)
+        authorize! :vote, proposal
+
+        proposal.votes.create!(author: current_user)
+        @from_proposals_list = params[:from_proposals_list] == "true"
+        render :update_buttons_and_counters
+      end
+
+      def destroy
+        authorize! :unvote, proposal
+
+        proposal.votes.where(author: current_user).delete_all
         @from_proposals_list = params[:from_proposals_list] == "true"
+        render :update_buttons_and_counters
       end
 
       private
 
-      # The vote buttons should not be visible if the setting is not enabled.
-      # This ensure the votes cannot be created using a POST request directly.
-      def check_current_settings!
-        raise "This setting is not enabled for this step" unless current_settings.votes_enabled?
+      def proposal
+        @proposal ||= Proposal.where(feature: current_feature).find(params[:proposal_id])
       end
     end
   end

data/app/controllers/decidim/proposals/proposals_controller.rb

@@ -18,14 +18,21 @@ module Decidim
                      .results
                      .includes(:author)
                      .includes(votes: [:author])
+                     .page(params[:page])
+                     .per(12)
+
         @random_seed = search.random_seed
       end
 
       def new
+        authorize! :create, Proposal
+
         @form = form(ProposalForm).from_params({})
       end
 
       def create
+        authorize! :create, Proposal
+
         @form = form(ProposalForm).from_params(params)
 
         CreateProposal.call(@form, current_user) do
@@ -47,19 +54,13 @@ module Decidim
         ProposalSearch
       end
 
-      def default_search_params
-        {
-          page: params[:page],
-          per_page: 12
-        }
-      end
-
       def default_filter_params
         {
           search_text: "",
           origin: "all",
           activity: "",
           category_id: "",
+          state: "all",
           random_seed: params[:random_seed]
         }
       end

data/app/forms/decidim/proposals/admin/proposal_answer_form.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Decidim
+  module Proposals
+    module Admin
+      # A form object to be used when admin users want to answer a proposal.
+      class ProposalAnswerForm < Decidim::Form
+        include TranslatableAttributes
+        mimic :proposal_answer
+
+        translatable_attribute :answer, String
+        attribute :state, String
+
+        validates :state, presence: true, inclusion: { in: %w(accepted rejected) }
+        validates :answer, translatable_presence: true, if: ->(form) { form.state == "rejected" }
+      end
+    end
+  end
+end

data/app/forms/decidim/proposals/proposal_form.rb

@@ -9,6 +9,7 @@ module Decidim
       attribute :body, String
       attribute :category_id, Integer
       attribute :scope_id, Integer
+      attribute :user_group_id, Integer
 
       validates :title, :body, presence: true
       validates :category, presence: true, if: ->(form) { form.category_id.present? }

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

@@ -7,6 +7,23 @@ module Decidim
       include Decidim::Comments::CommentsHelper
       include PaginateHelper
       include ProposalVotesHelper
+
+      # Public: The state of a proposal in a way a human can understand.
+      #
+      # state - The String state of the proposal.
+      #
+      # Returns a String.
+      def humanize_proposal_state(state)
+        value = if state == "accepted"
+                  "accepted"
+                elsif state == "rejected"
+                  "rejected"
+                else
+                  "not_answered"
+                end
+
+        I18n.t(value, scope: "decidim.proposals.answers")
+      end
     end
   end
 end

data/app/helpers/decidim/proposals/proposal_votes_helper.rb

@@ -22,6 +22,25 @@ module Decidim
         return "small" if from_proposals_list
         "expanded button--sc"
       end
+
+      # Check if the vote limit is enabled for the current feature
+      #
+      # Returns true if the vote limit is enabled
+      def vote_limit_enabled?
+        current_user && feature_settings.vote_limit.present? && feature_settings.vote_limit.positive?
+      end
+
+      # Return the remaining votes for a user if the current feature has a vote limit
+      #
+      # user - A User object
+      #
+      # Returns a number with the remaining votes for that user
+      def remaining_votes_count_for(user)
+        return 0 unless vote_limit_enabled?
+        proposals = Proposal.where(feature: current_feature)
+        votes_count = ProposalVote.where(author: user, proposal: proposals).size
+        feature_settings.vote_limit - votes_count
+      end
     end
   end
 end

data/app/models/decidim/proposals/abilities/current_user.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+module Decidim
+  module Proposals
+    module Abilities
+      # Defines the abilities related to proposals for a logged in user.
+      # Intended to be used with `cancancan`.
+      class CurrentUser
+        include CanCan::Ability
+
+        attr_reader :user, :context
+
+        def initialize(user, context)
+          return unless user
+
+          @user = user
+          @context = context
+
+          can :vote, Proposal do |_proposal|
+            voting_enabled? && remaining_votes.positive?
+          end
+
+          can :unvote, Proposal do |_proposal|
+            voting_enabled? && vote_limit_enabled?
+          end
+
+          can :create, Proposal if current_settings.try(:creation_enabled?)
+        end
+
+        private
+
+        def vote_limit_enabled?
+          return unless feature_settings
+          feature_settings.vote_limit.present? && feature_settings.vote_limit.positive?
+        end
+
+        def remaining_votes
+          return 1 unless vote_limit_enabled?
+
+          proposals = Proposal.where(feature: context.fetch(:current_feature))
+          votes_count = ProposalVote.where(author: user, proposal: proposals).size
+          feature_settings.vote_limit - votes_count
+        end
+
+        def voting_enabled?
+          return unless current_settings
+          current_settings.votes_enabled? && !current_settings.votes_blocked?
+        end
+
+        def current_settings
+          context.fetch(:current_settings, nil)
+        end
+
+        def feature_settings
+          context.fetch(:feature_settings, nil)
+        end
+      end
+    end
+  end
+end

data/app/models/decidim/proposals/proposal.rb

@@ -3,58 +3,55 @@ module Decidim
   module Proposals
     # The data store for a Proposal in the Decidim::Proposals component.
     class Proposal < Proposals::ApplicationRecord
-      belongs_to :feature, foreign_key: "decidim_feature_id", class_name: Decidim::Feature
-      belongs_to :author, foreign_key: "decidim_author_id", class_name: Decidim::User
-      belongs_to :category, foreign_key: "decidim_category_id", class_name: Decidim::Category
-      belongs_to :scope, foreign_key: "decidim_scope_id", class_name: Decidim::Scope
-      has_one :organization, through: :feature
+      include Decidim::Resourceable
+      include Decidim::Authorable
+      include Decidim::HasFeature
+      include Decidim::HasScope
+      include Decidim::HasCategory
+
+      feature_manifest_name "proposals"
+
       has_many :votes, foreign_key: "decidim_proposal_id", class_name: ProposalVote, dependent: :destroy
 
-      validates :title, :feature, :body, presence: true
-      validate :category_belongs_to_feature
-      validate :scope_belongs_to_organization
-      validate :author_belongs_to_organization
+      validates :title, :body, presence: true
+
+      scope :accepted, -> { where(state: "accepted") }
+      scope :rejected, -> { where(state: "rejected") }
 
       def author_name
-        author&.name || I18n.t("decidim.proposals.models.proposal.fields.official_proposal")
+        user_group&.name || author&.name || I18n.t("decidim.proposals.models.proposal.fields.official_proposal")
       end
 
       def author_avatar_url
         author&.avatar&.url || ActionController::Base.helpers.asset_path("decidim/default-avatar.svg")
       end
 
-      # Public: Canpeople comment on this proposal?
+      # Public: Check if the user has voted the proposal.
       #
-      # Until we have a way to store options fore features and its resources we
-      # assume all proposals can be commented.
-      #
-      # Returns Boolean
-      def commentable?
-        true
-      end
-
-      # Public: Check if the user has voted the proposal
-      #
-      # Returns Boolean
+      # Returns Boolean.
       def voted_by?(user)
         votes.any? { |vote| vote.author == user }
       end
 
-      private
-
-      def category_belongs_to_feature
-        return unless category
-        errors.add(:category, :invalid) unless feature.categories.where(id: category.id).exists?
+      # Public: Checks if the organization has given an answer for the proposal.
+      #
+      # Returns Boolean.
+      def answered?
+        answered_at.present?
       end
 
-      def scope_belongs_to_organization
-        return unless scope
-        errors.add(:scope, :invalid) unless feature.scopes.where(id: scope.id).exists?
+      # Public: Checks if the organization has accepted a proposal.
+      #
+      # Returns Boolean.
+      def accepted?
+        state == "accepted"
       end
 
-      def author_belongs_to_organization
-        return unless author
-        errors.add(:author, :invalid) unless Decidim::User.where(decidim_organization_id: feature.organization.id, id: author.id).exists?
+      # Public: Checks if the organization has rejected a proposal.
+      #
+      # Returns Boolean.
+      def rejected?
+        state == "rejected"
       end
     end
   end

data/app/models/decidim/proposals/proposal_vote.rb

@@ -6,6 +6,7 @@ module Decidim
       belongs_to :proposal, foreign_key: "decidim_proposal_id", class_name: Decidim::Proposals::Proposal, counter_cache: true
       belongs_to :author, foreign_key: "decidim_author_id", class_name: Decidim::User
 
+      validates :proposal, :author, presence: true
       validates :proposal, uniqueness: { scope: :author }
       validate :author_and_proposal_same_organization
 
@@ -13,6 +14,7 @@ module Decidim
 
       # Private: check if the proposal and the author have the same organization
       def author_and_proposal_same_organization
+        return if !proposal || !author
         errors.add(:proposal, :invalid) unless author.organization == proposal.organization
       end
     end