decidim-decidim_awesome 0.8.0 → 0.12.0

data/app/controllers/concerns/decidim/decidim_awesome/proposals/memoize_extra_fields.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      module MemoizeExtraFields
+        extend ActiveSupport::Concern
+        include Decidim::DecidimAwesome::RequestMemoizer
+
+        included do
+          alias_method :decidim_original_index, :index
+
+          def index
+            decidim_original_index
+
+            memoize("extra_fields") { Decidim::DecidimAwesome::ProposalExtraField.where(proposal: @proposals).index_by(&:decidim_proposal_id) }
+            memoize("user_votes") { Decidim::Proposals::ProposalVote.where(proposal: proposals, author: current_user).index_by(&:decidim_proposal_id) if current_user }
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/decidim_awesome/proposals/orderable_override.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      module OrderableOverride
+        extend ActiveSupport::Concern
+        include Decidim::DecidimAwesome::NeedsAwesomeConfig
+
+        included do
+          before_action only: [:index] do
+            session[:order] = params[:order] if params[:order].present?
+          end
+
+          private
+
+          alias_method :decidim_original_reorder, :reorder
+
+          # read order from session if available
+          def order
+            @order ||= detect_order(session[:order]) || default_order
+          end
+
+          def possible_orders
+            @possible_orders ||= begin
+              possible_orders = %w(random recent)
+              possible_orders += awesome_additional_sortings
+              possible_orders << "most_voted" if most_voted_order_available?
+              possible_orders << "most_endorsed" if current_settings.endorsements_enabled?
+              possible_orders << "most_commented" if component_settings.comments_enabled?
+              possible_orders << "most_followed" << "with_more_authors"
+              possible_orders
+            end
+          end
+
+          def reorder(proposals)
+            title_by_locale = Arel.sql(proposals.sanitize_sql(["decidim_proposals_proposals.title->>? #{collation}", locale]))
+            title_by_machine_translation = Arel.sql(proposals.sanitize_sql(["decidim_proposals_proposals.title->'machine_translations'->>? #{collation}", locale]))
+            title_by_default_locale = Arel.sql(proposals.sanitize_sql(["decidim_proposals_proposals.title->>? #{collation}", default_locale]))
+            case order
+            when "az"
+              proposals.order(title_by_locale => :asc, title_by_machine_translation => :asc, title_by_default_locale => :asc)
+            when "za"
+              proposals.order(title_by_locale => :desc, title_by_machine_translation => :desc, title_by_default_locale => :desc)
+            when "supported_first"
+              proposals.joins(my_votes_join).group(:id).order(Arel.sql("COUNT(decidim_proposals_proposal_votes.id) DESC"))
+            when "supported_last"
+              proposals.joins(my_votes_join).group(:id).order(Arel.sql("COUNT(decidim_proposals_proposal_votes.id) ASC"))
+            else
+              decidim_original_reorder(proposals)
+            end
+          end
+
+          def collation
+            @collation ||= begin
+              collation = Decidim::DecidimAwesome.collation_for(locale)
+              "COLLATE \"#{collation}\"" if collation.present?
+            end
+          end
+
+          def my_votes_join
+            votes_table = Decidim::Proposals::ProposalVote.arel_table
+            proposals_table = Decidim::Proposals::Proposal.arel_table
+            Arel::Nodes::OuterJoin.new(
+              votes_table,
+              Arel::Nodes::On.new(
+                votes_table[:decidim_proposal_id].eq(proposals_table[:id])
+                  .and(votes_table[:decidim_author_id].eq(current_user.id))
+              )
+            )
+          end
+
+          def supported_order_available?
+            most_voted_order_available? && current_user
+          end
+
+          def awesome_additional_sortings
+            return [] unless DecidimAwesome.enabled?(:additional_proposal_sortings)
+            return [] if awesome_config[:additional_proposal_sortings].blank?
+            return [] unless awesome_config_instance.constrained_in_context?(:additional_proposal_sortings)
+
+            awesome_config[:additional_proposal_sortings].filter_map do |sort|
+              sort = sort.to_s
+              next unless sort.in? DecidimAwesome.possible_additional_proposal_sortings
+              next if sort.in?(%w(supported_first supported_last)) && !supported_order_available?
+
+              sort
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/decidim_awesome/proposals/proposal_votes_controller_override.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      module ProposalVotesControllerOverride
+        extend ActiveSupport::Concern
+        include Decidim::DecidimAwesome::AwesomeHelpers
+
+        included do
+          # rubocop:disable Rails/LexicallyScopedActionFilter
+          before_action :validate_weight, only: :create
+          # rubocop:enable Rails/LexicallyScopedActionFilter
+
+          def create
+            enforce_permission_to(:vote, :proposal, proposal:)
+            @from_proposals_list = params[:from_proposals_list] == "true"
+
+            Decidim::Proposals::VoteProposal.call(proposal, current_user) do
+              on(:ok) do
+                current_vote.weight = weight if current_vote && vote_manifest
+
+                proposal.reload
+
+                proposals = Decidim::Proposals::ProposalVote.where(
+                  author: current_user,
+                  proposal: Decidim::Proposals::Proposal.where(component: current_component)
+                ).map(&:proposal)
+
+                expose(proposals:)
+                render :update_buttons_and_counters
+              end
+
+              on(:invalid) do
+                render json: { error: I18n.t("proposal_votes.create.error", scope: "decidim.proposals") }, status: :unprocessable_entity
+              end
+            end
+          end
+
+          private
+
+          def validate_weight
+            return unless vote_manifest
+            return if vote_manifest.valid_weight? weight, user: current_user, proposal: proposal
+
+            render json: { error: I18n.t("proposal_votes.create.error", scope: "decidim.proposals") }, status: :unprocessable_entity
+          end
+
+          def current_vote
+            @current_vote ||= Decidim::Proposals::ProposalVote.find_by(author: current_user, proposal:)
+          end
+
+          def vote_manifest
+            @vote_manifest ||= awesome_voting_manifest_for(current_component)
+          end
+
+          def weight
+            params[:weight].to_i if params.has_key?(:weight)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/concerns/decidim/decidim_awesome/use_user_time_zone.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module UseUserTimeZone
+      extend ActiveSupport::Concern
+
+      included do
+        around_action :use_user_time_zone, if: -> { user_time_zone.present? }
+        helper_method :user_time_zone
+
+        # Executes a block of code in the context of the user's time zone
+        #
+        # &action - a block of code to be wrapped around the time zone
+        #
+        # Returns nothing.
+        def use_user_time_zone(&)
+          Time.use_zone(user_time_zone, &)
+        end
+
+        # The current time zone from the user. Available as a helper for the views.
+        #
+        # Returns a String.
+        def user_time_zone
+          return if helpers&.awesome_config&.[](:user_timezone).blank?
+
+          @user_time_zone ||= current_user&.extended_data&.[]("time_zone")
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/decidim_awesome/admin/admin_accountability_controller.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Admin
+      class AdminAccountabilityController < DecidimAwesome::Admin::ApplicationController
+        include NeedsAwesomeConfig
+        include AdminAccountability::Admin::Filterable
+
+        helper_method :admin_actions, :collection, :export_params, :global?, :global_users_missing_date
+
+        layout "decidim/admin/users"
+
+        before_action do
+          enforce_permission_to :edit_config, :admin_accountability, global: global?
+        end
+
+        def index; end
+
+        def export
+          filters = export_params[:q]
+
+          ExportAdminActionsJob.perform_later(current_user,
+                                              params[:format].to_s,
+                                              admin_actions.ransack(filters).result.ids)
+
+          redirect_back fallback_location: decidim_admin_decidim_awesome.admin_accountability_path,
+                        notice: t("decidim.decidim_awesome.admin.admin_accountability.exports.notice")
+        end
+
+        private
+
+        def admin_actions
+          @admin_actions ||= filtered_collection
+        end
+
+        def collection
+          @collection = global? ? paginate(admin_role_actions) : paginate(space_role_actions)
+        end
+
+        def space_role_actions
+          @space_role_actions ||= PaperTrailVersion.space_role_actions(current_organization)
+        end
+
+        def admin_role_actions
+          @admin_role_actions ||= PaperTrailVersion.in_organization(current_organization).admin_role_actions(PaperTrailVersion.safe_admin_role_type(params[:admin_role_type]))
+        end
+
+        def export_params
+          params.permit(:format, :admins, :admin_role_type, q: [:role_type_eq, :user_name_or_user_email_cont, :created_at_gteq, :created_at_lteq])
+        end
+
+        def global?
+          params[:admins] == "true"
+        end
+
+        # User traceability was introduced in version 0.24. Users created before that might appear in the list.
+        # Returns the first traceability record available if there are users created before.
+        # Returns nil otherwise
+        def global_users_missing_date
+          return unless global?
+
+          @global_users_missing_date ||= begin
+            first_version = PaperTrailVersion.where(item_type: "Decidim::UserBaseEntity").last
+            first_user = Decidim::User.first
+            first_version.created_at if first_user && first_version && (first_version.created_at > first_user.created_at + 1.second)
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/decidim_awesome/admin/admin_authorizations_controller.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Admin
+      class AdminAuthorizationsController < DecidimAwesome::Admin::ApplicationController
+        include NeedsAwesomeConfig
+
+        layout "layouts/decidim/decidim_awesome/admin/admin_authorizations"
+        helper_method :user, :authorization, :workflow, :handler, :conflict
+        # overwrite original rescue_from to ensure we print messages from ajax methods
+        rescue_from Decidim::ActionForbidden, with: :json_error
+
+        before_action do
+          enforce_permission_to :edit_config, :admins_available_authorizations, handler: workflow.name
+        end
+
+        def edit
+          render "authorization" if authorization
+        end
+
+        def update
+          if conflict
+            message = render_to_string("conflict")
+          else
+            message = render_to_string("callout", locals: { i18n_key: "user_authorized", klass: "success" })
+            Decidim::Verifications::AuthorizeUser.call(handler, current_organization) do
+              on(:transferred) do |transfer|
+                message += render_to_string("callout", locals: { i18n_key: "authorization_transferred", klass: "success" }) if transfer.records.any?
+              end
+              on(:invalid) do
+                if force_verification.present?
+                  create_forced_authorization
+                else
+                  message = render_to_string("callout", locals: { i18n_key: "user_not_authorized", klass: "alert" })
+                  message += render_to_string("edit", locals: { with_override: true })
+                end
+              end
+              on(:ok) do
+                Decidim::ActionLogger.log("admin_creates_authorization", current_user, user, nil, user_id: user.id, handler: workflow.name, handler_name: workflow.fullname)
+              end
+            end
+          end
+
+          render json: {
+            message:,
+            granted: granted?,
+            userId: user.id,
+            handler: workflow.name
+          }
+        end
+
+        def destroy
+          message = if destroy_authorization
+                      render_to_string("callout", locals: { i18n_key: "authorization_destroyed", klass: "success" })
+                    else
+                      render_to_string("callout", locals: { i18n_key: "authorization_not_destroyed", klass: "alert" })
+                    end
+
+          render json: {
+            message:,
+            granted: granted?,
+            userId: user.id,
+            handler: workflow.name
+          }
+        end
+
+        private
+
+        def create_forced_authorization
+          Decidim::Authorization.create_or_update_from(handler)
+          Decidim::ActionLogger.log("admin_forces_authorization", current_user, user, nil, handler: workflow.name, user_id: user.id, handler_name: workflow.fullname,
+                                                                                           reason: force_verification)
+        end
+
+        def destroy_authorization
+          if authorization&.destroy
+            Decidim::ActionLogger.log("admin_destroys_authorization", current_user, user, nil, user_id: user.id, handler: workflow.name, handler_name: workflow.fullname)
+          end
+        end
+
+        def json_error(exception)
+          render plain: render_to_string("callout", locals: { message: exception.message, klass: "alert" }), status: :unprocessable_entity
+        end
+
+        def user
+          @user ||= Decidim::User.find(params[:id])
+        end
+
+        def authorization
+          @authorization ||= Decidim::Authorization.where.not(granted_at: nil).find_by(user:, name: workflow.name)
+        end
+
+        def granted?
+          authorization&.reload.present?
+        rescue ActiveRecord::RecordNotFound
+          false
+        end
+
+        def workflow
+          @workflow ||= Decidim::Verifications.find_workflow_manifest(params[:handler])
+        end
+
+        def handler
+          @handler ||= Decidim::AuthorizationHandler.handler_for(params[:handler], handler_params)
+        end
+
+        def conflict
+          @conflict ||= Decidim::Authorization.find_by(unique_id: handler.unique_id)
+        end
+
+        def handler_params
+          (params[:authorization_handler] || {}).merge(user:)
+        end
+
+        def force_verification
+          @force_verification ||= params[:force_verification].to_s.strip.presence
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/decidim_awesome/admin/application_controller.rb

@@ -9,6 +9,8 @@ module Decidim
       # Note that it inherits from `Decidim::Admin::Components::BaseController`, which
       # override its layout and provide all kinds of useful methods.
       class ApplicationController < Decidim::Admin::ApplicationController
+        layout "decidim/decidim_awesome/admin/application"
+
         def permission_class_chain
           [::Decidim::DecidimAwesome::Admin::Permissions] + super
         end

data/app/controllers/decidim/decidim_awesome/admin/checks_controller.rb

@@ -8,50 +8,54 @@ module Decidim
       # System compatibility analyzer
       class ChecksController < DecidimAwesome::Admin::ApplicationController
         include NeedsAwesomeConfig
+        include MaintenanceContext
+
         helper ConfigConstraintsHelpers
         helper SystemCheckerHelpers
 
-        layout "decidim/admin/decidim_awesome"
-
         helper_method :head, :admin_head, :head_addons, :admin_addons
 
-        def migrate_images
-          Decidim::DecidimAwesome::MigrateLegacyImagesJob.perform_later(current_organization.id)
-          flash[:notice] = I18n.t("image_migrations_started", scope: "decidim.decidim_awesome.admin.checks.index")
-          redirect_to checks_path
-        end
-
         private
 
         def head
-          @head ||= Nokogiri::HTML(render_to_string(partial: "layouts/decidim/head"))
+          @head ||= Nokogiri::HTML(render_template("decidim/decidim_awesome/admin/checks/assets_tester"))
         end
 
         def admin_head
-          @admin_head = Nokogiri::HTML(render_to_string(partial: "layouts/decidim/admin/header"))
+          @admin_head = Nokogiri::HTML(render_template("layouts/decidim/admin/header"))
         end
 
         def head_addons(part)
           case part
           when :CSS
-            ['<%= stylesheet_pack_tag "decidim_decidim_awesome", media: "all" %>',
-             '<%= render(partial: "layouts/decidim/decidim_awesome/custom_styles") if awesome_custom_styles %>'].join("\n")
+            ['<%= append_stylesheet_pack_tag "decidim_decidim_awesome", media: "all" %>',
+             '<%= render(partial: "layouts/decidim/decidim_awesome/custom_styles") if awesome_scoped_styles %>'].join("\n")
           when :JavaScript
             ['<%= render partial: "layouts/decidim/decidim_awesome/awesome_config" %>',
-             '<%= javascript_pack_tag "decidim_decidim_awesome" %>',
-             '<%= javascript_pack_tag "decidim_decidim_awesome_custom_fields" if awesome_proposal_custom_fields %>'].join("\n")
+             '<%= append_javascript_pack_tag "decidim_decidim_awesome", defer: false %>',
+             '<%= append_javascript_pack_tag "decidim_decidim_awesome_custom_fields" if awesome_proposal_custom_fields %>'].join("\n")
           end
         end
 
         def admin_addons(part)
           case part
           when :CSS
-            '<%= stylesheet_pack_tag "decidim_admin_decidim_awesome", media: "all" %>'
+            '<%= append_stylesheet_pack_tag "decidim_admin_decidim_awesome", media: "all" %>'
           when :JavaScript
-            ['<%= javascript_pack_tag "decidim_admin_decidim_awesome", defer: false %>',
-             '<%= javascript_pack_tag "decidim_decidim_awesome_custom_fields" if awesome_proposal_custom_fields %>'].join("\n")
+            ['<%= append_javascript_pack_tag "decidim_admin_decidim_awesome", defer: false %>',
+             '<%= append_javascript_pack_tag "decidim_decidim_awesome_custom_fields" if awesome_proposal_custom_fields %>'].join("\n")
           end
         end
+
+        def render_template(partial)
+          render_to_string(partial:)
+        rescue ActionView::Template::Error => e
+          flash.now[:alert] = "Partial [#{partial}] has thrown an error: #{e.message}"
+        end
+
+        def current_view
+          "checks"
+        end
       end
     end
   end

data/app/controllers/decidim/decidim_awesome/admin/config_controller.rb

@@ -9,9 +9,7 @@ module Decidim
         include ConfigConstraintsHelpers
         helper ConfigConstraintsHelpers
 
-        layout "decidim/admin/decidim_awesome"
-
-        helper_method :constraints_for, :users_for, :config_var
+        helper_method :constraints_for, :users_for, :config_var, :available_authorizations
         before_action do
           enforce_permission_to :edit_config, configs
         end
@@ -19,7 +17,7 @@ module Decidim
         def show
           @form = form(ConfigForm).from_params(organization_awesome_config)
 
-          redirect_to decidim_admin_decidim_awesome.checks_path unless config_var
+          redirect_to decidim_admin_decidim_awesome.checks_maintenance_index_path unless config_var
         end
 
         def update
@@ -43,8 +41,13 @@ module Decidim
               if (term = params[:term].to_s).present?
                 query = current_organization.users.order(name: :asc)
                 query = query.where("name ILIKE :term OR nickname ILIKE :term OR email ILIKE :term", term: "%#{term}%")
-
-                render json: query.all.collect { |u| { id: u.id, text: format_user_name(u) } }
+                render json: query.all.collect { |u|
+                               {
+                                 value: u.id,
+                                 text: format_user_name(u),
+                                 is_admin: u.read_attribute("admin")
+                               }
+                             }
               else
                 render json: []
               end
@@ -89,11 +92,17 @@ module Decidim
         end
 
         def users_for(ids_list)
-          Decidim::User.where(id: ids_list).map { |user| OpenStruct.new(text: format_user_name(user), id: user.id) }
+          Decidim::User.where(id: ids_list).map { |user| [format_user_name(user), user.id, { data: { is_admin: user.read_attribute("admin") } }] }
         end
 
         def format_user_name(user)
-          "<span class='#{"is-admin" if user.read_attribute("admin")}'>#{user.name} (@#{user.nickname} - #{user.email})</span>"
+          "#{user.name} (@#{user.nickname} - #{user.email})"
+        end
+
+        def available_authorizations
+          @available_authorizations ||= Decidim::Verifications::Adapter.from_collection(
+            current_organization.available_authorizations & Decidim.authorization_workflows.map(&:name)
+          )
         end
       end
     end

data/app/controllers/decidim/decidim_awesome/admin/constraints_controller.rb

@@ -6,21 +6,24 @@ module Decidim
       # Constraints configuration controller for config keys
       class ConstraintsController < DecidimAwesome::Admin::ApplicationController
         include NeedsAwesomeConfig
+        include Decidim::Headers::HttpCachingDisabler
         helper ConfigConstraintsHelpers
 
         layout false
-        before_action do
-          enforce_permission_to :edit_config, constraint_key
-        end
+        helper_method :constraint_key
 
-        def new
-          @form = form(ConstraintForm).from_params(filtered_params, setting: current_setting)
+        before_action do
+          render :no_permissions unless allowed_to? :edit_config, constraint_key
         end
 
         def show
           @form = form(ConstraintForm).from_params(constraint.settings.merge(filtered_params))
         end
 
+        def new
+          @form = form(ConstraintForm).from_params(filtered_params, setting: current_setting)
+        end
+
         def create
           @form = form(ConstraintForm).from_params(params, setting: current_setting)
           CreateConstraint.call(@form) do
@@ -39,11 +42,11 @@ module Decidim
 
             on(:invalid) do |message|
               render json: {
-                id: params[:id],
-                key: current_setting.var,
-                message: I18n.t("decidim_awesome.admin.constraints.create.error", scope: "decidim"),
-                error: message
-              },
+                       id: params[:id],
+                       key: current_setting.var,
+                       message: I18n.t("decidim_awesome.admin.constraints.create.error", scope: "decidim"),
+                       error: message
+                     },
                      status: :unprocessable_entity
             end
           end
@@ -67,11 +70,11 @@ module Decidim
 
             on(:invalid) do |message|
               render json: {
-                id: params[:id],
-                key: constraint.awesome_config.var,
-                message: I18n.t("decidim_awesome.admin.constraints.update.error", scope: "decidim"),
-                error: message
-              },
+                       id: params[:id],
+                       key: constraint.awesome_config.var,
+                       message: I18n.t("decidim_awesome.admin.constraints.update.error", scope: "decidim"),
+                       error: message
+                     },
                      status: :unprocessable_entity
             end
           end
@@ -94,11 +97,11 @@ module Decidim
 
             on(:invalid) do |message|
               render json: {
-                id: params[:id],
-                key: constraint.awesome_config.var,
-                message: I18n.t("decidim_awesome.admin.constraints.destroy.error", scope: "decidim"),
-                error: message
-              },
+                       id: params[:id],
+                       key: constraint.awesome_config.var,
+                       message: I18n.t("decidim_awesome.admin.constraints.destroy.error", scope: "decidim"),
+                       error: message
+                     },
                      status: :unprocessable_entity
             end
           end
@@ -127,10 +130,14 @@ module Decidim
           case key
           when /^scoped_style_/
             :scoped_styles
+          when /^scoped_admin_style_/
+            :scoped_admin_styles
           when /^scoped_admin_/
             :scoped_admins
           when /^proposal_custom_field_/
             :proposal_custom_fields
+          when /^proposal_private_custom_field_/
+            :proposal_private_custom_fields
           else
             key
           end