decidim-enhanced_textwork 1.0.0

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Metrics
+      class EndorsementsMetricManage < Decidim::MetricManage
+        def metric_name
+          "endorsements"
+        end
+
+        def save
+          cumulative.each do |key, cumulative_value|
+            next if cumulative_value.zero?
+
+            quantity_value = quantity[key] || 0
+            category_id, space_type, space_id, paragraph_id = key
+            record = Decidim::Metric.find_or_initialize_by(day: @day.to_s, metric_type: @metric_name,
+                                                           organization: @organization, decidim_category_id: category_id,
+                                                           participatory_space_type: space_type, participatory_space_id: space_id,
+                                                           related_object_type: "Decidim::EnhancedTextwork::Paragraph", related_object_id: paragraph_id)
+            record.assign_attributes(cumulative: cumulative_value, quantity: quantity_value)
+            record.save!
+          end
+        end
+
+        private
+
+        def query
+          return @query if @query
+
+          components = Decidim::Component.where(participatory_space: retrieve_participatory_spaces).published
+          paragraphs = Decidim::EnhancedTextwork::Paragraph.where(component: components).except_withdrawn
+          join_components = "INNER JOIN decidim_components ON decidim_components.manifest_name = 'paragraphs' AND paragraphs.decidim_component_id = decidim_components.id"
+          join_categories = <<~EOJOINCATS
+            LEFT OUTER JOIN decidim_categorizations
+            ON (paragraphs.id = decidim_categorizations.categorizable_id
+            AND decidim_categorizations.categorizable_type = 'Decidim::EnhancedTextwork::Paragraph')
+          EOJOINCATS
+          @query = Decidim::Endorsement.joins("INNER JOIN decidim_enhanced_textwork_paragraphs paragraphs ON resource_id = paragraphs.id")
+                                       .joins(join_components)
+                                       .joins(join_categories)
+                                       .where(resource_id: paragraphs.pluck(:id))
+                                       .where(resource_type: Decidim::EnhancedTextwork::Paragraph.name)
+          @query = @query.where("decidim_endorsements.created_at <= ?", end_time)
+          @query = @query.group("decidim_categorizations.id",
+                                :participatory_space_type,
+                                :participatory_space_id,
+                                :resource_id)
+          @query
+        end
+
+        def quantity
+          @quantity ||= query.where("decidim_endorsements.created_at >= ?", start_time).count
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Metrics
+      # Searches for unique Users following the next objects
+      #  - Paragraphs
+      #  - CollaborativeDrafts
+      class ParagraphFollowersMetricMeasure < Decidim::MetricMeasure
+        def valid?
+          super && @resource.is_a?(Decidim::Component)
+        end
+
+        def calculate
+          cumulative_users = []
+          cumulative_users |= retrieve_paragraphs_followers.pluck(:decidim_user_id)
+          cumulative_users |= retrieve_drafts_followers.pluck(:decidim_user_id)
+
+          quantity_users = []
+          quantity_users |= retrieve_paragraphs_followers(from_start: true).pluck(:decidim_user_id)
+          quantity_users |= retrieve_drafts_followers(from_start: true).pluck(:decidim_user_id)
+
+          {
+            cumulative_users: cumulative_users.uniq,
+            quantity_users: quantity_users.uniq
+          }
+        end
+
+        private
+
+        def retrieve_paragraphs_followers(from_start: false)
+          @paragraphs_followers ||= Decidim::Follow.where(followable: retrieve_paragraphs).joins(:user)
+                                                  .where("decidim_follows.created_at <= ?", end_time)
+
+          return @paragraphs_followers.where("decidim_follows.created_at >= ?", start_time) if from_start
+
+          @paragraphs_followers
+        end
+
+        def retrieve_drafts_followers(from_start: false)
+          @drafts_followers ||= Decidim::Follow.where(followable: retrieve_collaborative_drafts).joins(:user)
+                                               .where("decidim_follows.created_at <= ?", end_time)
+          return @drafts_followers.where("decidim_follows.created_at >= ?", start_time) if from_start
+
+          @drafts_followers
+        end
+
+        def retrieve_paragraphs
+          Decidim::EnhancedTextwork::Paragraph.where(component: @resource).except_withdrawn
+        end
+
+        def retrieve_collaborative_drafts
+          Decidim::EnhancedTextwork::CollaborativeDraft.where(component: @resource).except_withdrawn
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Metrics
+      # Searches for Participants in the following actions
+      #  - Create a paragraph (Paragraphs)
+      #  - Give support to a paragraph (Paragraphs)
+      #  - Endorse (Paragraphs)
+      class ParagraphParticipantsMetricMeasure < Decidim::MetricMeasure
+        def valid?
+          super && @resource.is_a?(Decidim::Component)
+        end
+
+        def calculate
+          cumulative_users = []
+          cumulative_users |= retrieve_votes.pluck(:decidim_author_id)
+          cumulative_users |= retrieve_endorsements.pluck(:decidim_author_id)
+          cumulative_users |= retrieve_paragraphs.pluck("decidim_coauthorships.decidim_author_id") # To avoid ambiguosity must be called this way
+
+          quantity_users = []
+          quantity_users |= retrieve_votes(from_start: true).pluck(:decidim_author_id)
+          quantity_users |= retrieve_endorsements(from_start: true).pluck(:decidim_author_id)
+          quantity_users |= retrieve_paragraphs(from_start: true).pluck("decidim_coauthorships.decidim_author_id") # To avoid ambiguosity must be called this way
+
+          {
+            cumulative_users: cumulative_users.uniq,
+            quantity_users: quantity_users.uniq
+          }
+        end
+
+        private
+
+        def retrieve_paragraphs(from_start: false)
+          @paragraphs ||= Decidim::EnhancedTextwork::Paragraph.where(component: @resource).joins(:coauthorships)
+                                                     .includes(:votes, :endorsements)
+                                                     .where(decidim_coauthorships: {
+                                                              decidim_author_type: [
+                                                                "Decidim::UserBaseEntity",
+                                                                "Decidim::Organization",
+                                                                "Decidim::Meetings::Meeting"
+                                                              ]
+                                                            })
+                                                     .where("decidim_enhanced_textwork_paragraphs.published_at <= ?", end_time)
+                                                     .except_withdrawn
+
+          return @paragraphs.where("decidim_enhanced_textwork_paragraphs.published_at >= ?", start_time) if from_start
+
+          @paragraphs
+        end
+
+        def retrieve_votes(from_start: false)
+          @votes ||= Decidim::EnhancedTextwork::ParagraphVote.joins(:paragraph).where(paragraph: retrieve_paragraphs).joins(:author)
+                                                     .where("decidim_enhanced_textwork_paragraph_votes.created_at <= ?", end_time)
+
+          return @votes.where("decidim_enhanced_textwork_paragraph_votes.created_at >= ?", start_time) if from_start
+
+          @votes
+        end
+
+        def retrieve_endorsements(from_start: false)
+          @endorsements ||= Decidim::Endorsement.joins("INNER JOIN decidim_enhanced_textwork_paragraphs paragraphs ON resource_id = paragraphs.id")
+                                                .where(resource: retrieve_paragraphs)
+                                                .where("decidim_endorsements.created_at <= ?", end_time)
+                                                .where(decidim_author_type: "Decidim::UserBaseEntity")
+
+          return @endorsements.where("decidim_endorsements.created_at >= ?", start_time) if from_start
+
+          @endorsements
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Metrics
+      class ParagraphsMetricManage < Decidim::MetricManage
+        def metric_name
+          "paragraphs"
+        end
+
+        def save
+          cumulative.each do |key, cumulative_value|
+            next if cumulative_value.zero?
+
+            quantity_value = quantity[key] || 0
+            category_id, space_type, space_id = key
+            record = Decidim::Metric.find_or_initialize_by(day: @day.to_s, metric_type: @metric_name,
+                                                           organization: @organization, decidim_category_id: category_id,
+                                                           participatory_space_type: space_type, participatory_space_id: space_id)
+            record.assign_attributes(cumulative: cumulative_value, quantity: quantity_value)
+            record.save!
+          end
+        end
+
+        private
+
+        def query
+          return @query if @query
+
+          spaces = Decidim.participatory_space_manifests.flat_map do |manifest|
+            manifest.participatory_spaces.call(@organization)
+          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.published_at <= ?", end_time).except_withdrawn.not_hidden
+          @query = @query.group("decidim_categorizations.decidim_category_id",
+                                :participatory_space_type,
+                                :participatory_space_id)
+          @query
+        end
+
+        def quantity
+          @quantity ||= query.where("decidim_enhanced_textwork_paragraphs.published_at >= ?", start_time).count
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Metrics
+      class VotesMetricManage < Decidim::MetricManage
+        def metric_name
+          "votes"
+        end
+
+        def save
+          cumulative.each do |key, cumulative_value|
+            next if cumulative_value.zero?
+
+            quantity_value = quantity[key] || 0
+            category_id, space_type, space_id, paragraph_id = key
+            record = Decidim::Metric.find_or_initialize_by(day: @day.to_s, metric_type: @metric_name,
+                                                           organization: @organization, decidim_category_id: category_id,
+                                                           participatory_space_type: space_type, participatory_space_id: space_id,
+                                                           related_object_type: "Decidim::EnhancedTextwork::Paragraph", related_object_id: paragraph_id)
+            record.assign_attributes(cumulative: cumulative_value, quantity: quantity_value)
+            record.save!
+          end
+        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
+          paragraph_ids = Decidim::EnhancedTextwork::Paragraph.where(component: visible_components_from_spaces(spaces)).except_withdrawn.not_hidden.pluck(:id)
+          @query = Decidim::EnhancedTextwork::ParagraphVote.joins(paragraph: :component)
+                                                   .left_outer_joins(paragraph: :category)
+                                                   .where(paragraph: paragraph_ids)
+          @query = @query.where("decidim_enhanced_textwork_paragraph_votes.created_at <= ?", end_time)
+          @query = @query.group("decidim_categorizations.id",
+                                :participatory_space_type,
+                                :participatory_space_id,
+                                :decidim_paragraph_id)
+          @query
+        end
+
+        def quantity
+          @quantity ||= query.where("decidim_enhanced_textwork_paragraph_votes.created_at >= ?", start_time).count
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # Class used to retrieve similar paragraphs.
+    class SimilarParagraphs < Rectify::Query
+      include Decidim::TranslationsHelper
+
+      # Syntactic sugar to initialize the class and return the queried objects.
+      #
+      # components - Decidim::CurrentComponent
+      # paragraph - Decidim::EnhancedTextwork::Paragraph
+      def self.for(components, paragraph)
+        new(components, paragraph).query
+      end
+
+      # Initializes the class.
+      #
+      # components - Decidim::CurrentComponent
+      # paragraph - Decidim::EnhancedTextwork::Paragraph
+      def initialize(components, paragraph)
+        @components = components
+        @paragraph = paragraph
+        @translations_enabled = paragraph.component.organization.enable_machine_translations
+      end
+
+      # Retrieves similar paragraphs
+      def query
+        Decidim::EnhancedTextwork::Paragraph
+          .where(component: @components)
+          .published
+          .not_hidden
+          .where(
+            "GREATEST(#{title_similarity}, #{body_similarity}) >= ?",
+            *similarity_params,
+            Decidim::EnhancedTextwork.similarity_threshold
+          )
+          .limit(Decidim::EnhancedTextwork.similarity_limit)
+      end
+
+      private
+
+      attr_reader :translations_enabled, :paragraph
+
+      def title_similarity
+        return "similarity(title::text, ?)" unless translations_enabled
+
+        language = paragraph.content_original_language
+        "similarity(title->>'#{language}'::text, ?), similarity(title->'machine_translations'->>'#{language}'::text, ?)"
+      end
+
+      def body_similarity
+        return "similarity(body::text, ?)" unless translations_enabled
+
+        language = paragraph.content_original_language
+        "similarity(body->>'#{language}'::text, ?), similarity(body->'machine_translations'->>'#{language}'::text, ?)"
+      end
+
+      def similarity_params
+        title_attr = translated_attribute(paragraph.title)
+        body_attr = translated_attribute(paragraph.body)
+
+        translations_enabled ? [title_attr, title_attr, body_attr, body_attr] : [title_attr, body_attr]
+      end
+    end
+  end
+end

data/app/services/decidim/enhanced_textwork/collaborative_draft_search.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A service to encapsualte all the logic when searching and filtering
+    # collaborative drafts in a participatory process.
+    class CollaborativeDraftSearch < ResourceSearch
+      text_search_fields :title, :body
+
+      # Public: Initializes the service.
+      # component     - A Decidim::Component to get the drafts from.
+      # page        - The page number to paginate the results.
+      # per_page    - The number of drafts to return per page.
+      def initialize(options = {})
+        super(CollaborativeDraft.all, options)
+      end
+
+      # Handle the search_text filter
+      #
+      # We can't use the search from `ResourceFilter` since these fields aren't
+      # translated.
+      def search_search_text
+        query
+          .where("title::text ILIKE ?", "%#{search_text}%")
+          .or(query.where("body ILIKE ?", "%#{search_text}%"))
+      end
+
+      # Handle the state filter
+      def search_state
+        return query if state.member?("all")
+
+        apply_scopes(%w(open withdrawn published), state)
+      end
+
+      # Filters drafts by the name of the classes they are linked to. By default,
+      # returns all drafts. When a `related_to` param is given, then it camelcases item
+      # to find the real class name and checks the links for the Collaborative Draft.
+      #
+      # The `related_to` param is expected to be in this form:
+      #
+      #   "decidim/meetings/meeting"
+      #
+      # This can be achieved by performing `klass.name.underscore`.
+      #
+      # Returns only those drafts that are linked to the given class name.
+      def search_related_to
+        from = query
+               .joins(:resource_links_from)
+               .where(decidim_resource_links: { to_type: related_to.camelcase })
+
+        to = query
+             .joins(:resource_links_to)
+             .where(decidim_resource_links: { from_type: related_to.camelcase })
+
+        query.where(id: from).or(query.where(id: to))
+      end
+    end
+  end
+end

data/app/services/decidim/enhanced_textwork/diff_renderer.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    class DiffRenderer < BaseDiffRenderer
+      private
+
+      # Lists which attributes will be diffable and how they should be rendered.
+      def attribute_types
+        {
+          title: :i18n,
+          body: :i18n,
+          decidim_category_id: :category,
+          decidim_scope_id: :scope,
+          address: :string,
+          latitude: :string,
+          longitude: :string,
+          state: :string
+        }
+      end
+
+      # Parses the values before parsing the changeset.
+      def parse_changeset(attribute, values, type, diff)
+        return parse_scope_changeset(attribute, values, type, diff) if type == :scope
+
+        values = parse_values(attribute, values)
+        old_value = values[0]
+        new_value = values[1]
+
+        diff.update(
+          attribute => {
+            type: type,
+            label: I18n.t(attribute, scope: i18n_scope),
+            old_value: old_value,
+            new_value: new_value
+          }
+        )
+      end
+
+      # Handles which values to use when diffing emendations and
+      # normalizes line endings of the :body attribute values.
+      # Returns and Array of two Strings.
+      def parse_values(attribute, values)
+        values = [amended_previous_value(attribute), values[1]] if paragraph&.emendation?
+        values = values.map { |value| normalize_line_endings(value) } if attribute == :body
+        values
+      end
+
+      # Sets the previous value so the emendation can be compared with the amended paragraph.
+      # If the amendment is being evaluated, returns the CURRENT attribute value of the amended paragraph;
+      # else, returns the attribute value of amended paragraph at the moment of making the amendment.
+      def amended_previous_value(attribute)
+        if paragraph.amendment.evaluating?
+          paragraph.amendable.attributes[attribute.to_s]
+        else # See Decidim::Amendable::PublishDraft#set_first_emendation_version
+          paragraph.versions.first.changeset[attribute.to_s].last
+        end
+      end
+
+      # Returns a String with the newline escape sequences normalized.
+      def normalize_line_endings(value)
+        if value.is_a?(Hash)
+          value.values.map { |subvalue| normalize_line_endings(subvalue) }
+        else
+          Decidim::ContentParsers::NewlineParser.new(value, context: {}).rewrite
+        end
+      end
+
+      def paragraph
+        @paragraph ||= Paragraph.find_by(id: version.item_id)
+      end
+    end
+  end
+end

data/app/services/decidim/enhanced_textwork/paragraph_builder.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "open-uri"
+
+module Decidim
+  module EnhancedTextwork
+    # A factory class to ensure we always create Paragraphs the same way since it involves some logic.
+    module ParagraphBuilder
+      # Public: Creates a new Paragraph.
+      #
+      # attributes        - The Hash of attributes to create the Paragraph with.
+      # author            - An Authorable the will be the first coauthor of the Paragraph.
+      # user_group_author - A User Group to, optionally, set it as the author too.
+      # action_user       - The User to be used as the user who is creating the paragraph in the traceability logs.
+      #
+      # Returns a Paragraph.
+      def create(attributes:, author:, action_user:, user_group_author: nil)
+        Decidim.traceability.perform_action!(:create, Paragraph, action_user, visibility: "all") do
+          paragraph = Paragraph.new(attributes)
+          paragraph.add_coauthor(author, user_group: user_group_author)
+          paragraph.save!
+          paragraph
+        end
+      end
+
+      module_function :create
+
+      # Public: Creates a new Paragraph with the authors of the `original_paragraph`.
+      #
+      # attributes - The Hash of attributes to create the Paragraph with.
+      # action_user - The User to be used as the user who is creating the paragraph in the traceability logs.
+      # original_paragraph - The paragraph from which authors will be copied.
+      #
+      # Returns a Paragraph.
+      def create_with_authors(attributes:, action_user:, original_paragraph:)
+        Decidim.traceability.perform_action!(:create, Paragraph, action_user, visibility: "all") do
+          paragraph = Paragraph.new(attributes)
+          original_paragraph.coauthorships.each do |coauthorship|
+            paragraph.add_coauthor(coauthorship.author, user_group: coauthorship.user_group)
+          end
+          paragraph.save!
+          paragraph
+        end
+      end
+
+      module_function :create_with_authors
+
+      # Public: Creates a new Paragraph by copying the attributes from another one.
+      #
+      # original_paragraph - The Paragraph to be used as base to create the new one.
+      # author            - An Authorable the will be the first coauthor of the Paragraph.
+      # user_group_author - A User Group to, optionally, set it as the author too.
+      # action_user       - The User to be used as the user who is creating the paragraph in the traceability logs.
+      # extra_attributes  - A Hash of attributes to create the new paragraph, will overwrite the original ones.
+      # skip_link         - Whether to skip linking the two paragraphs or not (default false).
+      #
+      # Returns a Paragraph
+      #
+      # rubocop:disable Metrics/ParameterLists
+      def copy(original_paragraph, author:, action_user:, user_group_author: nil, extra_attributes: {}, skip_link: false)
+        origin_attributes = original_paragraph.attributes.except(
+          "id",
+          "created_at",
+          "updated_at",
+          "state",
+          "state_published_at",
+          "answer",
+          "answered_at",
+          "decidim_component_id",
+          "reference",
+          "comments_count",
+          "endorsements_count",
+          "follows_count",
+          "paragraph_notes_count",
+          "paragraph_votes_count"
+        ).merge(
+          "category" => original_paragraph.category
+        ).merge(
+          extra_attributes
+        )
+
+        paragraph = if author.nil?
+                     create_with_authors(
+                       attributes: origin_attributes,
+                       original_paragraph: original_paragraph,
+                       action_user: action_user
+                     )
+                   else
+                     create(
+                       attributes: origin_attributes,
+                       author: author,
+                       user_group_author: user_group_author,
+                       action_user: action_user
+                     )
+                   end
+
+        paragraph.link_resources(original_paragraph, "copied_from_component") unless skip_link
+        copy_attachments(original_paragraph, paragraph)
+
+        paragraph
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      module_function :copy
+
+      def copy_attachments(original_paragraph, paragraph)
+        original_paragraph.attachments.each do |attachment|
+          new_attachment = Decidim::Attachment.new(
+            {
+              # Attached to needs to be always defined before the file is set
+              attached_to: paragraph
+            }.merge(
+              attachment.attributes.slice("content_type", "description", "file_size", "title", "weight")
+            )
+          )
+
+          if attachment.file.attached?
+            new_attachment.file = attachment.file.blob
+          else
+            new_attachment.attached_uploader(:file).remote_url = attachment.attached_uploader(:file).url(host: original_paragraph.organization.host)
+          end
+
+          new_attachment.save!
+        rescue Errno::ENOENT, OpenURI::HTTPError => e
+          Rails.logger.warn("[ERROR] Couldn't copy attachment from paragraph #{original_paragraph.id} when copying to component due to #{e.message}")
+        end
+      end
+
+      module_function :copy_attachments
+    end
+  end
+end