decidim-enhanced_textwork 1.0.0

data/app/cells/decidim/enhanced_textwork/participatory_text_paragraph/show.erb

@@ -0,0 +1,38 @@
+<div class="paragraph__hover-section" id="<%= dom_id(model) %>">
+  <%= content_tag :div, class: paragraph_class_names do %>
+    <%= link_to overview_paragraph_path(model, anchor: dom_id(model)), class: "card__link--block pb-s" do %>
+      <%= title %>
+      <%= body %>
+    <% end %>
+
+    <div class="paragraph__actions row">
+      <div class="columns mediumlarge-2">
+        
+      </div>
+
+      <div class="columns mediumlarge-10 right-column">
+        <%= render partial: "decidim/enhanced_textwork/paragraphs/participatory_texts/paragraph_vote_button.html", locals: { paragraph: model, from_paragraphs_list: true } %>
+
+        <% if model.component.settings.comments_enabled %>
+          <%= link_to overview_paragraph_path(model, anchor: dom_id(model)) do %>
+            <%= icon "comment-square", class: "icon--small", role: "img", "aria-hidden": true %>
+            <%= t("decidim.enhanced_textwork.actions.add_comment") %>
+            (<%= present(model).comments_count %>)
+          <% end %>
+        <% end %>
+
+        <% if model.component.settings.amendments_enabled %>
+          <%= link_to amend_resource_path do %>
+            <%= icon "pencil", class: "icon--small", role: "img", "aria-hidden": true %>
+            <%= t("decidim.enhanced_textwork.actions.add_amendment") %>
+            (<%= model.amendments.count %>)
+          <% end %>
+        <% end %>
+
+        <%= link_to paragraph_path(model) do %>
+          <%= t('decidim.enhanced_textwork.actions.show_details') %>
+        <% end %>
+      </div>
+    </div>
+  <% end %>
+</div>

data/app/cells/decidim/enhanced_textwork/participatory_text_paragraph_cell.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "cell/partial"
+
+module Decidim
+  module EnhancedTextwork
+    # This cell renders the participatory text paragraph card for an instance of a Paragraph
+    # the default size is the Medium Card (:m)
+    class ParticipatoryTextParagraphCell < Decidim::ViewModel
+      include ParagraphCellsHelper
+      include Cell::ViewModel::Partial
+      include Messaging::ConversationHelper
+      include Decidim::SanitizeHelper
+
+      def show
+        render
+      end
+
+      private
+
+      def title
+        return "" if section_title.blank?
+
+        case model.participatory_text_level
+        when "section"
+          "<h5><strong>#{section_title}</strong></h5>"
+        else
+          "<h6><strong>#{section_title}</strong></h6>"
+        end
+      end
+
+      def section_title
+        decidim_html_escape(present(model).title_if_enabled).html_safe
+      end
+
+      def body
+        return unless model.participatory_text_level == "article"
+
+        formatted = simple_format(present(model).body)
+        decidim_sanitize(strip_links(formatted))
+      end
+
+      def resource_path
+        resource_locator(model).path(filter_link_params)
+      end
+
+      def amend_resource_path
+        decidim.new_amend_path(amendable_gid: model.to_sgid.to_s)
+      end
+
+      def resource_comments_path
+        resource_locator(model).path(anchor: "comments")
+      end
+
+      def resource_amendments_path
+        resource_locator(model).path(anchor: "amendments")
+      end
+
+      def current_participatory_space
+        model.component.participatory_space
+      end
+
+      def component_name
+        translated_attribute current_component.name
+      end
+
+      def component_type_name
+        model.class.model_name.human
+      end
+
+      def participatory_space_name
+        translated_attribute current_participatory_space.title
+      end
+
+      def participatory_space_type_name
+        translated_attribute current_participatory_space.model_name.human
+      end
+
+      def visible_emendations
+        @visible_emendations ||= model.visible_emendations_for(current_user)
+      end
+
+      def amendmendment_creation_enabled?
+        (current_component.settings.amendments_enabled? && current_settings.amendment_creation_enabled?)
+      end
+
+      def amend_button_disabled?
+        !amendmendment_creation_enabled?
+      end
+
+      def active_paragraph?
+        @options[:active_paragraph] && model == @options[:active_paragraph]
+      end
+
+      def paragraph_class_names
+        class_names = "paragraph"
+
+        class_names = "#{class_names} paragraph--active" if active_paragraph?
+
+        class_names
+      end
+    end
+  end
+end

data/app/cells/decidim/enhanced_textwork/reported_content/show.erb

@@ -0,0 +1,4 @@
+<blockquote>
+  <h5><%= render_value model.title %></h5>
+  <p><%= render_value model.body %></p>
+</blockquote>

data/app/cells/decidim/enhanced_textwork/reported_content_cell.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # This cells renders a small preview of the `Paragraph` that is
+    # used in the moderations panel.
+    class ReportedContentCell < Decidim::ReportedContentCell
+      def show
+        render :show
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/accept_access_to_collaborative_draft.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    # A command with all the business logic to accept a user request to
+    # contribute to a collaborative draft.
+    class AcceptAccessToCollaborativeDraft < Rectify::Command
+      # Public: Initializes the command.
+      #
+      # form         - A form object with the params.
+      # collaborative_draft     - A Decidim::EnhancedTextwork::CollaborativeDraft object.
+      # current_user - The current user.
+      # requester_user - The user that requested to collaborate.
+      def initialize(form, current_user)
+        @form = form
+        @collaborative_draft = form.collaborative_draft
+        @current_user = current_user
+        @requester_user = form.requester_user
+      end
+
+      # Executes the command. Broadcasts these events:
+      #
+      # - :ok when everything is valid.
+      # - :invalid if it wasn't valid and we couldn't proceed.
+      #
+      # Returns nothing.
+      def call
+        return broadcast(:invalid) if @form.invalid?
+        return broadcast(:invalid) if @current_user.nil?
+
+        transaction do
+          @collaborative_draft.requesters.delete @requester_user
+
+          Decidim::Coauthorship.create(
+            coauthorable: @collaborative_draft,
+            author: @requester_user
+          )
+        end
+
+        notify_collaborative_draft_requester
+        notify_collaborative_draft_authors
+        broadcast(:ok, @requester_user)
+      end
+
+      private
+
+      def notify_collaborative_draft_authors
+        affected_users = @collaborative_draft.notifiable_identities - [@requester_user]
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.collaborative_draft_access_accepted",
+          event_class: Decidim::EnhancedTextwork::CollaborativeDraftAccessAcceptedEvent,
+          resource: @collaborative_draft,
+          affected_users: affected_users.uniq,
+          extra: {
+            requester_id: @requester_user.id
+          }
+        )
+      end
+
+      def notify_collaborative_draft_requester
+        Decidim::EventsManager.publish(
+          event: "decidim.events.enhanced_textwork.collaborative_draft_access_requester_accepted",
+          event_class: Decidim::EnhancedTextwork::CollaborativeDraftAccessRequesterAcceptedEvent,
+          resource: @collaborative_draft,
+          affected_users: [@requester_user]
+        )
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/answer_paragraph.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin answers a paragraph.
+      class AnswerParagraph < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        # paragraph - The paragraph to write the answer for.
+        def initialize(form, paragraph)
+          @form = form
+          @paragraph = paragraph
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          store_initial_paragraph_state
+
+          transaction do
+            answer_paragraph
+            notify_paragraph_answer
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form, :paragraph, :initial_has_state_published, :initial_state
+
+        def answer_paragraph
+          Decidim.traceability.perform_action!(
+            "answer",
+            paragraph,
+            form.current_user
+          ) do
+            attributes = {
+              state: form.state,
+              answer: form.answer,
+              answered_at: Time.current,
+              cost: form.cost,
+              cost_report: form.cost_report,
+              execution_period: form.execution_period
+            }
+
+            attributes[:state_published_at] = Time.current if !initial_has_state_published && form.publish_answer?
+
+            paragraph.update!(attributes)
+          end
+        end
+
+        def notify_paragraph_answer
+          return if !initial_has_state_published && !form.publish_answer?
+
+          NotifyParagraphAnswer.call(paragraph, initial_state)
+        end
+
+        def store_initial_paragraph_state
+          @initial_has_state_published = paragraph.published_state?
+          @initial_state = paragraph.state
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/assign_paragraphs_to_valuator.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic to assign paragraphs to a given
+      # valuator.
+      class AssignParagraphsToValuator < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless form.valid?
+
+          assign_paragraphs
+          broadcast(:ok)
+        rescue ActiveRecord::RecordInvalid
+          broadcast(:invalid)
+        end
+
+        private
+
+        attr_reader :form
+
+        def assign_paragraphs
+          transaction do
+            form.paragraphs.flat_map do |paragraph|
+              find_assignment(paragraph) || assign_paragraph(paragraph)
+            end
+          end
+        end
+
+        def find_assignment(paragraph)
+          Decidim::EnhancedTextwork::ValuationAssignment.find_by(
+            paragraph: paragraph,
+            valuator_role: form.valuator_role
+          )
+        end
+
+        def assign_paragraph(paragraph)
+          Decidim.traceability.create!(
+            Decidim::EnhancedTextwork::ValuationAssignment,
+            form.current_user,
+            paragraph: paragraph,
+            valuator_role: form.valuator_role
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/create_paragraph.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when a user creates a new paragraph.
+      class CreateParagraph < Rectify::Command
+        include ::Decidim::AttachmentMethods
+        include GalleryMethods
+        include HashtagsMethods
+
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid, together with the paragraph.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          if process_attachments?
+            build_attachment
+            return broadcast(:invalid) if attachment_invalid?
+          end
+
+          if process_gallery?
+            build_gallery
+            return broadcast(:invalid) if gallery_invalid?
+          end
+
+          transaction do
+            create_paragraph
+            create_attachment if process_attachments?
+            create_gallery if process_gallery?
+            link_author_meeeting if form.created_in_meeting?
+            send_notification
+          end
+
+          broadcast(:ok, paragraph)
+        end
+
+        private
+
+        attr_reader :form, :paragraph, :attachment, :gallery
+
+        def create_paragraph
+          @paragraph = Decidim::EnhancedTextwork::ParagraphBuilder.create(
+            attributes: attributes,
+            author: form.author,
+            action_user: form.current_user
+          )
+          @attached_to = @paragraph
+        end
+
+        def attributes
+          parsed_title = Decidim::ContentProcessor.parse_with_processor(:hashtag, form.title, current_organization: form.current_organization).rewrite
+          parsed_body = Decidim::ContentProcessor.parse_with_processor(:hashtag, form.body, current_organization: form.current_organization).rewrite
+          {
+            title: parsed_title,
+            body: parsed_body,
+            category: form.category,
+            scope: form.scope,
+            component: form.component,
+            address: form.address,
+            latitude: form.latitude,
+            longitude: form.longitude,
+            created_in_meeting: form.created_in_meeting,
+            published_at: Time.current
+          }
+        end
+
+        def link_author_meeeting
+          paragraph.link_resources(form.author, "paragraphs_from_meeting")
+        end
+
+        def send_notification
+          Decidim::EventsManager.publish(
+            event: "decidim.events.enhanced_textwork.paragraph_published",
+            event_class: Decidim::EnhancedTextwork::PublishParagraphEvent,
+            resource: paragraph,
+            followers: @paragraph.participatory_space.followers,
+            extra: {
+              participatory_space: true
+            }
+          )
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/create_paragraph_note.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin creates a private note paragraph.
+      class CreateParagraphNote < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form         - A form object with the params.
+        # paragraph - the paragraph to relate.
+        def initialize(form, paragraph)
+          @form = form
+          @paragraph = paragraph
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid, together with the note paragraph.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid?
+
+          create_paragraph_note
+          notify_admins_and_valuators
+
+          broadcast(:ok, paragraph_note)
+        end
+
+        private
+
+        attr_reader :form, :paragraph_note, :paragraph
+
+        def create_paragraph_note
+          @paragraph_note = Decidim.traceability.create!(
+            ParagraphNote,
+            form.current_user,
+            {
+              body: form.body,
+              paragraph: paragraph,
+              author: form.current_user
+            },
+            resource: {
+              title: paragraph.title
+            }
+          )
+        end
+
+        def notify_admins_and_valuators
+          affected_users = Decidim::User.org_admins_except_me(form.current_user).all
+          affected_users += Decidim::EnhancedTextwork::ValuationAssignment.includes(valuator_role: :user).where.not(id: form.current_user.id).where(paragraph: paragraph).map(&:valuator)
+
+          data = {
+            event: "decidim.events.enhanced_textwork.admin.paragraph_note_created",
+            event_class: Decidim::EnhancedTextwork::Admin::ParagraphNoteCreatedEvent,
+            resource: paragraph,
+            affected_users: affected_users
+          }
+
+          Decidim::EventsManager.publish(data)
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/destroy_paragraph.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when a user destroys a draft paragraph.
+      class DestroyParagraph < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # paragraph     - The paragraph to destroy.
+        def initialize(paragraph)
+          @paragraph = paragraph
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid and the paragraph is deleted.
+        # - :invalid if the paragraph is not a draft.
+        # - :invalid if the paragraph's author is not the current user.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless @paragraph.draft?
+
+          @paragraph.destroy!
+
+          broadcast(:ok, @paragraph)
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/discard_participatory_text.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic related with an admin discarding participatory text paragraphs.
+      class DiscardParticipatoryText < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A PreviewParticipatoryTextForm form object with the params.
+        def initialize(component)
+          @component = component
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          transaction do
+            discard_drafts
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form
+
+        def discard_drafts
+          paragraphs = Decidim::EnhancedTextwork::Paragraph.drafts.where(component: @component)
+          paragraphs.destroy_all
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/enhanced_textwork/admin/import_from_editor_participatory_text.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Decidim
+  module EnhancedTextwork
+    module Admin
+      # A command with all the business logic when an admin imports paragraphs from
+      # a participatory text rich text editor.
+      class ImportFromEditorParticipatoryText < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        def initialize(form)
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) unless @form.valid?
+
+          transaction do
+            save_participatory_text_meta(@form)
+            parse_participatory_text_content(@form)
+          end
+
+          broadcast(:ok)
+          # rescue StandardError
+          #   broadcast(:invalid_file)
+        end
+
+        private
+
+        # Persist ParticipatoryText related meta information.
+        def save_participatory_text_meta(form)
+          document = ParticipatoryText.find_or_initialize_by(component: form.current_component)
+          document.update!(title: form.title, description: form.description)
+        end
+
+        def parse_participatory_text_content(form)
+          return if form.content.blank?
+
+          markdown = Decidim::EnhancedTextwork::HtmlToMarkdown.new(form.content).to_md
+          parser = MarkdownToParagraphs.new(form.current_component, form.current_user)
+          parser.parse(markdown)
+        end
+      end
+    end
+  end
+end