decidim-participatory_processes 0.19.1 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26796587924ddffda370cd31f84fe2356197e4a772670d73621b4d49eb3b48ec
-  data.tar.gz: a580378c67f87b97d994f45afbe1633fc7dc75df0e2deb0489d74f8470be41aa
+  metadata.gz: 5f959ee9321869b81c37005639c7a0a97f1b2722c77761e79306efa8ecfa1066
+  data.tar.gz: ec371806ff5ead53ee47a376df07dff624e5339ed753a152b0368d8bfe2d8c8e
 SHA512:
-  metadata.gz: 69e91a8fd76b7fe47d34fab56a3607713654efebbabedd88a21624ec23763c5f6524a418a3313372adac0417834174e9541ff798cadf26704dfa3766164462a7
-  data.tar.gz: e864877ec2478044dafda6763b939e197dc426541ed0d7a6889c5b0c2e52e7c1ea5f0a91978d0aa38d0190eb01ff4a346c3fded112e2df73685cea6fb1293237
+  metadata.gz: be8f140181b6a2c49468bfdd39cdcea9acca454b75b0797ad0d1fb8f8e5c0b657e3cb375f905625bfd9acb3fcbebe71e20acff98de7617870172711869d77d14
+  data.tar.gz: d0bffa4750c27e6ac2f61904ece20a42847f86dc69a2cea5ad8858e3a51087f9c45bbf8e073be72cd8b4bab4e82096ad812d5503c92a5bbdb69d7ed4723ee43a

data/app/commands/decidim/participatory_processes/admin/create_participatory_process.rb

@@ -105,17 +105,6 @@ module Decidim
             Decidim::CreateFollow.new(form, admin).call
           end
         end
-
-        def create_participatory_process_users(process)
-          return unless form.private_process
-
-          form.users.each do |user|
-            ParticipatoryProcessUser.create!(
-              participatory_process: process,
-              user: user
-            )
-          end
-        end
       end
     end
   end

data/app/commands/decidim/participatory_processes/admin/import_participatory_process.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatoryProcesses
+    module Admin
+      # A command with all the business logic when copying a new participatory
+      # process in the system.
+      class ImportParticipatoryProcess < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form - A form object with the params.
+        # participatory_process - A participatory_process we want to duplicate
+        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) if form.invalid?
+
+          transaction do
+            import_participatory_process
+            add_admins_as_followers(@imported_process)
+          end
+
+          broadcast(:ok, @imported_process)
+        end
+
+        private
+
+        attr_reader :form
+
+        def import_participatory_process
+          importer = Decidim::ParticipatoryProcesses::ParticipatoryProcessImporter.new(form.current_organization, form.current_user)
+          participatory_processes.each do |original_process|
+            @imported_process = importer.import(original_process, form.current_user, title: form.title, slug: form.slug)
+            importer.import_participatory_process_steps(original_process["participatory_process_steps"]) if form.import_steps?
+            importer.import_categories(original_process["participatory_process_categories"]) if form.import_categories?
+            importer.import_folders_and_attachments(original_process["attachments"]) if form.import_attachments?
+            importer.import_components(original_process["components"]) if form.import_components?
+          end
+        end
+
+        def participatory_processes
+          document_parsed(form.document_text)
+        end
+
+        def document_parsed(document_text)
+          JSON.parse(document_text)
+        end
+
+        def add_admins_as_followers(process)
+          process.organization.admins.each do |admin|
+            form = Decidim::FollowForm
+                   .from_params(followable_gid: process.to_signed_global_id.to_s)
+                   .with_context(
+                     current_organization: process.organization,
+                     current_user: admin
+                   )
+
+            Decidim::CreateFollow.new(form, admin).call
+          end
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/participatory_processes/admin/participatory_process_exports_controller.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatoryProcesses
+    module Admin
+      class ParticipatoryProcessExportsController < Decidim::Admin::ApplicationController
+        include Concerns::ParticipatoryProcessAdmin
+        include Decidim::Admin::ParticipatorySpaceExport
+
+        def exportable_space
+          current_participatory_process
+        end
+
+        def after_export_path
+          participatory_processes_path
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/participatory_processes/admin/participatory_process_imports_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatoryProcesses
+    module Admin
+      class ParticipatoryProcessImportsController < Decidim::ParticipatoryProcesses::Admin::ApplicationController
+        def new
+          enforce_permission_to :import, :process
+          @form = form(ParticipatoryProcessImportForm).instance
+        end
+
+        def create
+          enforce_permission_to :import, :process
+          @form = form(ParticipatoryProcessImportForm).from_params(params)
+
+          ImportParticipatoryProcess.call(@form) do
+            on(:ok) do
+              flash[:notice] = I18n.t("participatory_process_imports.create.success", scope: "decidim.admin")
+              redirect_to participatory_processes_path
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("participatory_process_imports.create.error", scope: "decidim.admin")
+              render :new
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/forms/decidim/participatory_processes/admin/participatory_process_import_form.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatoryProcesses
+    module Admin
+      # A form object used to import a participatory processes from the admin
+      # dashboard.
+      #
+      class ParticipatoryProcessImportForm < Form
+        include TranslatableAttributes
+
+        JSON_MIME_TYPE = "application/json"
+        # Accepted mime types
+        # keys: are used for dynamic help text on admin form.
+        # values: are used to validate the file format of imported document.
+        ACCEPTED_TYPES = {
+          json: JSON_MIME_TYPE
+        }.freeze
+
+        translatable_attribute :title, String
+
+        mimic :participatory_process
+
+        attribute :slug, String
+        attribute :import_steps, Boolean, default: true
+        attribute :import_categories, Boolean, default: true
+        attribute :import_attachments, Boolean, default: true
+        attribute :import_components, Boolean, default: true
+        attribute :document
+
+        validates :document, presence: true
+
+        validates :slug, presence: true, format: { with: Decidim::ParticipatoryProcess.slug_format }
+        validates :title, translatable_presence: true
+        validate :slug_uniqueness
+
+        validate :document_type_must_be_valid, if: :document
+
+        def document_text
+          @document_text ||= document&.read
+        end
+
+        def document_type_must_be_valid
+          return if valid_mime_types.include?(document_type)
+
+          errors.add(:document, i18n_invalid_document_type_text)
+        end
+
+        # Return ACCEPTED_MIME_TYPES plus `text/plain` for better markdown support
+        def valid_mime_types
+          ACCEPTED_TYPES.values
+        end
+
+        def document_type
+          document.content_type
+        end
+
+        def i18n_invalid_document_type_text
+          I18n.t("invalid_document_type",
+                 scope: "activemodel.errors.models.participatory_process.attributes.document",
+                 valid_mime_types: i18n_valid_mime_types_text)
+        end
+
+        def i18n_valid_mime_types_text
+          ACCEPTED_TYPES.keys.map do |mime_type|
+            I18n.t(mime_type, scope: "decidim.participatory_processes.admin.new_import.accepted_types")
+          end.join(", ")
+        end
+
+        private
+
+        def slug_uniqueness
+          return unless OrganizationParticipatoryProcesses.new(current_organization).query.where(slug: slug).where.not(id: id).any?
+
+          errors.add(:slug, :taken)
+        end
+      end
+    end
+  end
+end

data/app/models/decidim/participatory_process.rb

@@ -18,6 +18,7 @@ module Decidim
     include Decidim::HasPrivateUsers
     include Decidim::Loggable
     include Decidim::ParticipatorySpaceResourceable
+    include Decidim::Searchable
 
     belongs_to :organization,
                foreign_key: "decidim_organization_id",
@@ -63,6 +64,18 @@ module Decidim
     scope :upcoming, -> { where(arel_table[:start_date].gt(Date.current)) }
     scope :active, -> { where(arel_table[:start_date].lteq(Date.current).and(arel_table[:end_date].gt(Date.current).or(arel_table[:end_date].eq(nil)))) }
 
+    searchable_fields({
+                        scope_id: :decidim_scope_id,
+                        participatory_space: :itself,
+                        A: :title,
+                        B: :subtitle,
+                        C: :short_description,
+                        D: :description,
+                        datetime: :published_at
+                      },
+                      index_on_create: ->(_process) { false },
+                      index_on_update: ->(process) { process.visible? })
+
     # Scope to return only the promoted processes.
     #
     # Returns an ActiveRecord::Relation.

data/app/permissions/decidim/participatory_processes/permissions.rb

@@ -223,7 +223,9 @@ module Decidim
           :moderation,
           :process,
           :process_step,
-          :process_user_role
+          :process_user_role,
+          :export_space,
+          :import
         ].include?(permission_action.subject)
         allow! if is_allowed
       end
@@ -241,7 +243,9 @@ module Decidim
           :process,
           :process_step,
           :process_user_role,
-          :space_private_user
+          :space_private_user,
+          :export_space,
+          :import
         ].include?(permission_action.subject)
         allow! if is_allowed
       end

data/app/presenters/decidim/participatory_processes/participatory_process_group_presenter.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatoryProcesses
+    class ParticipatoryProcessGroupPresenter < SimpleDelegator
+      include Rails.application.routes.mounted_helpers
+      include ActionView::Helpers::UrlHelper
+
+      delegate :url, to: :hero_image, prefix: true
+
+      def hero_image_url
+        return if process_group.blank?
+
+        URI.join(decidim.root_url(host: process_group.organization.host), process_group.try(:hero_image_url)).to_s
+      end
+
+      def process_group
+        __getobj__
+      end
+    end
+  end
+end

data/app/presenters/decidim/participatory_processes/participatory_process_presenter.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatoryProcesses
+    class ParticipatoryProcessPresenter < SimpleDelegator
+      include Rails.application.routes.mounted_helpers
+      include ActionView::Helpers::UrlHelper
+
+      delegate :url, to: :hero_image, prefix: true
+      delegate :url, to: :banner_image, prefix: true
+
+      def hero_image_url
+        URI.join(decidim.root_url(host: process.organization.host), process.hero_image_url).to_s
+      end
+
+      def banner_image_url
+        URI.join(decidim.root_url(host: process.organization.host), process.banner_image_url).to_s
+      end
+
+      def process
+        __getobj__
+      end
+    end
+  end
+end

data/app/serializers/decidim/participatory_processes/participatory_process_importer.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ParticipatoryProcesses
+    # A factory class to ensure we always create ParticipatoryProcesses the same way since it involves some logic.
+    class ParticipatoryProcessImporter < Decidim::Importers::Importer
+      def initialize(organization, user)
+        @organization = organization
+        @user = user
+      end
+
+      # Public: Creates a new ParticipatoryProcess.
+      #
+      # attributes  - The Hash of attributes to create the ParticipatoryProcess with.
+      # user        - The user that performs the action.
+      # opts        - The options MUST contain:
+      #   - title: The +title+ for the new PartidicpatoryProcess
+      #   - slug: The +slug+ for the new PartidicpatoryProcess
+      #
+      # Returns a ParticipatoryProcess.
+      def import(attributes, _user, opts)
+        title = opts[:title]
+        slug = opts[:slug]
+        Decidim.traceability.perform_action!(:create, ParticipatoryProcess, @user, visibility: "all") do
+          @imported_process = ParticipatoryProcess.new(
+            organization: @organization,
+            title: title,
+            slug: slug,
+            subtitle: attributes["subtitle"],
+            hashtag: attributes["hashtag"],
+            description: attributes["description"],
+            short_description: attributes["short_description"],
+            promoted: attributes["promoted"],
+            developer_group: attributes["developer_group"],
+            local_area: attributes["local_area"],
+            target: attributes["target"],
+            participatory_scope: attributes["participatory_scope"],
+            participatory_structure: attributes["participatory_structure"],
+            meta_scope: attributes["meta_scope"],
+            start_date: attributes["start_date"],
+            end_date: attributes["end_date"],
+            private_space: attributes["private_space"],
+            participatory_process_group: import_process_group(attributes["participatory_process_group"])
+          )
+          @imported_process.remote_hero_image_url = attributes["remote_hero_image_url"] if remote_file_exists?(attributes["remote_hero_image_url"])
+          @imported_process.remote_banner_image_url = attributes["remote_banner_image_url"] if remote_file_exists?(attributes["remote_banner_image_url"])
+          @imported_process.save!
+          @imported_process
+        end
+      end
+
+      def import_process_group(attributes)
+        Decidim.traceability.perform_action!("create", ParticipatoryProcessGroup, @user) do
+          group = ParticipatoryProcessGroup.find_or_initialize_by(
+            name: attributes["name"],
+            description: attributes["description"],
+            organization: @organization
+          )
+
+          group.remote_hero_image_url = attributes["remote_hero_image_url"] if remote_file_exists?(attributes["remote_hero_image_url"])
+          group.save!
+          group
+        end
+      end
+
+      def import_participatory_process_steps(steps)
+        return if steps.nil?
+
+        steps.map do |step_attributes|
+          Decidim.traceability.create!(
+            ParticipatoryProcessStep,
+            @user,
+            title: step_attributes["title"],
+            description: step_attributes["description"],
+            start_date: step_attributes["start_date"],
+            end_date: step_attributes["end_date"],
+            participatory_process: @imported_process,
+            active: step_attributes["active"],
+            position: step_attributes["position"]
+          )
+        end
+      end
+
+      def import_categories(categories)
+        return if categories.nil?
+
+        categories.map do |category_attributes|
+          category = Decidim.traceability.create!(
+            Category,
+            @user,
+            name: category_attributes["name"],
+            description: category_attributes["description"],
+            parent_id: category_attributes["parent_id"],
+            participatory_space: @imported_process
+          )
+          next if category_attributes["subcategories"].nil?
+
+          category_attributes["subcategories"].map do |subcategory_attributes|
+            Decidim.traceability.create!(
+              Category,
+              @user,
+              name: subcategory_attributes["name"],
+              description: subcategory_attributes["description"],
+              parent_id: category.id,
+              participatory_space: @imported_process
+            )
+          end
+        end
+      end
+
+      def import_folders_and_attachments(attachments)
+        return if attachments["files"].nil?
+
+        attachments["files"].map do |file|
+          next unless remote_file_exists?(file["remote_file_url"])
+
+          file_tmp = URI.open(file["remote_file_url"])
+
+          Decidim.traceability.perform_action!("create", Attachment, @user) do
+            attachment = Attachment.new(
+              title: file["title"],
+              description: file["description"],
+              file: file_tmp,
+              file_size: file_tmp.size,
+              content_type: file_tmp.content_type,
+              attached_to: @imported_process,
+              weight: file["weight"]
+            )
+            attachment.create_attachment_collection(file["attachment_collection"])
+            attachment.save!
+            attachment
+          end
+        end
+
+        attachments["attachment_collections"].map do |collection|
+          Decidim.traceability.perform_action!("create", AttachmentCollection, @user) do
+            create_attachment_collection(collection)
+          end
+        end
+      end
+
+      # +components+: An Array of Hashes, each corresponding with the settings of a Decidim::Component.
+      def import_components(components)
+        return if components.nil?
+
+        importer = Decidim::Importers::ParticipatorySpaceComponentsImporter.new(@imported_process)
+        importer.import(components, @user)
+      end
+
+      private
+
+      def create_attachment_collection(attributes)
+        return unless attributes.compact.any?
+
+        attachment_collection = AttachmentCollection.find_or_initialize_by(
+          name: attributes["name"],
+          weight: attributes["weight"],
+          description: attributes["description"],
+          collection_for: @imported_process
+        )
+        attachment_collection.save!
+        attachment_collection
+      end
+
+      def remote_file_exists?(url)
+        return if url.nil?
+
+        accepted = ["image", "application/pdf"]
+        url = URI.parse(url)
+        Net::HTTP.start(url.host, url.port) do |http|
+          return http.head(url.request_uri)["Content-Type"].start_with?(*accepted)
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end