decidim-assemblies 0.20.1 → 0.23.1

data/app/models/decidim/assembly_user_role.rb

@@ -11,7 +11,7 @@ module Decidim
     belongs_to :assembly, foreign_key: "decidim_assembly_id", class_name: "Decidim::Assembly", optional: true
     alias participatory_space assembly
 
-    ROLES = %w(admin collaborator moderator).freeze
+    ROLES = %w(admin collaborator moderator valuator).freeze
     validates :role, inclusion: { in: ROLES }, uniqueness: { scope: [:user, :assembly] }
     validate :user_and_assembly_same_organization
 

data/app/permissions/decidim/assemblies/permissions.rb

@@ -30,16 +30,20 @@ module Decidim
         return permission_action unless permission_action.scope == :admin
 
         user_can_read_assembly_list?
+        user_can_list_assembly_list?
         user_can_read_current_assembly?
         user_can_create_assembly?
+        user_can_read_assemblies_setting?
 
         # org admins and space admins can do everything in the admin section
         org_admin_action?
+        assemblies_type_action?
 
         return permission_action unless assembly
 
         moderator_action?
         collaborator_action?
+        valuator_action?
         assembly_admin_action?
 
         permission_action
@@ -47,6 +51,21 @@ module Decidim
 
       private
 
+      def assemblies_type_action?
+        return unless [:assembly_type, :assemblies_type].include? permission_action.subject
+        return disallow! unless user.admin?
+
+        assembly_type = context.fetch(:assembly_type, nil)
+        case permission_action.action
+        when :destroy
+          assemblies_is_empty = assembly_type && assembly_type.assemblies.empty?
+
+          toggle_allow(assemblies_is_empty)
+        else
+          allow!
+        end
+      end
+
       # It's an admin user if it's an organization admin or is a space admin
       # for the current `assembly`.
       def admin_user?
@@ -148,6 +167,13 @@ module Decidim
         toggle_allow(user.admin?)
       end
 
+      def user_can_read_assemblies_setting?
+        return unless permission_action.action == :read &&
+                      permission_action.subject == :assemblies_setting
+
+        toggle_allow(user.admin?)
+      end
+
       # Everyone can read the assembly list
       def user_can_read_assembly_list?
         return unless read_assembly_list_permission_action?
@@ -155,6 +181,25 @@ module Decidim
         toggle_allow(user.admin? || has_manageable_assemblies?)
       end
 
+      # Checks whether the user can list the current given assembly or not.
+      #
+      # In case of user being admin of child assembly even parent assembly
+      # should be listed to be able to navigate to child assembly
+      def user_can_list_assembly_list?
+        return unless permission_action.action == :list &&
+                      permission_action.subject == :assembly
+
+        toggle_allow(user.admin? || allowed_list_of_assemblies?)
+      end
+
+      def allowed_list_of_assemblies?
+        assemblies = AssembliesWithUserRole.for(user)
+        parent_assemblies = assemblies.flat_map { |assembly| [assembly.id] + assembly.ancestors.pluck(:id) }
+
+        allowed_list_of_assemblies = Decidim::Assembly.where(id: assemblies + parent_assemblies)
+        allowed_list_of_assemblies.uniq.member?(assembly)
+      end
+
       def user_can_read_current_assembly?
         return unless read_assembly_list_permission_action?
         return if permission_action.subject == :assembly_list
@@ -177,6 +222,14 @@ module Decidim
         allow! if permission_action.action == :read || permission_action.action == :preview
       end
 
+      # Valuators can only read the assembly components
+      def valuator_action?
+        return unless can_manage_assembly?(role: :valuator)
+
+        allow! if permission_action.action == :read && permission_action.subject == :component
+        allow! if permission_action.action == :export && permission_action.subject == :component_data
+      end
+
       # Process admins can perform everything *inside* that assembly. They cannot
       # create a assembly or perform actions on assembly groups or other
       # assemblies.
@@ -196,7 +249,9 @@ module Decidim
           :assembly,
           :assembly_user_role,
           :assembly_member,
-          :space_private_user
+          :space_private_user,
+          :export_space,
+          :import
         ].include?(permission_action.subject)
         allow! if is_allowed
       end
@@ -214,7 +269,10 @@ module Decidim
           :assembly,
           :assembly_user_role,
           :assembly_member,
-          :space_private_user
+          :space_private_user,
+          :export_space,
+          :import,
+          :assemblies_setting
         ].include?(permission_action.subject)
         allow! if is_allowed
       end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Assemblies
+    module AdminLog
+      # This class holds the logic to present a `Decidim::AssembliesType`
+      # 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
+      #    AssembliesTypePresenter.new(action_log, view_helpers).present
+      class AssembliesTypePresenter < Decidim::Log::BasePresenter
+        private
+
+        def diff_fields_mapping
+          {
+            title: :i18n
+          }
+        end
+
+        def i18n_labels_scope
+          "activemodel.attributes.assemblies_type"
+        end
+
+        def action_string
+          case action
+          when "create", "delete", "update"
+            "decidim.admin_log.assembly_type.#{action}"
+          else
+            super
+          end
+        end
+
+        def has_diff?
+          action == "delete" || super
+        end
+      end
+    end
+  end
+end

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

@@ -37,8 +37,7 @@ module Decidim
             target: :i18n,
             title: :i18n,
             purpose_of_action: :i18n,
-            assembly_type: :string,
-            assembly_type_other: :i8n,
+            decidim_assemblies_type_id: :assembly_type,
             creation_date: :date,
             created_by: :string,
             created_by_other: :i18n,

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/presenters/decidim/log/value_types/assembly_type_presenter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Log
+    module ValueTypes
+      # This class presents the given value as a Decidim::AssembliesType. Check
+      # the `DefaultPresenter` for more info on how value
+      # presenters work.
+      class AssemblyTypePresenter < DefaultPresenter
+        # Public: Presents the value as a Decidim::AssembliesType. If the type can
+        # be found, it shows its title. Otherwise it shows its ID.
+        #
+        # Returns an HTML-safe String.
+        def present
+          return unless value
+          return h.translated_attribute(type.title) if type
+
+          I18n.t("not_found", id: value, scope: "decidim.log.value_types.assembly_type_presenter")
+        end
+
+        private
+
+        def type
+          @type ||= Decidim::AssembliesType.find_by(id: value)
+        end
+      end
+    end
+  end
+end

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

@@ -13,9 +13,9 @@ module Decidim
       end
 
       def query
-        return assemblies.all if @filter == "all"
+        return assemblies.all if @filter.blank?
 
-        assemblies.where(assembly_type: @filter)
+        assemblies.where(decidim_assemblies_type_id: @filter)
       end
     end
   end

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Assemblies
+    # This query filters assemblies that can be assigned as parents for an assembly.
+    class ParentAssembliesForSelect < Rectify::Query
+      # Syntactic sugar to initialize the class and return the queried objects.
+      def self.for(organization, assembly)
+        new(organization, assembly).query
+      end
+
+      # Initializes the class.
+      def initialize(organization, assembly)
+        @organization = organization
+        @assembly = assembly
+      end
+
+      # Finds the available assemblies
+      #
+      # Returns an ActiveRecord::Relation.
+      def query
+        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
+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