decidim-decidim_awesome 0.8.0 → 0.12.0

data/app/presenters/concerns/decidim/decidim_awesome/proposals/proposal_presenter_override.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      ##
+      # Override Proposal Presenter to access private field.
+      module ProposalPresenterOverride
+        extend ActiveSupport::Concern
+        included do
+          def private_body(*)
+            return unless proposal
+
+            proposal.private_body
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/decidim_awesome/admin_log/component_presenter_override.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module AdminLog
+      module ComponentPresenterOverride
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method :decidim_original_action_string, :action_string
+          alias_method :decidim_original_i18n_params, :i18n_params
+
+          def action_string
+            return "decidim.decidim_awesome.admin_log.component.#{action}" if action == "destroy_private_data"
+
+            decidim_original_action_string
+          end
+
+          def i18n_params
+            return decidim_original_i18n_params unless action == "destroy_private_data"
+
+            decidim_original_i18n_params.merge({ count: action_log.extra["count"] })
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/decidim_awesome/admin_log/user_presenter_override.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module AdminLog
+      module UserPresenterOverride
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method :decidim_original_action_string, :action_string
+          alias_method :decidim_original_i18n_params, :i18n_params
+          alias_method :decidim_original_resource_presenter, :resource_presenter
+
+          def action_string
+            return "decidim.decidim_awesome.admin_log.user.#{action}" if authorization_action?
+
+            decidim_original_action_string
+          end
+
+          def i18n_params
+            return decidim_original_i18n_params unless authorization_action?
+
+            decidim_original_i18n_params.merge({
+                                                 handler_name: h.content_tag(:span, action_log.extra["handler_name"], class: "logs__log__resource"),
+                                                 reason: h.content_tag(:em, action_log.extra["reason"])
+                                               })
+          end
+
+          def resource_presenter
+            return decidim_original_resource_presenter unless authorization_action? && authorization_user
+
+            @resource_presenter ||= Decidim::Log::UserPresenter.new(authorization_user, h, { "name" => authorization_user.name, "nickname" => authorization_user.nickname })
+          end
+
+          def authorization_user
+            @authorization_user ||= Decidim::User.find_by(id: action_log.extra["user_id"])
+          end
+
+          def authorization_action?
+            action.in?(%w(admin_creates_authorization admin_forces_authorization admin_destroys_authorization))
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/decidim_awesome/paper_trail_base_presenter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    class PaperTrailBasePresenter
+      attr_reader :entry, :html
+
+      def initialize(entry, html: true)
+        @entry = entry
+        @html = html
+      end
+
+      # try to use the object in the database if exists
+      # Note that "reify" does not work on "create" events
+      def item
+        @item ||= entry&.item
+      end
+
+      def item_type
+        @item_type ||= entry&.item_type
+      end
+
+      def item_id
+        @item_id ||= entry&.item_id
+      end
+    end
+  end
+end

data/app/presenters/decidim/decidim_awesome/participatory_space_role_presenter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    class ParticipatorySpaceRolePresenter < RoleBasePresenter
+      # Finds the destroyed entry if exists
+      def destroy_entry
+        @destroy_entry ||= PaperTrail::Version.find_by(item_type:, event: "destroy", item_id:)
+      end
+
+      # roles are in the destroyed event if the role has been removed
+      def role
+        @role ||= destroy_item&.role || item&.role
+      end
+
+      def role_name
+        type = I18n.t(role, scope: "decidim.decidim_awesome.admin.admin_accountability.roles", default: role)
+        return type unless html && role_class
+
+        "<span class=\"#{role_class}\">#{type}</span>".html_safe
+      end
+
+      def user
+        @user ||= Decidim::User.find_by(id: entry.changeset["decidim_user_id"]&.last)
+      end
+
+      # participatory spaces is in the normal entry if the role hasn't been removed
+      # otherwise is in the removed role log entry
+      def participatory_space
+        item&.participatory_space || destroy_item&.participatory_space
+      end
+
+      private
+
+      def role_class
+        case role
+        when "admin"
+          "text-alert"
+        when "valuator"
+          "text-secondary"
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/decidim_awesome/private_data_presenter.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    class PrivateDataPresenter < SimpleDelegator
+      include Decidim::TranslatableAttributes
+      include ActionView::Helpers::DateHelper
+      include ActionView::Helpers::TagHelper
+
+      def name
+        @name ||= "#{translated_attribute(participatory_space.title)} / #{translated_attribute(super)}"
+      end
+
+      def path
+        @path ||= Decidim::EngineRouter.main_proxy(self).root_path
+      end
+
+      def total
+        @total ||= Decidim::Proposals::Proposal.joins(:extra_fields)
+                                               .where(component: self)
+                                               .where.not(extra_fields: { private_body: nil })
+                                               .count.to_s
+      end
+
+      def last_date
+        @last_date ||= Decidim::Proposals::Proposal.joins(:extra_fields)
+                                                   .where(component: self)
+                                                   .where.not(extra_fields: { private_body: nil })
+                                                   .order(private_body_updated_at: :desc)
+                                                   .first&.extra_fields&.private_body_updated_at
+      end
+
+      def time_ago
+        I18n.t("decidim.decidim_awesome.admin.maintenance.private_data.time_ago", time: time_ago_in_words(last_date)) if last_date
+      end
+
+      def destroyable?
+        return false unless last_date
+
+        last_date < DecidimAwesome.private_data_expiration_time.ago
+      end
+
+      def locked?
+        Decidim::DecidimAwesome::Lock.new(organization).locked?(__getobj__)
+      end
+
+      def as_json(_options = nil)
+        {
+          id:,
+          name:,
+          path:,
+          total:,
+          last_date:,
+          time_ago:,
+          locked: locked?,
+          done:
+        }
+      end
+
+      def done
+        return content_tag("span", "", class: "loading-spinner primary") if locked?
+
+        return if destroyable?
+        return if last_date
+
+        I18n.t("decidim.decidim_awesome.admin.maintenance.private_data.done")
+      end
+    end
+  end
+end

data/app/presenters/decidim/decidim_awesome/role_base_presenter.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    class RoleBasePresenter < PaperTrailBasePresenter
+      include TranslatableAttributes
+
+      # Finds the destroyed entry if exists
+      def destroy_entry
+        nil
+      end
+
+      alias destroyed? destroy_entry
+
+      # try to reconstruct a destroyed event
+      def destroy_item
+        @destroy_item ||= destroy_entry&.reify
+      end
+
+      def user
+        raise "Please implement this method to return the user object"
+      end
+
+      def role_name
+        raise "Please implement this method to return the role text"
+      end
+
+      def participatory_space
+        nil
+      end
+
+      def participatory_space_name
+        participatory_space_type.present? ? "#{participatory_space_type} > #{translated_attribute participatory_space&.title}" : ""
+      end
+
+      def participatory_space_type
+        I18n.t(participatory_space&.manifest&.name, scope: "decidim.admin.menu") if participatory_space.present?
+      end
+
+      # try to link to the user roles page or to the participatory space if not existing
+      def participatory_space_path
+        proxy.send("#{participatory_space.manifest.route_name}_user_roles_path")
+      rescue NoMethodError
+        begin
+          proxy.send("#{participatory_space.manifest.route_name}_path", participatory_space)
+        rescue NoMethodError
+          ""
+        end
+      end
+
+      def user_name
+        return I18n.t("missing_user", scope: "decidim.decidim_awesome.admin.admin_accountability") unless user
+        return I18n.t("deleted_user", scope: "decidim.decidim_awesome.admin.admin_accountability") if user.deleted?
+
+        user&.name
+      end
+
+      def user_email
+        user&.email || entry.changeset["email"]&.last
+      end
+
+      def created_at
+        entry.changeset["created_at"]&.last || entry&.created_at
+      end
+
+      def created_date
+        I18n.l(created_at, format: :short)
+      rescue I18n::ArgumentError
+        ""
+      end
+
+      def destroyed_at
+        destroy_entry&.created_at
+      end
+
+      def removal_date
+        I18n.l(destroyed_at, format: :short)
+      rescue I18n::ArgumentError
+        info_text("currently_active", klass: "text-success")
+      end
+
+      def last_sign_in_date
+        I18n.l(user&.last_sign_in_at, format: :short)
+      rescue I18n::ArgumentError
+        info_text("never_logged")
+      end
+
+      protected
+
+      def info_text(key, klass: :muted)
+        text = I18n.t(key, scope: "decidim.decidim_awesome.admin.admin_accountability")
+        return text unless html
+
+        "<span class=\"#{klass}\">#{text}</span>".html_safe
+      end
+
+      def proxy
+        @proxy ||= Decidim::EngineRouter.admin_proxy(participatory_space)
+      end
+    end
+  end
+end

data/app/presenters/decidim/decidim_awesome/user_entity_presenter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    class UserEntityPresenter < RoleBasePresenter
+      # Finds the destroyed entry if exists
+      def destroy_entry
+        @destroy_entry ||= begin
+          query = PaperTrail::Version.where(item_type:, event: "update", item_id:)
+                                     .where("id > ?", entry.id)
+          if roles.include? "admin"
+            query.where("object_changes LIKE '%\nadmin:\n- true\n- false%'").first
+          else
+            query.where("object_changes LIKE '%\nroles:\n- - %'").first
+          end
+        end
+      end
+
+      def roles
+        @roles ||= begin
+          rls = entry.changeset["roles"]&.last || []
+          rls << "admin" if entry.changeset["admin"]&.last
+          rls
+        end
+      end
+
+      def role_name
+        types = roles.index_with { |role| I18n.t(role, scope: "decidim.decidim_awesome.admin.admin_accountability.admin_roles", default: role) }
+        return types.values.join(", ") unless html
+
+        types.map { |role, type| "<span class=\"#{role_class(role)}\">#{type}</span>" }.join(" ").html_safe
+      end
+
+      def user
+        @user ||= entry&.item || Decidim::User.find_by(id: entry.changeset["id"]&.last)
+      end
+
+      private
+
+      def role_class(role)
+        case role
+        when "admin"
+          "text-alert"
+        when "user_manager"
+          "text-secondary"
+        end
+      end
+    end
+  end
+end

data/app/queries/decidim/decidim_awesome/private_data_finder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    class PrivateDataFinder
+      def query
+        Component.where(id: proposals.where.not(extra_fields: { private_body: nil }))
+      end
+
+      def proposals
+        Decidim::Proposals::Proposal.select(:decidim_component_id).joins(:extra_fields)
+      end
+
+      def for(resources)
+        Component.where(id: proposals).where(id: resources)
+      end
+    end
+  end
+end

data/app/serializers/concerns/decidim/decidim_awesome/proposals/proposal_serializer_methods.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      # Adds one custom field per column in export if custom fields are activted
+      # Adds vote weights
+      module ProposalSerializerMethods
+        extend ActiveSupport::Concern
+
+        included do
+          include ::Decidim::DecidimAwesome::NeedsAwesomeConfig
+
+          # Override the NeedsAwesomeConfig's awesome_config_instance,
+          # to take context from proposal instead of controller's request.
+          def awesome_config_instance
+            return @custom_config if @custom_config
+
+            @custom_config = Config.new(proposal.organization)
+            @custom_config.context_from_component(proposal.component)
+            @custom_config
+          end
+
+          def serialize_custom_fields
+            payload = {}
+            custom_fields = CustomFields.new(awesome_proposal_custom_fields)
+            if custom_fields.present?
+              @proposal.body.each do |locale, body|
+                if body.is_a?(Hash)
+                  body.each do |translation_locale, value|
+                    fields_entries(custom_fields, value) do |field_key, field_value|
+                      payload["body/#{field_key}/#{translation_locale}".to_sym] = field_value if payload["body/#{field_key}/#{translation_locale}".to_sym].blank?
+                    end
+                  end
+                else
+                  fields_entries(custom_fields, body) do |key, value|
+                    payload["body/#{key}/#{locale}".to_sym] = value
+                  end
+                end
+              end
+            end
+            payload
+          end
+
+          def serialize_private_custom_fields
+            payload = {}
+            private_custom_fields = CustomFields.new(awesome_proposal_private_custom_fields)
+            if private_custom_fields.present?
+              fields_entries(private_custom_fields, proposal.private_body) do |key, value|
+                value = value.first if value.is_a? Array
+                payload["private_body/#{key}".to_sym] = value
+              end
+            end
+            payload
+          end
+
+          # Iterate on custom fields that has a label and name
+          # (will ignore paragraphs and title)
+          def fields_entries(custom_fields, body)
+            custom_fields.apply_xml(body)
+            custom_fields.fields.each do |field|
+              next unless field["label"].present? && field.has_key?("name")
+
+              value = field["userData"].is_a?(Array) ? field["userData"].first : field["userData"]
+              yield field["label"].parameterize, value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/concerns/decidim/decidim_awesome/proposals/proposal_serializer_override.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      # Adds one custom field per column in export if custom fields are activted
+      # Adds vote weights
+      module ProposalSerializerOverride
+        extend ActiveSupport::Concern
+
+        included do
+          include ProposalSerializerMethods
+
+          alias_method :decidim_original_serialize, :serialize
+
+          def serialize
+            # serialize first the custom fields,
+            # as default serialization will strip proposal body's <xml> tags.
+            serialization = decidim_original_serialize
+            serialization.merge!(proposal_vote_weights)
+            serialization.merge!(serialize_custom_fields)
+          end
+
+          protected
+
+          def proposal_vote_weights
+            payload = {}
+            if proposal.respond_to?(:vote_weights)
+              proposal.update_vote_weights!
+              payload[:votes] = proposal.reload.vote_weights
+            end
+            payload
+          end
+        end
+      end
+    end
+  end
+end

data/app/serializers/decidim/decidim_awesome/paper_trail_version_serializer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    # This class serializes a AdminAccountability so can be exported to CSV, JSON or other
+    # formats.
+    class PaperTrailVersionSerializer < Decidim::Exporters::Serializer
+      include Decidim::ApplicationHelper
+      include Decidim::ResourceHelper
+      include Decidim::TranslationsHelper
+
+      # Public: Initializes the serializer with a admin actions.
+      def initialize(log_entry)
+        @entry = log_entry.present(html: false)
+      end
+
+      # Public: Exports a hash with the serialized data for this admin action.
+      def serialize
+        {
+          role: entry.role_name,
+          user_name: entry.user_name,
+          user_email: entry.user_email,
+          user_role_type: entry.entry.item_type,
+          participatory_space_type: entry.participatory_space_type,
+          participatory_space_title: translated_attribute(entry.participatory_space&.title),
+          last_sign_in_at: entry.last_sign_in_date,
+          role_created_at: entry.created_date,
+          role_removed_at: entry.removal_date
+        }
+      end
+
+      private
+
+      attr_reader :entry
+    end
+  end
+end

data/app/serializers/decidim/decidim_awesome/proposals/private_proposal_serializer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      ##
+      # Custom serializer for Proposals with private data.
+      # Used to separate open-data export and admin export.
+      class PrivateProposalSerializer < ::Decidim::Proposals::ProposalSerializer
+        include ProposalSerializerMethods
+
+        def serialize
+          serialization = super.merge!(serialize_private_custom_fields)
+          serialization.merge!(serialize_private_notes)
+        end
+
+        def serialize_private_notes
+          payload = {}
+          notes = proposal.notes
+          return payload unless notes.any?
+
+          notes.each do |note|
+            payload["notes/#{note.id}".to_sym] = {
+              created_at: note.created_at,
+              note: note.body,
+              author: author_name(note.author)
+            }
+          end
+          payload
+        end
+      end
+    end
+  end
+end

data/app/types/concerns/decidim/decidim_awesome/add_proposal_type_custom_fields.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module AddProposalTypeCustomFields
+      extend ActiveSupport::Concern
+
+      included do
+        include ::Decidim::DecidimAwesome::NeedsAwesomeConfig
+
+        field :body_fields, TranslatedCustomFieldsType, "Custom fields for this proposal", null: true
+
+        def body_fields
+          return if custom_fields.empty?
+
+          @body_fields ||= object.body.transform_values do |body|
+            sanitize_translated_fields(body)
+          end
+        end
+
+        # Override the NeedsAwesomeConfig's awesome_config_instance,
+        # to take context from proposal instead of controller's request.
+        def awesome_config_instance
+          return @custom_config if @custom_config
+
+          @custom_config = Config.new(object.organization)
+          @custom_config.context_from_component(object.component)
+          @custom_config
+        end
+
+        private
+
+        def custom_fields
+          @custom_fields ||= CustomFields.new(awesome_proposal_custom_fields)
+        end
+
+        def fields_for_xml(body)
+          custom_fields.apply_xml(body)
+          custom_fields.fields.filter_map do |field|
+            next unless field["label"].present? && field.has_key?("name")
+
+            field["userData"] = field["userData"].first if field["userData"].is_a?(Array)
+            field.dup
+          end
+        end
+
+        def sanitize_translated_fields(body)
+          if body.is_a?(Hash)
+            body.transform_values do |value|
+              fields_for_xml(value)
+            end
+          else
+            fields_for_xml(body)
+          end
+        end
+      end
+    end
+  end
+end

data/app/types/concerns/decidim/decidim_awesome/add_proposal_type_vote_weights.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module AddProposalTypeVoteWeights
+      extend ActiveSupport::Concern
+
+      included do
+        field :vote_weights, GraphQL::Types::JSON, description: "The corresponding weights count to the proposal votes", null: true
+
+        def vote_weights
+          current_component = object.component
+          return unless current_component.current_settings.respond_to?(:votes_hidden?)
+
+          object.vote_weights unless current_component.current_settings.votes_hidden?
+        end
+      end
+    end
+  end
+end