decidim-core 0.29.2 → 0.30.0.rc2

data/lib/decidim/record_encryptor.rb

@@ -53,54 +53,59 @@ module Decidim
         #   def name=(value)
         #     super(encrypt_value(value))
         #   end
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-
-          # def full_name
-          #   return @full_name_decrypted if instance_variable_defined?(:@full_name_decrypted)
-          #
-          #   encrypted_value = begin
-          #     if defined?(super)
-          #       super
-          #     elsif instance_variable_defined?(:@full_name)
-          #       @full_name
-          #     end
-          #   end
-          #   @full_name_decrypted = decrypt_value(encrypted_value)
-          # end
-          def #{attribute}
-            return @#{attribute}_decrypted if instance_variable_defined?(:@#{attribute}_decrypted)
-
-            encrypted_value = begin
-              if defined?(super)
-                super
-              elsif instance_variable_defined?(:@#{attribute})
-                @#{attribute}
-              end
-            end
-            @#{attribute}_decrypted = decrypt_#{method_suffix}(encrypted_value)
-          end
+        create_encrypted_getter(attribute, method_suffix)
+        create_encrypted_setter(attribute, method_suffix)
+      end
+
+      # def full_name
+      #   return @full_name_decrypted if instance_variable_defined?(:@full_name_decrypted)
+      #
+      #   encrypted_value = begin
+      #     if defined?(super)
+      #       super
+      #     elsif instance_variable_defined?(:@full_name)
+      #       @full_name
+      #     end
+      #   end
+      #   @full_name_decrypted = decrypt_value(encrypted_value)
+      # end
+      def create_encrypted_getter(attribute, method_suffix)
+        define_method(attribute) do
+          return instance_variable_get(:"@#{attribute}_decrypted") if instance_variable_defined?(:"@#{attribute}_decrypted")
+
+          encrypted_value = if defined?(super)
+                              super()
+                            elsif instance_variable_defined?(:"@#{attribute}")
+                              instance_variable_get(:"@#{attribute}")
+                            end
+
+          decrypted_value = send(:"decrypt_#{method_suffix}", encrypted_value)
+          instance_variable_set(:"@#{attribute}_decrypted", decrypted_value)
+        end
+      end
 
-          # def full_name=(value)
-          #   remove_instance_variable(:@full_name_decrypted) if instance_variable_defined?(:@full_name_decrypted)
-          #   encrypted_value = encrypt_value(value)
-          #
-          #   if defined?(super)
-          #     super(encrypted_value)
-          #   else
-          #     @full_name = encrypted_value
-          #   end
-          # end
-          def #{attribute}=(value)
-            remove_instance_variable(:@#{attribute}_decrypted) if instance_variable_defined?(:@#{attribute}_decrypted)
-            encrypted_value = encrypt_#{method_suffix}(value)
-
-            if defined?(super)
-              super(encrypted_value)
-            else
-              @#{attribute} = encrypted_value
-            end
+      # def full_name=(value)
+      #   remove_instance_variable(:@full_name_decrypted) if instance_variable_defined?(:@full_name_decrypted)
+      #   encrypted_value = encrypt_value(value)
+      #
+      #   if defined?(super)
+      #     super(encrypted_value)
+      #   else
+      #     @full_name = encrypted_value
+      #   end
+      # end
+      def create_encrypted_setter(attribute, method_suffix)
+        define_method("#{attribute}=") do |value|
+          remove_instance_variable(:"@#{attribute}_decrypted") if instance_variable_defined?(:"@#{attribute}_decrypted")
+
+          encrypted_value = send(:"encrypt_#{method_suffix}", value)
+
+          if defined?(super)
+            super(encrypted_value)
+          else
+            instance_variable_set(:"@#{attribute}", encrypted_value)
           end
-        RUBY
+        end
       end
     end
 

data/lib/decidim/resourceable.rb

@@ -50,6 +50,22 @@ module Decidim
         scope.where(id: from).or(scope.where(id: to))
       end
 
+      def linked_resources_from(resource_name, link_name, component_published: true)
+        scope = sibling_scope(resource_name, component_published:)
+
+        scope
+          .joins(:resource_links_from)
+          .where(decidim_resource_links: { name: link_name, to_id: id, to_type: self.class.name })
+      end
+
+      def linked_resources_to(resource_name, link_name, component_published: true)
+        scope = sibling_scope(resource_name, component_published:)
+
+        scope
+          .joins(:resource_links_to)
+          .where(decidim_resource_links: { name: link_name, from_id: id, from_type: self.class.name })
+      end
+
       # Builds an ActiveRecord::Relation in order to load all the resources
       # that are in the same parent as this model.
       #

data/lib/decidim/seeds.rb

@@ -21,7 +21,7 @@ module Decidim
       user = Decidim::User.find_or_initialize_by(email:)
       user.update!(
         name: ::Faker::Name.name,
-        nickname: ::Faker::Twitter.unique.screen_name,
+        nickname: "#{::Faker::Twitter.unique.screen_name}-#{rand(10_000)}"[0...20],
         password: "decidim123456789",
         organization:,
         confirmed_at: Time.current,
@@ -38,18 +38,6 @@ module Decidim
       user
     end
 
-    def random_scope(participatory_space:)
-      if participatory_space.scope
-        scopes = participatory_space.scope.descendants
-        global = participatory_space.scope
-      else
-        scopes = participatory_space.organization.scopes
-        global = nil
-      end
-
-      ::Faker::Boolean.boolean(true_ratio: 0.5) ? global : scopes.sample
-    end
-
     def seeds_root = File.join(__dir__, "..", "..", "db", "seeds")
 
     def hero_image = create_blob!(seeds_file: "city.jpeg", filename: "hero_image.jpeg", content_type: "image/jpeg")
@@ -97,13 +85,23 @@ module Decidim
       )
     end
 
-    def create_category!(participatory_space:)
-      Decidim::Category.create!(
-        name: Decidim::Faker::Localized.sentence(word_count: 5),
-        description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-          Decidim::Faker::Localized.paragraph(sentence_count: 3)
-        end,
-        participatory_space:
+    def create_taxonomy!(name:, parent:)
+      Decidim::Taxonomy.create!(
+        name: Decidim::Faker::Localized.literal(name),
+        organization:,
+        parent:
+      )
+    end
+
+    def create_taxonomy_filter!(root_taxonomy:, taxonomies:, participatory_space_manifests: [])
+      Decidim::TaxonomyFilter.create!(
+        root_taxonomy:,
+        participatory_space_manifests:,
+        filter_items: taxonomies.map do |taxonomy_item|
+          Decidim::TaxonomyFilterItem.new(
+            taxonomy_item:
+          )
+        end
       )
     end
 

data/lib/decidim/settings_manifest.rb

@@ -70,6 +70,8 @@ module Decidim
             validates name, presence: true if attribute.required
             validates name, inclusion: { in: attribute.build_choices } if attribute.type == :enum
           end
+
+          SettingsManifest.add_integer_with_units_validation(self, name, attribute) if attribute.type == :integer_with_units
         end
       end
 
@@ -77,6 +79,20 @@ module Decidim
       @schema
     end
 
+    def self.add_integer_with_units_validation(schema, name, attribute)
+      schema.class_eval do
+        validate do
+          value = send(name)
+          value = [value["0"].to_i, value["1"].to_s] if value.is_a?(::Hash)
+
+          errors.add(name, :invalid) unless value.is_a?(::Array) &&
+                                            value.size == 2 &&
+                                            value[0].is_a?(Integer) &&
+                                            attribute.build_units.include?(value[1])
+        end
+      end
+    end
+
     def required_attributes_for_authorization
       attributes.select { |_, attribute| attribute.required_for_authorization? }
     end
@@ -91,6 +107,7 @@ module Decidim
       TYPES = {
         boolean: { klass: Boolean, default: false },
         integer: { klass: Integer, default: 0 },
+        integer_with_units: { klass: Decidim::Attributes::IntegerWithUnits, default: [5, "minutes"] },
         string: { klass: String, default: nil },
         float: { klass: Float, default: nil },
         text: { klass: String, default: nil },
@@ -98,7 +115,8 @@ module Decidim
         enum: { klass: String, default: nil },
         select: { klass: String, default: nil },
         scope: { klass: Integer, default: nil },
-        time: { klass: Decidim::Attributes::TimeWithZone, default: nil }
+        time: { klass: Decidim::Attributes::TimeWithZone, default: nil },
+        taxonomy_filters: { klass: Array, default: [] }
       }.freeze
 
       attribute :type, Symbol, default: :boolean
@@ -111,9 +129,20 @@ module Decidim
       attribute :required_for_authorization, Boolean, default: false
       attribute :readonly
       attribute :choices
+      attribute :units
       attribute :include_blank, Boolean, default: false
 
       validates :type, inclusion: { in: TYPES.keys }
+      validate :validate_integer_with_units_structure
+
+      def validate_integer_with_units_structure
+        return unless type == :integer_with_units
+
+        errors.add(:default, :invalid) unless default_value.is_a?(::Array) &&
+                                              default_value.size == 2 &&
+                                              default_value[0].is_a?(Integer) &&
+                                              build_units.include?(default_value[1])
+      end
 
       def type_class
         return Decidim::Attributes::RichText if type == :text && editor == true
@@ -129,6 +158,10 @@ module Decidim
         choices.try(:call) || choices
       end
 
+      def build_units
+        units.try(:call) || units
+      end
+
       def readonly?(context)
         readonly&.call(context)
       end

data/lib/decidim/soft_deletable.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+require "paranoia"
+
+module Decidim
+  # This concern contains the logic related to soft deletion (trashing).
+  module SoftDeletable
+    extend ActiveSupport::Concern
+
+    included do
+      acts_as_paranoid
+
+      scope :deleted_at_desc, -> { order(deleted_at: :desc) }
+    end
+  end
+end

data/lib/decidim/taxonomizable.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Decidim
+  # A concern with the components needed when you want a model to have taxonomies.
+  #
+  # The including model needs to implement the following interface:
+  #
+  #  @abstract  method that gives an associated organization
+  #  @method organization
+  #    @return [Decidim::Organization]
+  #
+  module Taxonomizable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :taxonomizations, as: :taxonomizable, class_name: "Decidim::Taxonomization", dependent: :destroy
+      has_many :taxonomies, through: :taxonomizations
+
+      validate :no_root_taxonomies
+      validate :taxonomies_belong_to_organization
+
+      # finds taxonomizables belonging to a specific taxonomy
+      scope :with_taxonomy, ->(taxonomy_id) { includes(:taxonomies).references(:decidim_taxonomies).where("? = ANY(decidim_taxonomies.part_of)", taxonomy_id) }
+
+      # finds taxonomizables belonging to any of the taxonomies specified (or its children)
+      scope :with_taxonomies, lambda { |*taxonomy_ids|
+        conditions = ["? = ANY(part_of)"] * taxonomy_ids.count
+        taxonomies = Decidim::Taxonomy.where(conditions.join(" OR "), *taxonomy_ids.map(&:to_i))
+        includes(:taxonomies).joins(:taxonomies).where(decidim_taxonomies: { id: taxonomies })
+      }
+
+      # finds taxonomizables belonging to all groups of taxonomies specified, each group is an array of taxonomy ids that are ORed together
+      scope :with_any_taxonomies, lambda { |*taxonomy_groups|
+        return with_taxonomies(*taxonomy_groups) unless taxonomy_groups.first.is_a?(Array)
+
+        queries = []
+        taxonomy_groups.each do |root_id, taxonomy_ids|
+          taxonomy_ids = taxonomy_ids.flatten.compact_blank
+          next if taxonomy_ids.empty?
+
+          taxonomy_ids = [root_id] if taxonomy_ids.include?("all")
+
+          queries << with_taxonomies(*taxonomy_ids)
+        end
+        return self if queries.empty?
+        return queries.first if queries.count == 1
+
+        subquery = queries.map(&:arel).reduce do |memo, query|
+          Arel::Nodes::Intersect.new(memo, query)
+        end
+
+        @klass.from(Arel::Nodes::As.new(subquery, Arel.sql(@klass.arel_table.name)))
+      }
+
+      private
+
+      def no_root_taxonomies
+        return unless taxonomies.any?(&:root?)
+
+        errors.add(:taxonomies, :invalid)
+      end
+
+      def taxonomies_belong_to_organization
+        return if taxonomies.all? { |taxonomy| taxonomy.organization == organization }
+
+        errors.add(:taxonomies, :invalid)
+      end
+    end
+  end
+end

data/lib/decidim/view_model.rb

@@ -8,7 +8,6 @@ module Decidim
     include ActionView::Helpers::TranslationHelper
     include ::Cell::Translation
     include Decidim::ResourceHelper
-    include Decidim::ScopesHelper
     include ActionController::Helpers
     include Decidim::ActionAuthorization
     include Decidim::ActionAuthorizationHelper

data/lib/tasks/decidim_download_your_data_tasks.rake

@@ -64,7 +64,7 @@ namespace :decidim do
     input = $stdin.gets.chomp
     if input.casecmp("y").zero?
       puts %(  Continue...)
-      Decidim::User.where("newsletter_notifications_at < ?", Time.zone.parse("2018-05-25 00:00 +02:00")).find_each(&:newsletter_opt_in_notify)
+      Decidim::User.where(newsletter_notifications_at: ...Time.zone.parse("2018-05-25 00:00 +02:00")).find_each(&:newsletter_opt_in_notify)
     else
       puts %(  Execution cancelled...)
     end
@@ -76,9 +76,7 @@ namespace :decidim do
     attachments = ActiveStorage::Attachment.joins(:blob).where(
       name: "download_your_data_file",
       record_type: "Decidim::UserBaseEntity"
-    ).where(
-      "active_storage_blobs.created_at < ?", Decidim.download_your_data_expiry_time.ago
-    )
+    ).where(active_storage_blobs: { created_at: ...Decidim.download_your_data_expiry_time.ago })
     attachments.each do |attachment|
       delete_download_your_data_file attachment
     end

data/lib/tasks/decidim_procfile.rake

@@ -11,6 +11,12 @@ namespace :decidim do
         shakapacker: bin/shakapacker-dev-server
       RUBY
 
+      if defined?(Sidekiq)
+        actions :append_file, "Procfile.dev", <<~RUBY
+          sidekiq: bundle exec sidekiq -C config/sidekiq.yml
+        RUBY
+      end
+
       actions :create_file, "bin/dev", %(#!/usr/bin/env sh
 
 set -e

data/lib/tasks/decidim_tasks.rake

@@ -6,6 +6,7 @@ namespace :decidim do
     :choose_target_plugins,
     :"decidim:upgrade_app",
     :"railties:install:migrations",
+    :"decidim:upgrade:migrations",
     :"decidim:upgrade:webpacker",
     :"decidim_api:generate_docs"
   ]

data/lib/tasks/decidim_taxonomies.rake

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "decidim/maintenance"
+
+namespace :decidim do
+  namespace :taxonomies do
+    desc "Creates a JSON file with the taxonomies structure imported from older models"
+    task :make_plan, [] => :environment do |_task, _args|
+      Decidim::Organization.find_each do |organization|
+        log(true).info "Creating a plan for organization #{organization.id} in #{plan_file_path(organization)}"
+        FileUtils.mkdir_p(Rails.root.join("tmp/taxonomies"))
+        json = planner(organization).to_json do |model|
+          log.info "...Exporting taxonomies for #{model.table_name}"
+        end
+        File.write(plan_file_path(organization), json)
+        log.info "Plan created, you can review or edit if needed before importing."
+        log.info "Import the plan with this command:"
+        log.info "bin/rails decidim:taxonomies:import_plan[#{plan_file_path(organization)}]"
+      end
+    end
+
+    desc "Imports taxonomies and filters structure from a JSON file"
+    task :import_plan, [:file] => :environment do |_task, args|
+      file = args[:file].to_s
+      abort "File not found! [#{file}]" unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      organization = Decidim::Organization.find_by(id: data.dig("organization", "id"))
+      abort "Organization not found! [#{data["organization"]}]" unless organization
+      log(true).info "Importing taxonomies and filters for organization #{organization.id}"
+
+      planner(organization).import(data) do |importer, model_name|
+        taxonomies = importer.roots
+        result = importer.result
+        log.info "...Importing #{taxonomies.count} root taxonomies from #{model_name}"
+        taxonomies.each do |name, taxonomy|
+          log.info "  - Root taxonomy: #{name}"
+          log.info "    1st level taxonomies: #{taxonomy["taxonomies"].count}"
+          log.info "    Filters: #{taxonomy["filters"].count}"
+          taxonomy["filters"].each do |filter|
+            log.info "      - Filter name: #{filter["name"]}"
+            log.info "        Internal name: #{filter["internal_name"] || "-"}"
+            log.info "        Space manifests: #{filter["participatory_space_manifests"]&.join(", ") || "-"}"
+            log.info "        Items: #{filter["items"].count}"
+            log.info "        Components: #{filter["components"].count}"
+          end
+        end
+        importer.import! do |type, detail|
+          log.info "    !#{type}: #{detail}"
+        end
+        log.info "    Created taxonomies: #{result[:taxonomies_created].count}"
+        result[:taxonomies_created].each do |name|
+          log.info "      - #{name}"
+        end
+        log.info "    Created filters: #{result[:filters_created].count}"
+        result[:filters_created].each do |name, items|
+          log.info "      - #{name}: #{items.count} items"
+        end
+        log.info "    Assigned resources: #{result[:taxonomies_assigned].count}"
+        result[:taxonomies_assigned].each do |name, items|
+          log.info "      - #{name}: #{items.count} resources"
+        end
+        log.info "    Assigned components: #{result[:components_assigned].count}"
+        result[:components_assigned].each do |name, items|
+          log.info "      - #{name}: #{items.count} components"
+        end
+        log.info "    Failed resources: #{result[:failed_resources].count}"
+        result[:failed_resources].each do |object_id|
+          log.info "      - #{object_id}"
+        end
+        log.info "    Failed components: #{result[:failed_components].count}"
+        result[:failed_components].each do |component_id|
+          log.info "      - #{component_id}"
+        end
+        Rails.root.join("tmp/taxonomies", "#{organization.host}_result.json").write(JSON.pretty_generate(result))
+        log.info "Result saved in tmp/taxonomies/#{organization.host}_result.json"
+      end
+      log.info "Taxonomies and filters imported successfully."
+    end
+
+    desc "Imports taxonomies and filters structure from all JSON files inside tmp/taxonomies"
+    task :import_all_plans, [] => :environment do |_task, _args|
+      Rails.root.glob("tmp/taxonomies/*_plan.json").each do |file|
+        log.info "Importing plan from #{file}"
+        Rake::Task["decidim:taxonomies:import_plan"].reenable
+        Rake::Task["decidim:taxonomies:import_plan"].invoke(file)
+      end
+    end
+
+    desc "Adds taxonomies to metrics from old categories"
+    task :update_metrics, [:file] => :environment do |_task, args|
+      file = args[:file].to_s
+      abort "File not found! [#{file}]" unless File.exist?(file)
+
+      data = JSON.parse(File.read(file))
+      taxonomies = data["taxonomy_map"]
+      unless taxonomies && taxonomies&.any?
+        log.warn "No metric (categories) taxonomies found in the file"
+        next
+      end
+
+      total = taxonomies.count
+      taxonomies.each_with_index do |(id, object_id), index|
+        next unless object_id.include?("ImportModels::Category")
+
+        category_id = object_id.split("/").last
+        percent = ((index + 1) * 100 / total).to_i
+
+        count = Decidim::Metric.where(decidim_category_id: category_id).count
+        log.info "...#{percent}% Updating #{count} metrics for category #{category_id} to taxonomy #{id}"
+        Decidim::Metric.where(decidim_category_id: category_id).update_all(decidim_taxonomy_id: id) # rubocop:disable Rails/SkipsModelValidations
+      end
+    end
+
+    desc "Processes all metrics for result files in tmp/taxonomies"
+    task :update_all_metrics, [] => :environment do |_task, _args|
+      Rails.root.glob("tmp/taxonomies/*_result.json").each do |file|
+        log.info "Processing metrics from #{file}"
+        Rake::Task["decidim:taxonomies:update_metrics"].reenable
+        Rake::Task["decidim:taxonomies:update_metrics"].invoke(file)
+      end
+    end
+
+    desc "Reset counters for taxonomies and taxonomy filters"
+    task :reset_counters, [] => :environment do |_task, _args|
+      Decidim::Taxonomy.find_each do |taxonomy|
+        taxonomy.reset_all_counters
+        log.info "Counters reset for taxonomy #{taxonomy.id}:"
+        log.info "  Children: #{taxonomy.children_count}"
+        log.info "  Taxonomizations: #{taxonomy.taxonomizations_count}"
+        log.info "  Filters: #{taxonomy.filters_count}"
+        log.info "  Filter items: #{taxonomy.filter_items_count}"
+      end
+      Decidim::TaxonomyFilter.find_each do |filter|
+        filter.reset_all_counters
+        log.info "Counters reset for taxonomy filter #{filter.id}:"
+        log.info "  Filter items: #{filter.filter_items_count}"
+        log.info "  Components: #{filter.components_count}"
+      end
+    end
+
+    def planner(organization)
+      models = ENV.fetch("IMPORTS", "ParticipatoryProcessType AssemblyType Scope Area Category").split.map do |model_name|
+        "Decidim::Maintenance::ImportModels::#{model_name}".constantize
+      end
+      Decidim::Maintenance::TaxonomyPlan.new(organization, models)
+    end
+
+    def plan_file_path(organization)
+      Rails.root.join("tmp/taxonomies", "#{organization.host}_plan.json")
+    end
+
+    def log(reset = false) # rubocop:disable Style/OptionalBooleanParameter
+      @log = nil if reset
+      @log ||= Logger.new($stdout, formatter: proc { |_severity, _time, _progname, msg|
+        "#{msg}\n"
+      })
+    end
+  end
+end