decidim-core 0.26.2 → 0.27.0.rc1

data/app/models/decidim/share_token.rb

@@ -2,8 +2,6 @@
 
 module Decidim
   class ShareToken < ApplicationRecord
-    validates :organization, presence: true
-    validates :user, presence: true
     validates :token, presence: true, uniqueness: { scope: [:decidim_organization_id, :token_for_type, :token_for_id] }
 
     belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"

data/app/models/decidim/short_link.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Short links are a way to reference specific locations within Decidim with
+  # shorted URLs, similar to the popular link shortening services. The original
+  # reason for creating the feature was to reference long calendar URLs in a
+  # more compact way for the URLs to be compatible with the calendar programs.
+  # When the URL is long with lots of filtering parameters included in it, it
+  # may be too long for specific 3rd party programs.
+  #
+  # This feature can be used to link to any URLs or resources in Decidim with a
+  # short reference.
+  class ShortLink < ApplicationRecord
+    belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
+    belongs_to :target, polymorphic: true
+
+    validates :identifier, presence: true, uniqueness: true
+
+    before_validation :generate_identifier
+
+    # Finds a matching short link to the same target with exactly the same
+    # parameters if it already exists or creates a new one if it doesn't exist.
+    #
+    # @param target [ActiveRecord::Base] The target where this short link should
+    #   link to. Most of the times [Decidim::Organization], [Decidim::Component]
+    #   or some other top-level record.
+    # @param mounted_engine [String] The mounted engine helper name that will be
+    #   used to generate the link.
+    # @param route_name [String, nil] The route name to be linked to. If not
+    #   defined, the short link will be generated for the root URL for the
+    #   mounted engine.
+    # @param params [Hash] The query parameters that should be included in the
+    #   URL where this short link will redirect to.
+    # @return [Decidim::ShortLink] The short link instance to link to.
+    def self.to(target, mounted_engine, route_name: nil, params: {})
+      organization =
+        if target.is_a?(Decidim::Organization)
+          target
+        else
+          target.try(:organization)
+        end
+
+      values = {
+        organization: organization,
+        target: target,
+        mounted_engine_name: mounted_engine,
+        route_name: route_name
+      }
+      existing =
+        if params
+          where(values).find_by("params = ?::jsonb", params.to_json)
+        else
+          find_by(values.merge(params: nil))
+        end
+
+      existing || create!(values.merge(params: params))
+    end
+
+    # Creates a random unique identifier for any new links. Raises an
+    # OutOfCandidatesError if a free candidate cannot be found with 20 tries.
+    # In this situation the older records should be removed from the database.
+    #
+    # @return [String] A new unique identifier.
+    def self.unique_identifier_within(organization)
+      1.step do |n|
+        raise OutOfCandidatesError if n > 20
+
+        # A-Z, a-z and 0-9
+        # 26 + 26 + 10 = 62 possibilities per character
+        # 62^10 ≈ 8×10¹⁷ total possibilities
+        candidate = SecureRandom.alphanumeric(10)
+        next if where(organization: organization, identifier: candidate).any?
+
+        return candidate
+      end
+    end
+
+    # Overrides the route_name method to add a default route name for the "root"
+    # path in case the route name is not defined for the record.
+    #
+    # @return [String] The route name to link to.
+    def route_name
+      super || "root"
+    end
+
+    # Generates the short URL referencing this link.
+    #
+    # @return [String] The short URL that can be used to link to the target.
+    def short_url
+      EngineRouter.new("decidim", default_url_options).short_link_url(id: identifier)
+    end
+
+    # Generates the full long URL to the resource matching this short link.
+    #
+    # @return [String] The target full URL that the short link should link to.
+    def target_url
+      url_helpers.send("#{route_name}_url", **params)
+    end
+
+    private
+
+    # Generates a new identifier for new records.
+    #
+    # @return [void]
+    def generate_identifier
+      return if identifier.present?
+
+      self.identifier = self.class.unique_identifier_within(organization)
+    end
+
+    # Returns the default URL options for the organization. The participatory
+    # space and component related parameters are excluded from the
+    # default_url_options because these are also needed for the short URL
+    # generation.
+    #
+    # @return [Hash] A hash of the default URL options for the links.
+    def default_url_options
+      { host: organization&.host }.compact
+    end
+
+    # Returns the options for the URL helper call against the routes proxy.
+    # The options include the mounted params for the target, such as
+    # participatory space slug and component ID, depending what the target is.
+    #
+    # @return [Hash] The mounted options for the target record that will be used
+    #   to generate the final link.
+    def mounted_options
+      if target.is_a?(Decidim::Participable)
+        # The mounted_params method returns always e.g. participatory_space_slug
+        # assembly_slug, etc. But when we want to link to the space itself, we
+        # only need the `slug` parameter.
+        { host: target.organization.host, slug: target.slug }
+      elsif target.respond_to?(:mounted_params)
+        target.mounted_params
+      elsif target.respond_to?(:component)
+        target.component.mounted_params.merge(id: target.id)
+      elsif target.respond_to?(:participatory_space)
+        target.participatory_space.mounted_params
+      elsif target.respond_to?(:slug)
+        # E.g. Decidim::StaticPage uses the slug as the `:id` parameter.
+        default_url_options.merge(id: target.slug)
+      elsif !target.is_a?(Decidim::Organization)
+        default_url_options.merge(id: target.id)
+      else
+        default_url_options
+      end
+    end
+
+    # Returns the routes helpers for the target engine.
+    #
+    # @return [Decidim::EngineRouter] An instance of the engine router that will
+    #   be used to generate the links to the correct context.
+    def url_helpers
+      @url_helpers ||= EngineRouter.new(mounted_engine_name, mounted_options)
+    end
+
+    # The OutOfCandidatesError is an error class that will be raised when the
+    # short link identifiers are running out and the short link cannot be
+    # generated.
+    class OutOfCandidatesError < StandardError; end
+  end
+end

data/app/models/decidim/user.rb

@@ -5,15 +5,15 @@ require "devise/models/decidim_newsletterable"
 require "valid_email2"
 
 module Decidim
-  # A User is a citizen that wants to join the platform to participate.
+  # A User is a participant that wants to join the platform to engage.
   class User < UserBaseEntity
-    include Decidim::DataPortability
+    include Decidim::DownloadYourData
     include Decidim::Searchable
     include Decidim::ActsAsAuthor
     include Decidim::UserReportable
     include Decidim::Traceable
 
-    REGEXP_NICKNAME = /\A[\w\-]+\z/.freeze
+    REGEXP_NICKNAME = /\A[\w\-]+\z/
 
     class Roles
       def self.all
@@ -34,6 +34,7 @@ module Decidim
     has_many :user_groups, through: :memberships, class_name: "Decidim::UserGroup", foreign_key: :decidim_user_group_id
     has_many :access_grants, class_name: "Doorkeeper::AccessGrant", foreign_key: :resource_owner_id, dependent: :destroy
     has_many :access_tokens, class_name: "Doorkeeper::AccessToken", foreign_key: :resource_owner_id, dependent: :destroy
+    has_many :reminders, foreign_key: "decidim_user_id", class_name: "Decidim::Reminder", dependent: :destroy
 
     has_one :blocking, class_name: "Decidim::UserBlock", foreign_key: :id, primary_key: :block_id, dependent: :destroy
 
@@ -50,7 +51,7 @@ module Decidim
 
     validate :all_roles_are_valid
 
-    has_one_attached :data_portability_file
+    has_one_attached :download_your_data_file
 
     scope :not_deleted, -> { where(deleted_at: nil) }
 
@@ -81,12 +82,14 @@ module Decidim
                         # scope_id: :decidim_scope_id,
                         organization_id: :decidim_organization_id,
                         A: :name,
+                        B: :nickname,
                         datetime: :created_at
                       },
                       index_on_create: ->(user) { !(user.deleted? || user.blocked?) },
                       index_on_update: ->(user) { !(user.deleted? || user.blocked?) })
 
     before_save :ensure_encrypted_password
+    before_save :save_password_change
 
     def user_invited?
       invitation_token_changed? && invitation_accepted_at_changed?
@@ -186,10 +189,10 @@ module Decidim
     end
 
     def self.export_serializer
-      Decidim::DataPortabilitySerializers::DataPortabilityUserSerializer
+      Decidim::DownloadYourDataSerializers::DownloadYourDataUserSerializer
     end
 
-    def self.data_portability_images(user)
+    def self.download_your_data_images(user)
       user_collection(user).map(&:avatar)
     end
 
@@ -255,6 +258,18 @@ module Decidim
       Arel.sql(%{("decidim_users"."last_sign_in_at")::text})
     end
 
+    def notifications_subscriptions
+      notification_settings.fetch("subscriptions", {})
+    end
+
+    def needs_password_update?
+      return false unless admin?
+      return false unless Decidim.config.admin_password_strong
+      return true if password_updated_at.blank?
+
+      password_updated_at < Decidim.config.admin_password_expiration_days.days.ago
+    end
+
     protected
 
     # Overrides devise email required validation.
@@ -302,5 +317,18 @@ module Decidim
     def ensure_encrypted_password
       restore_encrypted_password! if will_save_change_to_encrypted_password? && encrypted_password.blank?
     end
+
+    def save_password_change
+      return unless persisted?
+      return unless encrypted_password_changed?
+      return unless admin?
+      return unless Decidim.config.admin_password_strong
+
+      # We don't want to run validations here because that could lead to an endless validation loop.
+      # rubocop:disable Rails/SkipsModelValidations
+      update_column(:password_updated_at, Time.current)
+      update_column(:previous_passwords, [encrypted_password_was, *previous_passwords].first(Decidim.config.admin_password_repetition_times))
+      # rubocop:enable Rails/SkipsModelValidations
+    end
   end
 end

data/app/models/decidim/user_base_entity.rb

@@ -18,7 +18,7 @@ module Decidim
     has_many :following_follows, foreign_key: "decidim_user_id", class_name: "Decidim::Follow", dependent: :destroy
 
     # Regex for name & nickname format validations
-    REGEXP_NAME = /\A(?!.*[<>?%&\^*#@()\[\]=+:;"{}\\|])/.freeze
+    REGEXP_NAME = /\A(?!.*[<>?%&\^*#@()\[\]=+:;"{}\\|])/
 
     has_one_attached :avatar
     validates_avatar :avatar, uploader: Decidim::AvatarUploader

data/app/models/decidim/user_group.rb

@@ -4,10 +4,10 @@ require "devise/models/decidim_validatable"
 require "valid_email2"
 
 module Decidim
-  # A UserGroup is an organization of citizens
+  # A UserGroup is an organization of participants
   class UserGroup < UserBaseEntity
     include Decidim::Traceable
-    include Decidim::DataPortability
+    include Decidim::DownloadYourData
     include Decidim::ActsAsAuthor
     include Decidim::UserReportable
     include Decidim::Searchable
@@ -87,7 +87,7 @@ module Decidim
     end
 
     def self.export_serializer
-      Decidim::DataPortabilitySerializers::DataPortabilityUserGroupSerializer
+      Decidim::DownloadYourDataSerializers::DownloadYourDataUserGroupSerializer
     end
 
     def document_number

data/app/models/decidim/user_moderation.rb

@@ -12,8 +12,6 @@ module Decidim
     scope :unblocked, -> { joins(:user).where(decidim_users: { blocked: false }) }
 
     delegate :organization, to: :user
-    scope :blocked, -> { joins(:user).where(decidim_users: { blocked: true }) }
-    scope :unblocked, -> { joins(:user).where(decidim_users: { blocked: false }) }
 
     def self.log_presenter_class_for(_log)
       Decidim::AdminLog::UserModerationPresenter

data/app/models/decidim/user_report.rb

@@ -2,7 +2,7 @@
 
 module Decidim
   class UserReport < ApplicationRecord
-    include Decidim::DataPortability
+    include Decidim::DownloadYourData
 
     REASONS = %w(spam offensive does_not_belong).freeze
 
@@ -16,7 +16,7 @@ module Decidim
 
     def self.export_serializer
       raise NotImplementedError
-      # Decidim::DataPortabilitySerializers::DataPortabilityReportSerializer
+      # Decidim::DownloadYourDataSerializers::DownloadYourDataReportSerializer
     end
 
     private

data/app/packs/entrypoints/decidim_core.js

@@ -14,7 +14,6 @@ import "src/decidim/vendor/foundation-datepicker"
 import "src/decidim/foundation_datepicker_locales"
 import "src/decidim/vendor/modernizr"
 import "src/decidim/vendor/social-share-button"
-import "social-share-button"
 
 import "src/decidim/input_tags"
 import "src/decidim/input_hashtags"
@@ -57,7 +56,9 @@ import "src/decidim/start_conversation_dialog"
 import "src/decidim/notifications"
 import "src/decidim/identity_selector_dialog"
 import "src/decidim/gallery"
+import "src/decidim/direct_uploads/upload_field"
 import "src/decidim/back_to_list"
+import "src/decidim/cookie_consent/cookie_consent"
 
 // CSS
 import "entrypoints/decidim_core.scss"
@@ -70,4 +71,3 @@ require.context("../images", true)
 
 // This needs to be loaded after confirm dialog to bind properly
 Rails.start()
-

data/app/packs/entrypoints/decidim_sw.js

@@ -0,0 +1 @@
+import "src/decidim/sw"

data/app/packs/src/decidim/autocomplete.js

@@ -0,0 +1,298 @@
+import AutoCompleteJS from "@tarekraafat/autocomplete.js";
+
+export default class AutoComplete {
+  constructor(el, options = {}) {
+    this.element = el;
+    this.stickySelectedSpan = null;
+    this.clearStickySelectionSpan = null;
+    this.stickyHiddenInput = null;
+    this.promptDiv = null;
+    const thresholdTemp = options.threshold || 2;
+    this.options = Object.assign({
+      // Defines name of the hidden input (e.g. assembly_member[user_id])
+      name: null,
+      // Placeholder of the visible input field
+      placeholder: "",
+      // Defines what happens after user has selected value from suggestions
+      // sticky - Allows selecting a single value and not editing the value after selected (e.g. as the admin autocomplete fields)
+      // single - Allows selecting a single value and editing the selected text after the selection (e.g. geocoding field)
+      // multi - Allows selecting multiple values
+      // null (default) - Disable selection event handling in this class
+      mode: null,
+      // Defines if we show input help (e.g. "Type at least three characters to search") or not.
+      searchPrompt: false,
+      // Defines search prompt message, only shown if showPrompt is enabled!
+      searchPromptText: `Type at least ${thresholdTemp} characters to search`,
+      // Defines items that are selected already when page is loaded before user selects them. (e.g. when form submit fails)
+      selected: null,
+      // Defines how many characters input has to have before we start searching
+      threshold: thresholdTemp,
+      // Defines how many results to show in the autocomplete selection list
+      // by maximum.
+      maxResults: 10,
+      // Defines the data keys against which to match the user input when
+      // searching through the results. For example, when the following
+      // data is returned by the API:
+      //   { id: 123, name: "John", nickname: "john", __typename: "User" }
+      //
+      // You can define the data keys array as ["name", "nickname"] in
+      // which case the results shown to user would be only those that
+      // have matching text in these defined fields.
+      dataMatchKeys: null,
+      // The data source is a method that gets the callback parameter as
+      // its first argument which should be called with the results array
+      // once they are returned by the API.
+      // For example:
+      //   (query, callback) => {
+      //     (async () => {
+      //       const results = await callAjax(`/api/url?query=${query}`);
+      //       callback(results);
+      //     })();
+      //   }
+      //
+      // Signature: (callback: Function)
+      dataSource: () => [],
+      // Filters the data list returned by the data source before it is shown
+      // to the user. Can be used e.g. to hide already selected values from
+      // the list.
+      dataFilter: null,
+      // Delay in milliseconds how long to wait after user action before
+      // doing a backend request.
+      delay: 200,
+      // Allows modifying the suggested items before they are displayed in the list
+      // Signature: (element: HTMLElement, value: Object)
+      modifyResult: null
+    }, options);
+
+    this.autocomplete = new AutoCompleteJS({
+      selector: () => this.element,
+      placeHolder: options.placeholder,
+      // Delay (milliseconds) before autocomplete engine starts. It's preventing many queries when user is typing fast.
+      debounce: 200,
+      threshold: this.options.threshold,
+      data: {
+        keys: this.options.dataMatchKeys,
+        src: async (query) => {
+          const fetchResults = () => {
+            return new Promise((resolve) => {
+              this.options.dataSource(query, resolve);
+            });
+          }
+
+          try {
+            return await fetchResults();
+          } catch (error) {
+            return error;
+          }
+        },
+        filter: (list) => {
+          if (this.options.dataFilter) {
+            return this.options.dataFilter(list);
+          }
+
+          return list;
+        }
+      },
+      resultsList: {
+        maxResults: this.options.maxResults
+      },
+      resultItem: {
+        element: (item, data) => {
+          if (!this.options.modifyResult) {
+            return;
+          }
+
+          this.options.modifyResult(item, data.value);
+        }
+      },
+      events: {
+        input: {
+          blur: () => {
+            this.promptDiv.style.display = "none";
+          }
+        }
+      }
+    });
+
+    this.acWrapper = this.element.closest(".autoComplete_wrapper");
+    this.element.ac = this.autocomplete;
+
+    // Stop input field from bubbling open and close events to parent elements,
+    // because foundation closes modal from these events.
+    const stopPropagation = (event) => {
+      event.stopPropagation();
+    }
+    this.element.addEventListener("close", stopPropagation);
+    this.element.addEventListener("open", stopPropagation);
+
+    this.createPromptDiv();
+
+    switch (this.options.mode) {
+    case "sticky":
+      this.createStickySelect(this.options.name);
+      break;
+    case "multi":
+      this.createMultiSelect(this.options.name);
+      break;
+    default:
+    }
+  }
+
+  setInput(value) {
+    this.autocomplete.input.value = value;
+  }
+
+  handleEvent(event) {
+    switch (this.options.mode) {
+    case "single":
+      this.setInput(event.detail.selection.value[event.detail.selection.key]);
+      break;
+    case "sticky":
+      this.handleStickyEvents(event);
+      break;
+    case "multi":
+      this.handleMultiEvents(event);
+      break;
+    default:
+    }
+  }
+
+  handleMultiEvents(event) {
+    switch (event.type) {
+    case "selection":
+      this.addMultiSelectItem(event.detail.selection);
+      break;
+    default:
+    }
+  }
+
+  handleStickyEvents(event) {
+    switch (event.type) {
+    case "selection":
+      this.addStickySelectItem(event.detail.selection);
+      break;
+    case "click":
+      if (event.target === this.clearStickySelectionSpan) {
+        this.removeStickySelection();
+      }
+      break;
+    case "keyup":
+      if (this.stickyHiddenInput.value !== "" && event.target === this.element && (["Escape", "Backspace", "Delete"].includes(event.key) || (/^[a-z0-9]$/i).test(event.key))) {
+        this.removeStickySelection();
+      } else if (this.options.searchPrompt) {
+        if (this.stickyHiddenInput.value === "" && this.element.value.length < this.options.threshold) {
+          this.promptDiv.style.display = "block";
+        } else {
+          this.promptDiv.style.display = "none";
+        }
+      }
+      break;
+    default:
+    }
+  }
+
+  createHiddenInput(value) {
+    const hiddenInput = document.createElement("input");
+    hiddenInput.name = this.options.name;
+    hiddenInput.type = "hidden";
+    if (value) {
+      hiddenInput.value = value;
+    }
+    this.acWrapper.prepend(hiddenInput);
+    return hiddenInput;
+  }
+
+  removeStickySelection() {
+    this.stickyHiddenInput.value = "";
+    this.element.placeholder = this.options.placeholder;
+    this.clearStickySelectionSpan.style.display = "none";
+    this.stickySelectedSpan.style.display = "none";
+  }
+
+  addStickySelectItem(selection) {
+    this.stickyHiddenInput.value = selection.value.value;
+    this.element.placeholder = "";
+    this.stickySelectedSpan.innerHTML = selection.value[selection.key];
+    this.stickySelectedSpan.style.display = "block";
+    this.clearStickySelectionSpan.style.display = "block";
+    this.setInput("");
+  }
+
+  addMultiSelectItem(selection) {
+    this.setInput("");
+    const chosen = document.createElement("span");
+    chosen.classList.add("label", "primary", "autocomplete__selected-item", "multi");
+    chosen.innerHTML = selection.value[selection.key];
+    const clearSelection = document.createElement("span");
+    clearSelection.classList.add("clear-multi-selection");
+    clearSelection.innerHTML = "&times;";
+    clearSelection.setAttribute("data-remove", selection.value.value);
+    clearSelection.addEventListener("click", (evt) => {
+      const hiddenInput = this.acWrapper.querySelector(`input[type='hidden'][value='${selection.value.value}']`);
+      if (hiddenInput) {
+        hiddenInput.remove();
+        evt.target.parentElement.remove();
+      }
+    });
+    chosen.appendChild(clearSelection);
+
+    const multiSelectWrapper = this.acWrapper.querySelector(".multiselect");
+    const inputContainer = multiSelectWrapper.querySelector("span.input-container");
+    multiSelectWrapper.insertBefore(chosen, inputContainer);
+    this.createHiddenInput(selection.value.value);
+  }
+
+  createStickySelect() {
+    this.stickySelectedSpan = document.createElement("span");
+    this.stickySelectedSpan.classList.add("autocomplete__selected-item", "sticky");
+    this.stickySelectedSpan.style.display = "none";
+    this.stickySelectedSpan.addEventListener("click", () => this.element.focus());
+    this.stickyHiddenInput = this.createHiddenInput();
+
+    this.clearStickySelectionSpan = document.createElement("span");
+    this.clearStickySelectionSpan.className = "clear-sticky-selection";
+    this.clearStickySelectionSpan.innerHTML = "&times;";
+    this.clearStickySelectionSpan.style.display = "none";
+    this.clearStickySelectionSpan.addEventListener("click", this);
+
+    this.element.addEventListener("selection", this);
+    this.element.addEventListener("keyup", this);
+
+    this.acWrapper.insertBefore(this.clearStickySelectionSpan, this.element);
+    this.acWrapper.insertBefore(this.stickySelectedSpan, this.element);
+    if (this.options.selected) {
+      this.addStickySelectItem(this.options.selected);
+    }
+  }
+
+  createMultiSelect() {
+    const multiSelectWrapper = document.createElement("div");
+    multiSelectWrapper.classList.add("multiselect");
+
+    const inputContainer = document.createElement("span");
+    inputContainer.classList.add("input-container");
+
+    multiSelectWrapper.appendChild(inputContainer);
+    this.acWrapper.prepend(multiSelectWrapper);
+    inputContainer.appendChild(this.element);
+
+    this.element.addEventListener("selection", this);
+    multiSelectWrapper.addEventListener("click", () => {
+      this.element.focus();
+    })
+
+    if (this.options.selected) {
+      this.options.selected.forEach((selection) => {
+        this.addMultiSelectItem(selection);
+      })
+    }
+  }
+
+  createPromptDiv() {
+    this.promptDiv = document.createElement("div");
+    this.promptDiv.classList.add("search-prompt");
+    this.promptDiv.style.display = "none";
+    this.promptDiv.innerHTML = this.options.searchPromptText;
+    this.acWrapper.appendChild(this.promptDiv);
+  }
+}