decidim-core 0.26.2 → 0.27.0.rc2

data/db/migrate/20210831181635_create_active_storage_variant_records.active_storage.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# This migration comes from active_storage (originally 20191206030411)
+class CreateActiveStorageVariantRecords < ActiveRecord::Migration[6.0]
+  def change
+    create_table :active_storage_variant_records do |t|
+      t.belongs_to :blob, null: false, index: false
+      t.string :variation_digest, null: false
+
+      t.index [:blob_id, :variation_digest], name: "index_active_storage_variant_records_uniqueness", unique: true
+      t.foreign_key :active_storage_blobs, column: :blob_id
+    end
+  end
+end

data/db/migrate/20211208155453_create_decidim_reminders.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class CreateDecidimReminders < ActiveRecord::Migration[6.0]
+  def change
+    create_table :decidim_reminders do |t|
+      t.belongs_to :decidim_user, index: true, foreign_key: true, null: false
+      t.belongs_to :decidim_component, index: true, foreign_key: true
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20211209121025_create_decidim_reminder_records.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class CreateDecidimReminderRecords < ActiveRecord::Migration[6.0]
+  def change
+    create_table :decidim_reminder_records do |t|
+      t.string :state, :string, index: true, default: "active"
+      t.belongs_to :decidim_reminder, index: true, foreign_key: true
+      t.belongs_to :remindable, polymorphic: true, null: false, index: { name: "index_decidim_reminder_records_remindable" }
+    end
+  end
+end

data/db/migrate/20211209121040_create_decidim_reminder_deliveries.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class CreateDecidimReminderDeliveries < ActiveRecord::Migration[6.0]
+  def change
+    create_table :decidim_reminder_deliveries do |t|
+      t.belongs_to :decidim_reminder, index: true, foreign_key: true
+      t.timestamps
+    end
+  end
+end

data/db/migrate/20220118121921_change_required_description_categories.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class ChangeRequiredDescriptionCategories < ActiveRecord::Migration[6.0]
+  def change
+    change_column_null :decidim_categories, :description, true
+  end
+end

data/db/migrate/20220127113419_add_notification_settings_to_users.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddNotificationSettingsToUsers < ActiveRecord::Migration[6.0]
+  def change
+    add_column :decidim_users, :notification_settings, :jsonb, default: {}
+  end
+end

data/db/migrate/20220203121137_add_notifications_sending_frequency_to_users.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddNotificationsSendingFrequencyToUsers < ActiveRecord::Migration[6.0]
+  def change
+    add_column :decidim_users, :notifications_sending_frequency, :string, default: "daily", index: true
+  end
+end

data/db/migrate/20220215172439_add_digest_sent_at_to_users.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddDigestSentAtToUsers < ActiveRecord::Migration[6.0]
+  def change
+    add_column :decidim_users, :digest_sent_at, :datetime
+  end
+end

data/db/migrate/20220323195258_add_index_to_decidim_users_notifications_sending_frequency.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class AddIndexToDecidimUsersNotificationsSendingFrequency < ActiveRecord::Migration[6.0]
+  def change
+    add_index :decidim_users, :notifications_sending_frequency
+  end
+end

data/db/migrate/20220427142214_drop_emails_on_notifications_flag_from_user.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class DropEmailsOnNotificationsFlagFromUser < ActiveRecord::Migration[5.1]
+  class DecidimUser < ApplicationRecord
+    self.table_name = :decidim_users
+  end
+
+  def change
+    # rubocop:disable Rails/SkipsModelValidations
+    DecidimUser.where(email_on_notification: true).update_all(notifications_sending_frequency: "real_time")
+    # rubocop:enable Rails/SkipsModelValidations
+
+    remove_column :decidim_users, :email_on_notification
+  end
+end

data/db/migrate/20220518094535_add_previous_passwords_to_users.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class AddPreviousPasswordsToUsers < ActiveRecord::Migration[6.1]
+  class User < ApplicationRecord
+    self.table_name = :decidim_users
+  end
+
+  def change
+    add_column :decidim_users, :password_updated_at, :datetime
+    add_column :decidim_users, :previous_passwords, :string, array: true, default: []
+
+    reversible do |direction|
+      direction.up do
+        # rubocop:disable Rails/SkipsModelValidations
+        User.update_all("password_updated_at = updated_at")
+        # rubocop:enable Rails/SkipsModelValidations
+      end
+    end
+  end
+end

data/db/migrate/20220524195530_create_decidim_short_links.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class CreateDecidimShortLinks < ActiveRecord::Migration[6.1]
+  def change
+    create_table :decidim_short_links do |t|
+      t.references :decidim_organization, null: false, index: true
+      t.references :target, polymorphic: true, null: false, index: true
+      t.string :identifier, limit: 10, null: false
+      t.string :mounted_engine_name, index: true
+      t.string :route_name, index: true
+      t.jsonb :params
+
+      t.timestamps
+    end
+
+    add_index(
+      :decidim_short_links,
+      [:decidim_organization_id, :identifier],
+      unique: true,
+      name: "idx_decidim_short_links_organization_id_identifier"
+    )
+  end
+end

data/db/seeds.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-if !Rails.env.production? || ENV["SEED"]
+if !Rails.env.production? || ENV.fetch("SEED", nil)
   print "Creating seeds for decidim-core...\n" unless Rails.env.test?
 
   require "decidim/faker/localized"
@@ -17,8 +17,8 @@ if !Rails.env.production? || ENV["SEED"]
     table.tr("_", "/").classify.safe_constantize
   end.compact.each(&:reset_column_information)
 
-  smtp_label = ENV["SMTP_FROM_LABEL"] || Faker::Twitter.unique.screen_name
-  smtp_email = ENV["SMTP_FROM_EMAIL"] || Faker::Internet.email
+  smtp_label = ENV.fetch("SMTP_FROM_LABEL", Faker::Twitter.unique.screen_name)
+  smtp_email = ENV.fetch("SMTP_FROM_EMAIL", Faker::Internet.email)
 
   organization = Decidim::Organization.first || Decidim::Organization.create!(
     name: Faker::Company.name,
@@ -31,12 +31,12 @@ if !Rails.env.production? || ENV["SEED"]
       from: "#{smtp_label} <#{smtp_email}>",
       from_email: smtp_email,
       from_label: smtp_label,
-      user_name: ENV["SMTP_USERNAME"] || Faker::Twitter.unique.screen_name,
-      encrypted_password: Decidim::AttributeEncryptor.encrypt(ENV["SMTP_PASSWORD"] || Faker::Internet.password(min_length: 8)),
-      address: ENV["SMTP_ADDRESS"] || ENV["DECIDIM_HOST"] || "localhost",
-      port: ENV["SMTP_PORT"] || ENV["DECIDIM_SMTP_PORT"] || "25"
+      user_name: ENV.fetch("SMTP_USERNAME", Faker::Twitter.unique.screen_name),
+      encrypted_password: Decidim::AttributeEncryptor.encrypt(ENV.fetch("SMTP_PASSWORD", Faker::Internet.password(min_length: 8))),
+      address: ENV.fetch("SMTP_ADDRESS", nil) || ENV.fetch("DECIDIM_HOST", "localhost"),
+      port: ENV.fetch("SMTP_PORT", nil) || ENV.fetch("DECIDIM_SMTP_PORT", "25")
     },
-    host: ENV["DECIDIM_HOST"] || "localhost",
+    host: ENV.fetch("DECIDIM_HOST", "localhost"),
     external_domain_whitelist: ["decidim.org", "github.com"],
     description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
       Decidim::Faker::Localized.sentence(word_count: 15)
@@ -115,12 +115,9 @@ if !Rails.env.production? || ENV["SEED"]
   end
 
   admin = Decidim::User.find_or_initialize_by(email: "admin@example.org")
-
-  admin.update!(
+  admin_hash = {
     name: Faker::Name.name,
     nickname: Faker::Twitter.unique.screen_name,
-    password: "decidim123456",
-    password_confirmation: "decidim123456",
     organization: organization,
     confirmed_at: Time.current,
     locale: I18n.default_locale,
@@ -130,14 +127,16 @@ if !Rails.env.production? || ENV["SEED"]
     about: Faker::Lorem.paragraph(sentence_count: 2),
     accepted_tos_version: organization.tos_version,
     admin_terms_accepted_at: Time.current
-  )
+  }
+  admin_hash.merge!(password: "decidim123456789", password_confirmation: "decidim123456789") if admin.encrypted_password.blank?
+  admin.update!(admin_hash)
 
   ["user@example.org", "user2@example.org"].each do |email|
     Decidim::User.find_or_initialize_by(email: email).update!(
       name: Faker::Name.name,
       nickname: Faker::Twitter.unique.screen_name,
-      password: "decidim123456",
-      password_confirmation: "decidim123456",
+      password: "decidim123456789",
+      password_confirmation: "decidim123456789",
       confirmed_at: Time.current,
       locale: I18n.default_locale,
       organization: organization,
@@ -155,8 +154,8 @@ if !Rails.env.production? || ENV["SEED"]
   locked_user.update!(
     name: Faker::Name.name,
     nickname: Faker::Twitter.unique.screen_name,
-    password: "decidim123456",
-    password_confirmation: "decidim123456",
+    password: "decidim123456789",
+    password_confirmation: "decidim123456789",
     confirmed_at: Time.current,
     locale: I18n.default_locale,
     organization: organization,
@@ -211,7 +210,7 @@ if !Rails.env.production? || ENV["SEED"]
   Decidim::System::CreateDefaultContentBlocks.call(organization)
 
   hero_content_block = Decidim::ContentBlock.find_by(organization: organization, manifest_name: :hero, scope_name: :homepage)
-  hero_content_block.images_container.background_image = ActiveStorage::Blob.create_after_upload!(
+  hero_content_block.images_container.background_image = ActiveStorage::Blob.create_and_upload!(
     io: File.open(File.join(seeds_root, "homepage_image.jpg")),
     filename: "homepage_image.jpg",
     content_type: "image/jpeg",

data/lib/decidim/acts_as_tree.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Decidim
+  module ActsAsTree
+    extend ActiveSupport::Concern
+
+    included do
+      @parent_item_foreign_key = :parent_id
+    end
+
+    class_methods do
+      def parent_item_foreign_key(name = nil)
+        return @parent_item_foreign_key unless name
+
+        @parent_item_foreign_key = name
+      end
+
+      def tree_for(item)
+        where(Arel.sql("#{table_name}.id IN (#{tree_sql_for(item)})")).order("#{table_name}.id")
+      end
+
+      def tree_sql_for(item)
+        <<-SQL.squish
+        WITH RECURSIVE search_tree(id, path) AS (
+          SELECT id, ARRAY[id]
+          FROM #{table_name}
+          WHERE id = #{item.id}
+            UNION ALL
+          SELECT #{table_name}.id, path || #{table_name}.id
+            FROM search_tree
+          JOIN #{table_name} ON #{table_name}.#{parent_item_foreign_key} = search_tree.id
+            WHERE NOT #{table_name}.id = ANY(path)
+        )
+        SELECT id FROM search_tree ORDER BY path
+        SQL
+      end
+    end
+
+    def descendants
+      @descendants ||= self_and_descendants.where.not(id: id)
+    end
+
+    def self_and_descendants
+      @self_and_descendants ||= self.class.tree_for(self)
+    end
+  end
+end

data/lib/decidim/api/input_sorts/component_input_sort.rb

@@ -23,7 +23,8 @@ module Decidim
                prepare: lambda { |direction, ctx|
                           lambda { |locale|
                             locale = ctx[:current_organization].default_locale if locale.blank?
-                            [Arel.sql("name->? #{direction.upcase}").to_s, locale]
+                            field = Arel::Nodes::InfixOperation.new("->", Arel.sql("name"), Arel::Nodes.build_quoted(locale))
+                            Arel::Nodes::InfixOperation.new("", field, Arel.sql(direction.upcase))
                           }
                         }
     end

data/lib/decidim/api/interfaces/authorable_interface.rb

@@ -12,11 +12,12 @@ module Decidim
       end
 
       def author
-        if object.respond_to?(:normalized_author)
-          object&.normalized_author
-        elsif object.respond_to?(:creator_identity)
-          object&.creator_identity
-        end
+        author = if object.respond_to?(:normalized_author)
+                   object&.normalized_author
+                 elsif object.respond_to?(:creator_identity)
+                   object&.creator_identity
+                 end
+        author if author.is_a?(Decidim::UserBaseEntity)
       end
     end
   end

data/lib/decidim/asset_router.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Asset router provides global access to the asset routes for assets saved
+  # through ActiveStorage. This handles the different cases for routing to the
+  # remote routes when using an assets CDN or to local routes when using the
+  # local disk storage driver.
+  class AssetRouter
+    # Initializes the router.
+    #
+    # @param [ActiveStorage::Attached, ActiveStorage::Blob] The asset to route
+    #   to
+    def initialize(asset)
+      @asset = asset
+    end
+
+    # Generates the correct URL to the asset with the provided options.
+    #
+    # @param options The options for the URL that are the normal route options
+    #   Rails route helpers accept
+    def url(**options)
+      if asset.is_a? ActiveStorage::Attached
+        routes.rails_blob_url(asset.blob, **default_options.merge(options))
+      else
+        routes.rails_representation_url(asset, **default_options.merge(options))
+      end
+    end
+
+    private
+
+    attr_reader :asset
+
+    # Provides the route helpers depending on whether the URL is generated to
+    # the local host or an external CDN (remote).
+    #
+    # @return [Module, Decidim::EngineRouter] The correct route helpers based
+    #   on the configuration
+    def routes
+      @routes ||=
+        if remote?
+          Rails.application.routes.url_helpers
+        else
+          EngineRouter.new("main_app", {})
+        end
+    end
+
+    # Determines whether the assets call should be to a remote CDN or to the
+    # local server based on the storage options.
+    #
+    # @return [Boolean] A boolean indicating whether the assets are served
+    #   through a remote CDN
+    def remote?
+      remote_storage_options.present?
+    end
+
+    # Determines the default options to be passed to the route helper. For the
+    # remote storage, returns the remote storage options and for the local disk
+    # storage returns an empty hash.
+    #
+    # @return [Hash] The default options hash to pass to the route helper
+    def default_options
+      @default_options ||=
+        if remote?
+          remote_storage_options
+        else
+          {}
+        end
+    end
+
+    # The remote storage options when using a remote CDN. An empty hash in case
+    # using the local disk storage.
+    #
+    # @return [Hash] The remote storage options hash
+    def remote_storage_options
+      @remote_storage_options ||= {
+        host: Rails.application.secrets.dig(:storage, :cdn_host)
+      }.compact
+    end
+  end
+end

data/lib/decidim/attachment_attributes.rb

@@ -3,14 +3,14 @@
 require "active_support/concern"
 
 module Decidim
-  # A set of convenience methods to deal with attachment attributes for Virtus
+  # A set of convenience methods to deal with attachment attributes for
   # models that may set the attachment records through the original model
   # (Decidim::Attachment) or through the user submitted form data (String).
   module AttachmentAttributes
     extend ActiveSupport::Concern
 
     class_methods do
-      # Public: Mirrors Virtus' `attribute` interface to define attachment
+      # Public: Mirrors the `attribute` interface to define attachment
       # attributes for form objects.
       #
       # name - The attribute's name
@@ -20,14 +20,14 @@ module Decidim
       #
       #   attachment_attribute :photos
       #   # This will create two attributes of the following types:
-      #   #   attribute :photos, Array[String]
+      #   #   attribute :photos, Array[Integer]
       #   #   attribute :add_photos, Array
       #   # In addition, it will generate the getter method for the attribute
       #   # returning an array of the Decidim::Attachment records.
       #
       # Returns nothing.
       def attachments_attribute(name)
-        attribute name, Array[String]
+        attribute name, Array[Integer]
         attribute "add_#{name}".to_sym, Array
 
         # Define the getter method that fetches the attachment records based on
@@ -37,13 +37,13 @@ module Decidim
         define_method name do
           return instance_variable_get(variable_name) if instance_variable_defined?(variable_name)
 
-          original = instance_variable_get("@#{name}")
-          return original unless original.is_a?(Array)
+          original = @attributes[name.to_s].value_before_type_cast
+          return original if original && !original.is_a?(Array)
 
           instance_variable_set(
             variable_name,
-            original.map do |attachment|
-              if attachment.is_a?(String) || attachment.is_a?(Integer)
+            super().map do |attachment|
+              if attachment.is_a?(Integer)
                 Decidim::Attachment.find_by(id: attachment)
               else
                 attachment

data/lib/decidim/attribute_object/form.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+module Decidim
+  module AttributeObject
+    # This is the main Form class that provides the functionality for all core
+    # forms that take in user input from the user interface forms and converts
+    # the inputs to expected formats.
+    #
+    # This replaces the Rectify::Form classes in Decidim which used to provide
+    # similar functionality. The API provided by this class is largely
+    # compatible with `Rectify::Form`.
+    class Form
+      include Decidim::AttributeObject::Model
+      include ActiveModel::Validations
+
+      attr_reader :context
+
+      def self.mimic(model_name)
+        @model_name = model_name.to_s.underscore.to_sym
+      end
+
+      def self.mimicked_model_name
+        @model_name || infer_model_name
+      end
+
+      def self.infer_model_name
+        return :form unless name
+
+        class_name = name.split("::").last
+        return :form if class_name == "Form"
+
+        class_name.chomp("Form").underscore.to_sym
+      end
+
+      # Converts the mimicked name to ActiveModel naming.
+      def self.model_name
+        ActiveModel::Name.new(self, nil, mimicked_model_name.to_s)
+      end
+
+      def self.from_model(model)
+        form_attributes = attribute_types.keys.each_with_object({}) do |key, attrs|
+          next unless model.respond_to?(key)
+
+          value = model.send(key)
+          attrs[key] =
+            case value
+            when ActiveStorage::Attached::One
+              value.attachment.try(:blob)
+            when ActiveStorage::Attached::Many
+              value.attachments.map(&:blob)
+            else
+              value
+            end
+        end
+
+        form = new(form_attributes)
+        form.map_model(model)
+
+        form
+      end
+
+      def self.from_params(params, additional_params = {})
+        params_hash = hash_from(params)
+        mimicked_params = ensure_hash(params_hash[mimicked_model_name])
+
+        attributes_hash = params_hash.merge(mimicked_params).merge(additional_params)
+
+        new(attributes_hash)
+      end
+
+      def self.hash_from(params)
+        params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+        params.with_indifferent_access
+      end
+
+      def self.ensure_hash(object)
+        if object.is_a?(Hash)
+          object
+        else
+          {}
+        end
+      end
+
+      def persisted?
+        id.present? && id.to_i.positive?
+      end
+
+      def to_key
+        [id]
+      end
+
+      # Required for the active model naming to work correctly to form the HTML
+      # class attributes for the form elements (e.g. edit_account instead
+      # of edit_account_form).
+      def to_model
+        self
+      end
+
+      def to_param
+        id.to_s
+      end
+
+      # Use the map_model method within the form implementations to map any
+      # custom form-specific attributes from the model to the form.
+      def map_model(_model); end
+
+      def with_context(new_context)
+        @context = if new_context.is_a?(Hash)
+                     OpenStruct.new(new_context)
+                   else
+                     new_context
+                   end
+
+        attributes.each do |_name, value|
+          case value
+          when Array
+            value.each do |v|
+              next unless v.respond_to?(:with_context)
+
+              v.with_context(context)
+            end
+          else
+            next unless value.respond_to?(:with_context)
+
+            value.with_context(context)
+          end
+        end
+
+        self
+      end
+
+      # Although we are running the nested attributes validations through the
+      # NestedValidator, we still need to check for the errors in the nested
+      # attributes after the main validations are run in case the main
+      # validations are adding errors to some of the nested attributes.
+      #
+      # An example of such form is the Decidim::Budgets::Admin::ComponentForm
+      # which adds errors to the sub-attribute "settings" during its own
+      # validations. Because these errors are not added to the main form object,
+      # the main form object would be interpreted as valid without checking the
+      # sub-attribute validations.
+      #
+      # This preserves the backwards compatibility with Rectify::Form which
+      # did the validations in this order and fails the main record validation
+      # in case one of the nested attributes is not valid. This is needed e.g.
+      # for the customized component validations (e.g. Budgets component form).
+      def valid?(_context = nil)
+        super && self.class.attribute_types.none? do |name, type|
+          value = public_send(name)
+
+          if value.is_a?(Decidim::AttributeObject::Model) || (type.respond_to?(:validate_nested?) && type.validate_nested?)
+            _value_has_errors?(value)
+          else
+            false
+          end
+        end
+      end
+
+      private
+
+      def _value_has_errors?(value)
+        if value.is_a?(Array)
+          value.any? { |v| _value_has_errors?(v) }
+        elsif value.is_a?(Hash)
+          _value_has_errors?(value.values)
+        elsif value.respond_to?(:errors)
+          value.errors.any?
+        else
+          false
+        end
+      end
+    end
+  end
+end