decidim-core 0.20.1 → 0.21.0

data/app/presenters/decidim/home_stats_presenter.rb

@@ -49,7 +49,7 @@ module Decidim
     private
 
     def global_stats(conditions)
-      Decidim.stats.except([:users_count, :processes_count])
+      Decidim.stats.except([:users_count, :processes_count, :followers_count])
              .filter(conditions)
              .with_context(organization)
              .map { |name, data| [name, data] }
@@ -57,7 +57,10 @@ module Decidim
 
     def component_stats(conditions)
       Decidim.component_manifests.flat_map do |component|
-        component.stats.filter(conditions).with_context(published_components).map { |name, data| [name, data] }
+        component.stats.except([:supports_count])
+                 .filter(conditions)
+                 .with_context(published_components)
+                 .map { |name, data| [name, data] }
       end
     end
 

data/app/presenters/decidim/resource_locator_presenter.rb

@@ -47,6 +47,15 @@ module Decidim
       admin_collection_route("path", options)
     end
 
+    # Builds the admin show path to the resource.
+    #
+    # options - An optional hash of options to pass to the Rails router
+    #
+    # Returns a String.
+    def show(options = {})
+      admin_route_proxy.send("#{member_route_name}_path", resource, options)
+    end
+
     # Builds the admin edit path to the resource.
     #
     # options - An optional hash of options to pass to the Rails router

data/app/serializers/decidim/exporters/participatory_space_components_serializer.rb

@@ -23,7 +23,7 @@ module Decidim
             name: component.name,
             participatory_space_id: component.participatory_space_id,
             participatory_space_type: component.participatory_space_type,
-            settings: component.settings.as_json,
+            settings: component[:settings].as_json,
             weight: component.weight,
             permissions: component.permissions,
             published_at: component.published_at

data/app/serializers/decidim/importers/participatory_space_components_importer.rb

@@ -33,10 +33,10 @@ module Decidim
       def import(json_ary, user)
         ActiveRecord::Base.transaction do
           json_ary.collect do |serialized|
-            attributes = serialized.with_indifferent_access
-            # we override the parent participatory sapce
-            attributes["participatory_space_id"] = @participatory_space.id
-            attributes["participatory_space_type"] = @participatory_space.class.name
+            attributes = serialized.with_indifferent_access.except(:id, :participatory_space_id, :participatory_space_type)
+            step_settings = attributes["settings"]["steps"]
+            # we override the parent participatory space steps id
+            override_step_settings_ids(attributes, step_settings)
             import_component_from_attributes(attributes, user)
           end
         end
@@ -49,7 +49,7 @@ module Decidim
         component = Decidim.traceability.perform_action!(:create,
                                                          Decidim::Component,
                                                          user) do
-          c = Decidim::Component.new(attributes.except(:id, :settings, :specific_data))
+          c = Decidim::Component.new({ participatory_space: @participatory_space }.merge(attributes.except(:settings, :specific_data)))
           c[:settings] = attributes[:settings]
           c.save!
           c
@@ -62,6 +62,15 @@ module Decidim
         specific_importer = component.manifest.specific_data_importer_class.new(component)
         specific_importer.import(serialized[:specific_data], user)
       end
+
+      def override_step_settings_ids(attributes, step_settings)
+        return if step_settings.nil?
+
+        @participatory_space.steps.each do |step|
+          old_id = attributes["settings"]["steps"].keys.first
+          step_settings[step.id.to_s] = step_settings.delete(old_id)
+        end
+      end
     end
   end
 end

data/app/services/decidim/data_portability_exporter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "seven_zip_ruby"
+require_relative "zip_stream/zip_stream_writer"
+
+module Decidim
+  # Public: Generates a 7z(seven zip) file with data files ready to be persisted
+  # somewhere so users can download their data.
+  #
+  # In fact, the 7z file wraps a ZIP file which finally contains the data files.
+  class DataPortabilityExporter
+    include ::Decidim::ZipStream::Writer
+
+    DEFAULT_EXPORT_FORMAT = "CSV"
+    ZIP_FILE_NAME = "data-portability.zip"
+
+    # Public: Initializes the class.
+    #
+    # user          - The user to export the data from.
+    # path          - The String path where to write the zip file.
+    # password      - The password to protect the zip file.
+    # export_format - The format of the data files inside the zip file. (CSV by default)
+    def initialize(user, path, password, export_format = DEFAULT_EXPORT_FORMAT)
+      @user = user
+      @path = File.expand_path path
+      @export_format = export_format
+      @password = password
+    end
+
+    def export
+      dirname = File.dirname(@path)
+      FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+      File.open(@path, "wb") do |file|
+        SevenZipRuby::Writer.open(file, password: @password) do |szw|
+          szw.header_encryption = true
+          szw.add_data(data, ZIP_FILE_NAME)
+        end
+      end
+    end
+
+    private
+
+    def data
+      buffer = Zip::OutputStream.write_buffer do |out|
+        user_data, attachments = data_for(@user, @export_format)
+
+        add_user_data_to_zip_stream(out, user_data)
+        add_attachments_to_zip_stream(out, attachments)
+      end
+
+      buffer.string
+    end
+
+    def data_for(user, format)
+      export_data = []
+      export_attachments = []
+
+      data_portability_entities.each do |object|
+        klass = Object.const_get(object)
+        export_data << [klass.model_name.name.parameterize.pluralize, Exporters.find_exporter(format).new(klass.user_collection(user), klass.export_serializer).export]
+        attachments = klass.data_portability_images(user)
+        export_attachments << [klass.model_name.name.parameterize.pluralize, attachments.flatten] unless attachments.nil?
+      end
+
+      [export_data, export_attachments]
+    end
+
+    def data_portability_entities
+      @data_portability_entities ||= DataPortabilitySerializers.data_entities
+    end
+  end
+end

data/app/services/decidim/resource_search.rb

@@ -25,24 +25,24 @@ module Decidim
 
     # Handle the category_id filter
     def search_category_id
+      return query if category_ids.include?("all")
+
       query
         .includes(:categorization)
-        .where(decidim_categorizations: { decidim_category_id: category_ids })
+        .where(decidim_categorizations: { decidim_category_id: all_category_ids })
     end
 
-    # Handles the scope_id filter. When we want to show only those that do not
-    # have a scope_id set, we cannot pass an empty String or nil because Searchlight
+    # Handles the scope_ids filter. When we want to show only those that do not
+    # have a scope_ids set, we cannot pass an empty String or nil because Searchlight
     # will automatically filter out these params, so the method will not be used.
     # Instead, we need to pass a fake ID and then convert it inside. In this case,
-    # in order to select those elements that do not have a scope_id set we use
+    # in order to select those elements that do not have a scope_ids set we use
     # `"global"` as parameter, and in the method we do the needed changes to search
     # properly.
     def search_scope_id
-      clean_scope_ids = if scope_id.is_a?(Hash)
-                          scope_id.values
-                        else
-                          [scope_id].flatten
-                        end
+      return query if scope_ids.include?("all")
+
+      clean_scope_ids = scope_ids
 
       conditions = []
       conditions << "#{query.model_name.plural}.decidim_scope_id IS NULL" if clean_scope_ids.delete("global")
@@ -55,12 +55,28 @@ module Decidim
 
     # Private: Creates an array of category ids.
     # It contains categories' subcategories ids as well.
-    def category_ids
+    def all_category_ids
+      cat_ids = category_ids.without("without")
+
       component
         .categories
-        .where(id: category_id)
-        .or(component.categories.where(parent_id: category_id))
-        .pluck(:id)
+        .where(id: cat_ids)
+        .or(component.categories.where(parent_id: cat_ids))
+        .pluck(:id).tap { |ids| ids.prepend(nil) if category_ids.include?("without") }
+    end
+
+    # Private: Returns an array with checked category ids.
+    def category_ids
+      [category_id].flatten
+    end
+
+    # Private: Returns an array with checked scope ids.
+    def scope_ids
+      if scope_id.is_a?(Hash)
+        scope_id.values
+      else
+        [scope_id].flatten
+      end
     end
 
     # Private: Since component is not used by a search method we need

data/app/services/decidim/zip_stream/zip_stream_writer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ZipStream
+    module Writer
+      def add_user_data_to_zip_stream(out, user_data)
+        user_data.each do |element|
+          filename_file = element.last.filename(element.first.parameterize)
+
+          out.put_next_entry(filename_file)
+          if element.last.read.presence
+            out.write element.last.read
+          else
+            out.write "No data"
+          end
+        end
+      end
+
+      def add_attachments_to_zip_stream(out, export_attachments)
+        export_attachments.each do |attachment_block|
+          next if attachment_block.last.nil?
+
+          folder_name = attachment_block.first.parameterize
+          attachment_block.last.each do |attachment_uploader|
+            next if attachment_uploader.file.nil?
+
+            case attachment_uploader.fog_provider
+            when "fog" # file system
+              next unless File.exist?(attachment_uploader.file.file)
+            when "fog/aws"
+              cache_attachment_from_aws(attachment_uploader)
+            else
+              Rails.logger.info "Carrierwave fog_provider not supported by DataPortabilityExporter for attachment: #{attachment_uploader}"
+              next
+            end
+
+            attachment_local_path = attachment_uploader.file.file
+            out.put_next_entry("#{folder_name}/#{attachment_uploader.file.filename}")
+            File.open(attachment_local_path) do |f|
+              out << f.read
+            end
+            CarrierWave.clean_cached_files!
+          end
+        end
+      end
+
+      # Retrieves the file from AWS and stores it into a temporal cache.
+      # Once the file is cached, the uploader returns a local `CarrierWave::SanitizedFile`
+      # instead of a fog file that acts as a proxy to the remote file.
+      def cache_attachment_from_aws(uploader)
+        uploader.cache_stored_file!
+        uploader.retrieve_from_cache!(uploader.cache_name)
+      end
+    end
+  end
+end

data/app/types/decidim/core/amendment_type.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    AmendmentType = GraphQL::ObjectType.define do
+      name "Amendment"
+      description "An amendment"
+
+      field :id, !types.ID, "The id of this amendment"
+      field :state, !types.String, "The status of this amendment"
+      field :amender, !Decidim::Core::AuthorInterface, "The author of this amendment"
+
+      field :amendableType, !types.String do
+        description "Type of the amendable object"
+        property :decidim_amendable_type
+      end
+      field :emendationType, !types.String do
+        description "Type of the emendation object"
+        property :decidim_emendation_type
+      end
+
+      field :amendable, !AmendableEntityInterface, "The original amended resource (currently, a proposal only)"
+      field :emendation, !AmendableEntityInterface, "The emendation (currently, a proposal only)"
+    end
+  end
+end

data/app/types/decidim/core/area_api_type.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    AreaApiType = GraphQL::ObjectType.define do
+      name "Area"
+      description "An area."
+
+      field :id, !types.ID, "Internal ID for this area"
+      field :name, !TranslatedFieldType, "The name of this area."
+      field :areaType, Decidim::Core::AreaTypeType, "The area type of this area", property: :area_type
+      field :createdAt, !Decidim::Core::DateTimeType, "The time this assembly was created", property: :created_at
+      field :updatedAt, !Decidim::Core::DateTimeType, "The time this assembly was updated", property: :updated_at
+    end
+  end
+end

data/app/types/decidim/core/area_type_type.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    AreaTypeType = GraphQL::ObjectType.define do
+      name "AreaType"
+      description "An area type."
+
+      field :id, !types.ID, "Internal ID for this area type"
+      field :name, !TranslatedFieldType, "The name of this area type."
+      field :plural, !TranslatedFieldType, "The plural name of this area type"
+    end
+  end
+end

data/app/types/decidim/core/base_input_filter.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    class BaseInputFilter < GraphQL::Schema::InputObject
+    end
+  end
+end

data/app/types/decidim/core/base_input_sort.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    class BaseInputSort < GraphQL::Schema::InputObject
+      # Overwrite the prepare method to allow 2 possible values only
+      def prepare
+        arguments.each do |key, value|
+          next if key == "locale"
+          raise GraphQL::ExecutionError, "Invalid order value for #{key}, only ASC or DESC are valids" unless valid_order?(value)
+        end
+        super
+      end
+
+      private
+
+      def valid_order?(order)
+        %w(asc desc).include? order.downcase
+      end
+    end
+  end
+end

data/app/types/decidim/core/component_input_filter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    class ComponentInputFilter < BaseInputFilter
+      include HasPublishableInputFilter
+      include HasLocalizedInputFilter
+
+      graphql_name "ComponentFilter"
+      description "A type used for filtering any component parent objects"
+
+      argument :type,
+               type: String,
+               description: "Filters by type of component",
+               required: false,
+               prepare: ->(value, _ctx) do
+                 { manifest_name: value.downcase }
+               end
+      argument :name,
+               type: String,
+               description: "Filters by name of the component, additional locale parameter can be provided to specify in which to search",
+               required: false,
+               prepare: ->(search, ctx) do
+                          proc do |model_class, locale|
+                            locale = ctx[:current_organization].default_locale if locale.blank?
+                            op = Arel::Nodes::InfixOperation.new("->>", model_class.arel_table[:name], Arel::Nodes.build_quoted(locale))
+                            op.matches("%#{search}%")
+                          end
+                        end
+      argument :with_geolocation_enabled,
+               type: Boolean,
+               description: "Returns components with geolocation activated (may be Proposals or Meetings)",
+               required: false,
+               prepare: ->(active, _ctx) do
+                 proc do |_model_class|
+                   ["(settings->'global'->>'geocoding_enabled')::boolean is ? or manifest_name='meetings'", active]
+                 end
+               end
+      argument :with_comments_enabled,
+               type: Boolean,
+               description: "Returns components with comments enabled globally (can still be deactivated in the current step if the component has steps)",
+               required: false,
+               prepare: ->(active, _ctx) do
+                 proc do |_model_class|
+                   ["(settings->'global'->>'comments_enabled')::boolean is ?", active]
+                 end
+               end
+    end
+  end
+end

data/app/types/decidim/core/component_input_sort.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Core
+    class ComponentInputSort < BaseInputSort
+      include HasLocalizedInputSort
+
+      graphql_name "ComponentSort"
+      description "A type used for sorting any component parent objects"
+
+      argument :id, String, "Sort by ID, valid values are ASC or DESC", required: false
+      argument :weight, String, "Sort by weight (order in the website), valid values are ASC or DESC", required: false
+      argument :type,
+               type: String,
+               description: "Sort by type of component, alphabetically, valid values are ASC or DESC",
+               required: false,
+               prepare: ->(direction, _ctx) do
+                 { manifest_name: direction }
+               end
+      argument :name,
+               type: String,
+               description: "Sort by name of the component, alphabetically, valid values are ASC or DESC",
+               required: false,
+               prepare: ->(direction, ctx) do
+                          proc do |locale|
+                            locale = ctx[:current_organization].default_locale if locale.blank?
+                            [Arel.sql("name->? #{direction.upcase}"), locale]
+                          end
+                        end
+    end
+  end
+end