decidim-enhanced_textwork 1.0.0

data/app/permissions/decidim/enhanced_textwork/permissions.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class Permissions < Decidim::DefaultPermissions
+      def permissions
+        return permission_action unless user
+
+        # Delegate the admin permission checks to the admin permissions class
+        return Decidim::EnhancedTextwork::Admin::Permissions.new(user, permission_action, context).permissions if permission_action.scope == :admin
+        return permission_action if permission_action.scope != :public
+
+        case permission_action.subject
+        when :paragraph
+          apply_paragraph_permissions(permission_action)
+        when :collaborative_draft
+          apply_collaborative_draft_permissions(permission_action)
+        else
+          permission_action
+        end
+
+        permission_action
+      end
+
+      private
+
+      def apply_paragraph_permissions(permission_action)
+        case permission_action.action
+        when :create
+          can_create_paragraph?
+        when :edit
+          can_edit_paragraph?
+        when :withdraw
+          can_withdraw_paragraph?
+        when :amend
+          can_create_amendment?
+        when :vote
+          can_vote_paragraph?
+        when :unvote
+          can_unvote_paragraph?
+        when :report
+          true
+        end
+      end
+
+      def paragraph
+        @paragraph ||= context.fetch(:paragraph, nil) || context.fetch(:resource, nil)
+      end
+
+      def voting_enabled?
+        return unless current_settings
+
+        current_settings.votes_enabled? && !current_settings.votes_blocked?
+      end
+
+      def vote_limit_enabled?
+        return unless component_settings
+
+        component_settings.vote_limit.present? && component_settings.vote_limit.positive?
+      end
+
+      def remaining_votes
+        return 1 unless vote_limit_enabled?
+
+        paragraphs = Paragraph.where(component: component)
+        votes_count = ParagraphVote.where(author: user, paragraph: paragraphs).size
+        component_settings.vote_limit - votes_count
+      end
+
+      def can_create_paragraph?
+        toggle_allow(authorized?(:create) && current_settings&.creation_enabled?)
+      end
+
+      def can_edit_paragraph?
+        toggle_allow(paragraph && paragraph.editable_by?(user))
+      end
+
+      def can_withdraw_paragraph?
+        toggle_allow(paragraph && paragraph.authored_by?(user))
+      end
+
+      def can_create_amendment?
+        is_allowed = paragraph &&
+                     authorized?(:amend, resource: paragraph) &&
+                     current_settings&.amendments_enabled?
+
+        toggle_allow(is_allowed)
+      end
+
+      def can_vote_paragraph?
+        is_allowed = paragraph &&
+                     authorized?(:vote, resource: paragraph) &&
+                     voting_enabled? &&
+                     remaining_votes.positive?
+
+        toggle_allow(is_allowed)
+      end
+
+      def can_unvote_paragraph?
+        is_allowed = paragraph &&
+                     authorized?(:vote, resource: paragraph) &&
+                     voting_enabled?
+
+        toggle_allow(is_allowed)
+      end
+
+      def apply_collaborative_draft_permissions(permission_action)
+        case permission_action.action
+        when :create
+          can_create_collaborative_draft?
+        when :edit
+          can_edit_collaborative_draft?
+        when :publish
+          can_publish_collaborative_draft?
+        when :request_access
+          can_request_access_collaborative_draft?
+        when :react_to_request_access
+          can_react_to_request_access_collaborative_draft?
+        end
+      end
+
+      def collaborative_draft
+        @collaborative_draft ||= context.fetch(:collaborative_draft, nil)
+      end
+
+      def collaborative_drafts_enabled?
+        component_settings.collaborative_drafts_enabled
+      end
+
+      def can_create_collaborative_draft?
+        return toggle_allow(false) unless collaborative_drafts_enabled?
+
+        toggle_allow(current_settings&.creation_enabled? && authorized?(:create))
+      end
+
+      def can_edit_collaborative_draft?
+        return toggle_allow(false) unless collaborative_drafts_enabled? && collaborative_draft.open?
+
+        toggle_allow(collaborative_draft.editable_by?(user))
+      end
+
+      def can_publish_collaborative_draft?
+        return toggle_allow(false) unless collaborative_drafts_enabled? && collaborative_draft.open?
+
+        toggle_allow(collaborative_draft.created_by?(user))
+      end
+
+      def can_request_access_collaborative_draft?
+        return toggle_allow(false) unless collaborative_drafts_enabled? && collaborative_draft.open?
+        return toggle_allow(false) if collaborative_draft.requesters.include?(user)
+
+        toggle_allow(!collaborative_draft.editable_by?(user))
+      end
+
+      def can_react_to_request_access_collaborative_draft?
+        return toggle_allow(false) unless collaborative_drafts_enabled? && collaborative_draft.open?
+        return toggle_allow(false) if collaborative_draft.requesters.include? user
+
+        toggle_allow(collaborative_draft.created_by?(user))
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/admin_log/paragraph_note_presenter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module AdminLog
+      # This class holds the logic to present a `Decidim::EnhancedTextwork::ParagraphNote`
+      # for the `AdminLog` log.
+      #
+      # Usage should be automatic and you shouldn't need to call this class
+      # directly, but here's an example:
+      #
+      #    action_log = Decidim::ActionLog.last
+      #    view_helpers # => this comes from the views
+      #    ParagraphNotePresenter.new(action_log, view_helpers).present
+      class ParagraphNotePresenter < Decidim::Log::BasePresenter
+        private
+
+        def diff_fields_mapping
+          {
+            body: :string
+          }
+        end
+
+        def action_string
+          case action
+          when "create"
+            "decidim.enhanced_textwork.admin_log.paragraph_note.#{action}"
+          else
+            super
+          end
+        end
+
+        def i18n_labels_scope
+          "activemodel.attributes.paragraph_note"
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/admin_log/paragraph_presenter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module AdminLog
+      # This class holds the logic to present a `Decidim::EnhancedTextwork::Paragraph`
+      # for the `AdminLog` log.
+      #
+      # Usage should be automatic and you shouldn't need to call this class
+      # directly, but here's an example:
+      #
+      #    action_log = Decidim::ActionLog.last
+      #    view_helpers # => this comes from the views
+      #    ParagraphPresenter.new(action_log, view_helpers).present
+      class ParagraphPresenter < Decidim::Log::BasePresenter
+        private
+
+        def resource_presenter
+          @resource_presenter ||= Decidim::EnhancedTextwork::Log::ResourcePresenter.new(action_log.resource, h, action_log.extra["resource"])
+        end
+
+        def diff_fields_mapping
+          {
+            title: "Decidim::EnhancedTextwork::AdminLog::ValueTypes::ParagraphTitleBodyPresenter",
+            body: "Decidim::EnhancedTextwork::AdminLog::ValueTypes::ParagraphTitleBodyPresenter",
+            state: "Decidim::EnhancedTextwork::AdminLog::ValueTypes::ParagraphStatePresenter",
+            answered_at: :date,
+            answer: :i18n
+          }
+        end
+
+        def action_string
+          case action
+          when "answer", "create", "update", "publish_answer"
+            "decidim.enhanced_textwork.admin_log.paragraph.#{action}"
+          else
+            super
+          end
+        end
+
+        def i18n_labels_scope
+          "activemodel.attributes.paragraph"
+        end
+
+        def diff_actions
+          super + %w(answer)
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/admin_log/valuation_assignment_presenter.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module AdminLog
+      # This class holds the logic to present a `Decidim::EnhancedTextwork::ValuationAssignment`
+      # for the `AdminLog` log.
+      #
+      # Usage should be automatic and you shouldn't need to call this class
+      # directly, but here's an example:
+      #
+      #    action_log = Decidim::ActionLog.last
+      #    view_helpers # => this comes from the views
+      #    ValuationAssignmentPresenter.new(action_log, view_helpers).present
+      class ValuationAssignmentPresenter < Decidim::Log::BasePresenter
+        private
+
+        def resource_presenter
+          @resource_presenter ||= Decidim::EnhancedTextwork::Log::ValuationAssignmentPresenter.new(action_log.resource, h, action_log.extra["resource"])
+        end
+
+        def diff_fields_mapping
+          {
+            valuator_role_id: "Decidim::EnhancedTextwork::AdminLog::ValueTypes::ValuatorRoleUserPresenter"
+          }
+        end
+
+        def action_string
+          case action
+          when "create", "delete"
+            "decidim.enhanced_textwork.admin_log.valuation_assignment.#{action}"
+          else
+            super
+          end
+        end
+
+        def i18n_labels_scope
+          "activemodel.attributes.valuation_assignment.admin_log"
+        end
+
+        def diff_actions
+          super + %w(create delete)
+        end
+
+        def i18n_params
+          super.merge(paragraph_title: h.translated_attribute(action_log.extra["paragraph_title"]))
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/admin_log/value_types/paragraph_state_presenter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module AdminLog
+      module ValueTypes
+        class ParagraphStatePresenter < Decidim::Log::ValueTypes::DefaultPresenter
+          def present
+            return unless value
+
+            h.t(value, scope: "decidim.enhanced_textwork.admin.paragraph_answers.edit", default: value)
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/admin_log/value_types/paragraph_title_body_presenter.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module AdminLog
+      module ValueTypes
+        class ParagraphTitleBodyPresenter < Decidim::Log::ValueTypes::DefaultPresenter
+          include Decidim::TranslatableAttributes
+
+          def present
+            return unless value
+
+            translated_value = translated_attribute(value)
+            return if translated_value.blank?
+
+            renderer = Decidim::ContentRenderers::HashtagRenderer.new(translated_value)
+            renderer.render(links: false).html_safe
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/admin_log/value_types/valuator_role_user_presenter.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module AdminLog
+      module ValueTypes
+        class ValuatorRoleUserPresenter < Decidim::Log::ValueTypes::DefaultPresenter
+          def present
+            return unless value
+
+            role = Decidim::EnhancedTextwork::ValuationAssignment.find_by(valuator_role_id: value).valuator_role
+            user = role.user
+            user.try(:name)
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/collaborative_draft_presenter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    #
+    # Decorator for collaborative drafts
+    #
+    class CollaborativeDraftPresenter < ParagraphPresenter
+      def author
+        coauthorship = __getobj__.coauthorships.first
+        @author ||= if coauthorship.user_group
+                      Decidim::UserGroupPresenter.new(coauthorship.user_group)
+                    else
+                      Decidim::UserPresenter.new(coauthorship.author)
+                    end
+      end
+
+      alias collaborative_draft paragraph
+
+      def collaborative_draft_path
+        Decidim::ResourceLocatorPresenter.new(collaborative_draft).path
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/log/resource_presenter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Log
+      class ResourcePresenter < Decidim::Log::ResourcePresenter
+        private
+
+        # Private: Presents resource name.
+        #
+        # Returns an HTML-safe String.
+        def present_resource_name
+          if resource.present?
+            Decidim::EnhancedTextwork::ParagraphPresenter.new(resource).title
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/log/valuation_assignment_presenter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Log
+      class ValuationAssignmentPresenter < Decidim::Log::ResourcePresenter
+        private
+
+        # Private: Presents resource name.
+        #
+        # Returns an HTML-safe String.
+        def present_resource_name
+          if resource.present?
+            Decidim::EnhancedTextwork::ParagraphPresenter.new(resource.paragraph).title
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/official_author_presenter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    #
+    # A dummy presenter to abstract out the author of an official paragraph.
+    #
+    class OfficialAuthorPresenter < Decidim::OfficialAuthorPresenter
+      def name
+        I18n.t("decidim.enhanced_textwork.models.paragraph.fields.official_paragraph")
+      end
+    end
+  end
+end

data/app/presenters/decidim/enhanced_textwork/paragraph_presenter.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    #
+    # Decorator for paragraphs
+    #
+    class ParagraphPresenter < Decidim::ResourcePresenter
+      include Rails.application.routes.mounted_helpers
+      include ActionView::Helpers::UrlHelper
+
+      def author
+        @author ||= if official?
+                      Decidim::EnhancedTextwork::OfficialAuthorPresenter.new
+                    else
+                      coauthorship = coauthorships.includes(:author, :user_group).first
+                      coauthorship.user_group&.presenter || coauthorship.author.presenter
+                    end
+      end
+
+      def paragraph
+        __getobj__
+      end
+
+      def paragraph_path
+        Decidim::ResourceLocatorPresenter.new(paragraph).path
+      end
+
+      def display_mention
+        link_to title, paragraph_path
+      end
+
+      # Render the paragraph title
+      #
+      # links - should render hashtags as links?
+      # extras - should include extra hashtags?
+      #
+      # Returns a String.
+      def title(links: false, extras: true, html_escape: false, all_locales: false)
+        return unless paragraph
+
+        super paragraph.title, links, html_escape, all_locales, extras: extras
+      end
+
+      # Render the paragraph title if it is not numeric and if showing it is enabled
+      #
+      # links - should render hashtags as links?
+      # extras - should include extra hashtags?
+      #
+      # Returns a String.
+      def title_if_enabled
+        return unless paragraph
+        return "" if paragraph.component.settings.hide_participatory_text_titles_enabled? && translated_attribute(paragraph.title) !~ /\D/
+
+        translated_attribute(paragraph.title)
+      end
+
+      def id_and_title(links: false, extras: true, html_escape: false)
+        "##{paragraph.id} - #{title(links: links, extras: extras, html_escape: html_escape)}"
+      end
+
+      def body(links: false, extras: true, strip_tags: false, all_locales: false)
+        return unless paragraph
+
+        handle_locales(paragraph.body, all_locales) do |content|
+          content = strip_tags(sanitize_text(content)) if strip_tags
+
+          renderer = Decidim::ContentRenderers::HashtagRenderer.new(content)
+          content = renderer.render(links: links, extras: extras).html_safe
+
+          content = Decidim::ContentRenderers::LinkRenderer.new(content).render if links
+          content
+        end
+      end
+
+      # Returns the paragraph versions, hiding not published answers
+      #
+      # Returns an Array.
+      def versions
+        version_state_published = false
+        pending_state_change = nil
+
+        paragraph.versions.map do |version|
+          state_published_change = version.changeset["state_published_at"]
+          version_state_published = state_published_change.last.present? if state_published_change
+
+          if version_state_published
+            version.changeset["state"] = pending_state_change if pending_state_change
+            pending_state_change = nil
+          elsif version.changeset["state"]
+            pending_state_change = version.changeset.delete("state")
+          end
+
+          next if version.event == "update" && Decidim::EnhancedTextwork::DiffRenderer.new(version).diff.empty?
+
+          version
+        end.compact
+      end
+
+      delegate :count, to: :versions, prefix: true
+
+      def resource_manifest
+        paragraph.class.resource_manifest
+      end
+
+      private
+
+      def sanitize_unordered_lists(text)
+        text.gsub(%r{(?=.*</ul>)(?!.*?<li>.*?</ol>.*?</ul>)<li>}) { |li| "#{li}• " }
+      end
+
+      def sanitize_ordered_lists(text)
+        i = 0
+
+        text.gsub(%r{(?=.*</ol>)(?!.*?<li>.*?</ul>.*?</ol>)<li>}) do |li|
+          i += 1
+
+          li + "#{i}. "
+        end
+      end
+
+      def add_line_feeds_to_paragraphs(text)
+        text.gsub("</p>") { |p| "#{p}\n\n" }
+      end
+
+      def add_line_feeds_to_list_items(text)
+        text.gsub("</li>") { |li| "#{li}\n" }
+      end
+
+      # Adds line feeds after the paragraph and list item closing tags.
+      #
+      # Returns a String.
+      def add_line_feeds(text)
+        add_line_feeds_to_paragraphs(add_line_feeds_to_list_items(text))
+      end
+
+      # Maintains the paragraphs and lists separations with their bullet points and
+      # list numberings where appropriate.
+      #
+      # Returns a String.
+      def sanitize_text(text)
+        add_line_feeds(sanitize_ordered_lists(sanitize_unordered_lists(text)))
+      end
+    end
+  end
+end

data/app/queries/decidim/enhanced_textwork/filtered_paragraphs.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A class used to find paragraphs filtered by components and a date range
+    class FilteredParagraphs < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # components - An array of Decidim::Component
+      # start_at - A date to filter resources created after it
+      # end_at - A date to filter resources created before it.
+      def self.for(components, start_at = nil, end_at = nil)
+        new(components, start_at, end_at).query
+      end
+
+      # Initializes the class.
+      #
+      # components - An array of Decidim::Component
+      # start_at - A date to filter resources created after it
+      # end_at - A date to filter resources created before it.
+      def initialize(components, start_at = nil, end_at = nil)
+        @components = components
+        @start_at = start_at
+        @end_at = end_at
+      end
+
+      # Finds the Paragraphs scoped to an array of components and filtered
+      # by a range of dates.
+      def query
+        paragraphs = Decidim::EnhancedTextwork::Paragraph.where(component: @components)
+        paragraphs = paragraphs.where("created_at >= ?", @start_at) if @start_at.present?
+        paragraphs = paragraphs.where("created_at <= ?", @end_at) if @end_at.present?
+        paragraphs
+      end
+    end
+  end
+end

data/app/queries/decidim/enhanced_textwork/metrics/accepted_paragraphs_metric_manage.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Metrics
+      class AcceptedParagraphsMetricManage < Decidim::EnhancedTextwork::Metrics::ParagraphsMetricManage
+        def metric_name
+          "accepted_paragraphs"
+        end
+
+        private
+
+        def query
+          return @query if @query
+
+          spaces = Decidim.participatory_space_manifests.flat_map do |manifest|
+            manifest.participatory_spaces.call(@organization).public_spaces
+          end
+          @query = Decidim::EnhancedTextwork::Paragraph.where(component: visible_components_from_spaces(spaces)).joins(:component)
+                                               .left_outer_joins(:category)
+          @query = @query.where("decidim_enhanced_textwork_paragraphs.created_at <= ?", end_time).accepted
+          @query = @query.group("decidim_categorizations.id", :participatory_space_type, :participatory_space_id)
+          @query
+        end
+
+        def quantity
+          @quantity ||= query.where("decidim_enhanced_textwork_paragraphs.created_at >= ?", start_time).count
+        end
+      end
+    end
+  end
+end