decidim-assemblies 0.21.0 → 0.23.2

data/app/presenters/decidim/assemblies/admin_log/assemblies_setting_presenter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Assemblies
+    module AdminLog
+      # This class holds the logic to present a `Decidim::AssembliesSetting`
+      # 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
+      #    AssembliesSettingPresenter.new(action_log, view_helpers).present
+      class AssembliesSettingPresenter < Decidim::Log::BasePresenter
+        private
+
+        def action_string
+          case action
+          when "update"
+            "decidim.admin_log.assembly_setting.#{action}"
+          end
+        end
+      end
+    end
+  end
+end

data/app/presenters/decidim/assemblies/admin_log/assemblies_type_presenter.rb

@@ -34,8 +34,8 @@ module Decidim
           end
         end
 
-        def has_diff?
-          action == "delete" || super
+        def diff_actions
+          super + %w(delete)
         end
       end
     end

data/app/presenters/decidim/assemblies/admin_log/assembly_member_presenter.rb

@@ -43,8 +43,8 @@ module Decidim
           end
         end
 
-        def has_diff?
-          action == "delete" || super
+        def diff_actions
+          super + %w(delete)
         end
       end
     end

data/app/presenters/decidim/assemblies/admin_log/assembly_presenter.rb

@@ -70,8 +70,8 @@ module Decidim
           end
         end
 
-        def has_diff?
-          action == "unpublish" || super
+        def diff_actions
+          super + %w(unpublish)
         end
       end
     end

data/app/presenters/decidim/assemblies/admin_log/assembly_user_role_presenter.rb

@@ -44,8 +44,8 @@ module Decidim
           ).changeset
         end
 
-        def has_diff?
-          action == "delete" || super
+        def diff_actions
+          super + %w(delete)
         end
       end
     end

data/app/presenters/decidim/assemblies/assembly_presenter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Assemblies
+    class AssemblyPresenter < 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
+        return if assembly.hero_image.blank?
+
+        URI.join(decidim.root_url(host: assembly.organization.host), assembly.hero_image_url).to_s
+      end
+
+      def banner_image_url
+        return if assembly.banner_image.blank?
+
+        URI.join(decidim.root_url(host: assembly.organization.host), assembly.banner_image_url).to_s
+      end
+
+      def assembly
+        __getobj__
+      end
+    end
+  end
+end

data/app/presenters/decidim/assemblies/assembly_stats_presenter.rb

@@ -38,7 +38,7 @@ module Decidim
 
       def render_stats_data(component_manifest, name, data, index)
         safe_join([
-                    index.zero? ? manifest_icon(component_manifest) : " /&nbsp".html_safe,
+                    index.zero? ? manifest_icon(component_manifest, role: "img", "aria-hidden": true) : " /&nbsp".html_safe,
                     content_tag(:span, "#{number_with_delimiter(data)} " + I18n.t(name, scope: "decidim.assemblies.statistics"),
                                 class: "#{name} process_stats-text")
                   ])

data/app/queries/decidim/assemblies/parent_assemblies_for_select.rb

@@ -15,8 +15,27 @@ module Decidim
         @assembly = assembly
       end
 
+      # Finds the available assemblies
+      #
+      # Returns an ActiveRecord::Relation.
       def query
-        Assembly.where(organization: @organization).where.not(id: @assembly)
+        available_assemblies = Assembly.where(organization: @organization).where.not(id: @assembly)
+
+        return available_assemblies if @assembly.blank?
+
+        available_assemblies.where.not(id: descendant_ids)
+      end
+
+      private
+
+      def descendant_ids
+        recursive_children(@assembly).flatten
+      end
+
+      def recursive_children(model)
+        model.children.map do |child|
+          [recursive_children(child), child.id]
+        end
       end
     end
   end

data/app/serializers/decidim/assemblies/assembly_importer.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Assemblies
+    # A factory class to ensure we always create Assemblies the same way since it involves some logic.
+    class AssemblyImporter < Decidim::Importers::Importer
+      def initialize(organization, user)
+        @organization = organization
+        @user = user
+      end
+
+      # Public: Creates a new Assembly.
+      #
+      # attributes  - The Hash of attributes to create the Assembly with.
+      # user        - The user that performs the action.
+      # opts        - The options MUST contain:
+      #   - title: The +title+ for the new Assembly
+      #   - slug: The +slug+ for the new Assembly
+      #
+      # Returns a Assembly.
+      def import(attributes, _user, opts)
+        title = opts[:title]
+        slug = opts[:slug]
+        Decidim.traceability.perform_action!(:create, Assembly, @user, visibility: "all") do
+          @imported_assembly = Assembly.new(
+            organization: @organization,
+            title: title,
+            slug: slug,
+            hashtag: attributes["hashtag"],
+            subtitle: attributes["subtitle"],
+            short_description: attributes["short_description"],
+            description: attributes["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"],
+            show_statistics: attributes["show_statistics"],
+            scopes_enabled: attributes["scopes_enabled"],
+            private_space: attributes["private_space"],
+            reference: attributes["reference"],
+            purpose_of_action: attributes["purpose_of_action"],
+            composition: attributes["composition"],
+            duration: attributes["duration"],
+            creation_date: attributes["creation_date"],
+            decidim_scope_id: attributes["decidim_scope_id"],
+            closing_date_reason: attributes["closing_date_reason"],
+            included_at: attributes["included_at"],
+            closing_date: attributes["closing_date"],
+            created_by_other: attributes["created_by_other"],
+            internal_organisation: attributes["internal_organisation"],
+            is_transparent: attributes["is_transparent"],
+            special_features: attributes["special_features"],
+            twitter_handler: attributes["twitter_handler"],
+            instagram_handler: attributes["instagram_handler"],
+            facebook_handler: attributes["facebook_handler"],
+            youtube_handler: attributes["youtube_handler"],
+            github_handler: attributes["github_handler"],
+            created_by: attributes["created_by"],
+            meta_scope: attributes["meta_scope"]
+          )
+          @imported_assembly.remote_hero_image_url = attributes["remote_hero_image_url"] if remote_file_exists?(attributes["remote_hero_image_url"])
+          @imported_assembly.remote_banner_image_url = attributes["remote_banner_image_url"] if remote_file_exists?(attributes["remote_banner_image_url"])
+          @imported_assembly.save!
+          @imported_assembly
+        end
+      end
+
+      def import_assemblies_type(type_id)
+        return if Decidim::AssembliesType.find_by(id: type_id).nil?
+
+        @imported_assembly.decidim_assemblies_type_id = type_id
+      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_assembly
+          )
+          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_assembly
+            )
+          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"],
+              content_type: file_tmp.content_type,
+              attached_to: @imported_assembly,
+              weight: file["weight"],
+              file: form.file, # Define attached_to before this
+              file_size: file_tmp.size
+            )
+            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_assembly)
+        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_assembly
+        )
+        attachment_collection.save!
+        attachment_collection
+      end
+
+      def remote_file_exists?(url)
+        return if url.nil?
+
+        accepted = ["image", "application/pdf"]
+        url = URI.parse(url)
+        http_connection = Net::HTTP.new(url.host, url.port)
+        http_connection.use_ssl = true if url.scheme == "https"
+        http_connection.start do |http|
+          return http.head(url.request_uri)["Content-Type"].start_with?(*accepted)
+        end
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end

data/app/serializers/decidim/assemblies/assembly_serializer.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Assemblies
+    # This class serializes an Assembly so it can be exported to CSV, JSON or other formats.
+    class AssemblySerializer < Decidim::Exporters::Serializer
+      include Decidim::ApplicationHelper
+      include Decidim::ResourceHelper
+      include Decidim::TranslationsHelper
+
+      # Public: Initializes the serializer with a assembly.
+      def initialize(assembly)
+        @assembly = assembly
+      end
+
+      # Public: Exports a hash with the serialized data for this assembly.
+      def serialize
+        {
+          id: assembly.id,
+          slug: assembly.slug,
+          hashtag: assembly.hashtag,
+          decidim_organization_id: assembly.decidim_organization_id,
+          title: assembly.title,
+          subtitle: assembly.subtitle,
+          short_description: assembly.short_description,
+          description: assembly.description,
+          remote_hero_image_url: Decidim::Assemblies::AssemblyPresenter.new(assembly).hero_image_url,
+          remote_banner_image_url: Decidim::Assemblies::AssemblyPresenter.new(assembly).banner_image_url,
+          promoted: assembly.promoted,
+          developer_group: assembly.developer_group,
+          meta_scope: assembly.meta_scope,
+          local_area: assembly.local_area,
+          target: assembly.target,
+          decidim_scope_id: assembly.decidim_scope_id,
+          paticipatory_scope: assembly.participatory_scope,
+          participatory_structure: assembly.participatory_structure,
+          show_statistics: assembly.show_statistics,
+          scopes_enabled: assembly.scopes_enabled,
+          private_space: assembly.private_space,
+          reference: assembly.reference,
+          purpose_of_action: assembly.purpose_of_action,
+          composition: assembly.composition,
+          duration: assembly.duration,
+          participatory_scope: assembly.participatory_scope,
+          included_at: assembly.included_at,
+          closing_date: assembly.closing_date,
+          created_by: assembly.created_by,
+          creation_date: assembly.creation_date,
+          closing_date_reason: assembly.closing_date_reason,
+          internal_organisation: assembly.internal_organisation,
+          is_transparent: assembly.is_transparent,
+          special_features: assembly.special_features,
+          twitter_handler: assembly.twitter_handler,
+          instagram_handler: assembly.instagram_handler,
+          facebook_handler: assembly.facebook_handler,
+          youtube_handler: assembly.youtube_handler,
+          github_handler: assembly.github_handler,
+          created_by_other: assembly.created_by_other,
+          decidim_assemblies_type_id: assembly.decidim_assemblies_type_id,
+          area: {
+            id: assembly.area.try(:id),
+            name: assembly.area.try(:name) || empty_translatable
+          },
+          scope: {
+            id: assembly.scope.try(:id),
+            name: assembly.scope.try(:name) || empty_translatable
+          },
+
+          assembly_categories: serialize_categories,
+          attachments: {
+            attachment_collections: serialize_attachment_collections,
+            files: serialize_attachments
+          },
+          components: serialize_components
+        }
+      end
+
+      private
+
+      attr_reader :assembly
+
+      def serialize_categories
+        return unless assembly.categories.first_class.any?
+
+        assembly.categories.first_class.map do |category|
+          {
+            id: category.try(:id),
+            name: category.try(:name),
+            description: category.try(:description),
+            parent_id: category.try(:parent_id),
+            subcategories: serialize_subcategories(category.subcategories)
+          }
+        end
+      end
+
+      def serialize_subcategories(subcategories)
+        return unless subcategories.any?
+
+        subcategories.map do |subcategory|
+          {
+            id: subcategory.try(:id),
+            name: subcategory.try(:name),
+            description: subcategory.try(:description),
+            parent_id: subcategory.try(:parent_id)
+          }
+        end
+      end
+
+      def serialize_attachment_collections
+        return unless assembly.attachment_collections.any?
+
+        assembly.attachment_collections.map do |collection|
+          {
+            id: collection.try(:id),
+            name: collection.try(:name),
+            weight: collection.try(:weight),
+            description: collection.try(:description)
+          }
+        end
+      end
+
+      def serialize_attachments
+        return unless assembly.attachments.any?
+
+        assembly.attachments.map do |attachment|
+          {
+            id: attachment.try(:id),
+            title: attachment.try(:title),
+            weight: attachment.try(:weight),
+            description: attachment.try(:description),
+            attachment_collection: {
+              name: attachment.attachment_collection.try(:name),
+              weight: attachment.attachment_collection.try(:weight),
+              description: attachment.attachment_collection.try(:description)
+            },
+            remote_file_url: Decidim::AttachmentPresenter.new(attachment).attachment_file_url
+          }
+        end
+      end
+
+      def serialize_components
+        serializer = Decidim::Exporters::ParticipatorySpaceComponentsSerializer.new(@assembly)
+        serializer.serialize
+      end
+    end
+  end
+end