decidim-core 0.30.1 → 0.31.0.rc1

data/lib/decidim/core/test/shared_examples/system_endorse_resource_examples.rb

@@ -1,298 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-shared_context "with resources to be endorsed or not" do
-  include_context "with a component"
-
-  # Should be overridden and create one main resource
-  let!(:resource) { nil }
-  # the name of the resource to be clicked from the component view
-  let(:resource_name) { nil }
-  # Should be overridden and create 3 extra resources in the current component
-  let!(:resources) { nil }
-end
-
-shared_examples "Endorse resource system specs" do
-  def expect_page_not_to_include_endorsements
-    expect(page).to have_no_button("Like")
-    expect(page).to have_no_css("#resource-#{resource.id}-endorsements-count")
-  end
-
-  def visit_resource
-    visit_component
-    click_on resource_name
-  end
-
-  context "when endorsements are not enabled" do
-    let(:component_traits) { [:with_endorsements_disabled] }
-
-    context "when the user is not logged in" do
-      it "does not show the endorse resource button and counts" do
-        visit_resource
-        expect_page_not_to_include_endorsements
-      end
-    end
-
-    context "when the user is logged in" do
-      before do
-        login_as user, scope: :user
-      end
-
-      it "does not show the endorse resource button and counts" do
-        visit_resource
-        expect_page_not_to_include_endorsements
-      end
-    end
-  end
-
-  context "when endorsements are enabled but blocked" do
-    let(:component_traits) { [:with_endorsements_enabled, :with_endorsements_blocked] }
-
-    it "shows the endorsements count and the endorse button is disabled" do
-      visit_resource
-      expect(page).to have_css("#resource-#{resource.id}-endorsement-block button[disabled='true']")
-    end
-  end
-
-  context "when endorsements are enabled" do
-    let(:component_traits) { [:with_endorsements_enabled] }
-
-    context "when the user is not logged in" do
-      it "is given the option to sign in" do
-        visit_resource
-        within "#resource-#{resource.id}-endorsement-block" do
-          click_on "Like"
-        end
-
-        expect(page).to have_css("#loginModal", visible: :visible)
-      end
-    end
-
-    context "when the user is logged in" do
-      before do
-        login_as user, scope: :user
-      end
-
-      context "when the resource is not endorsed yet" do
-        it "is able to endorse the resource" do
-          visit_resource
-          within "#resource-#{resource.id}-endorsement-block" do
-            click_on "Like"
-            expect(page).to have_button("Like")
-            expect(page).to have_css('svg use[href*="ri-heart-fill"]')
-            expect(page).to have_css('#endorsement-button[aria-label="Undo the like"]')
-          end
-        end
-
-        it "has endorsements from other users" do
-          author = create(:user, :confirmed, organization: resource.organization)
-          create(:endorsement, resource:, author:)
-          visit_resource
-          within "#endorser-list-#{resource.id}" do
-            expect(page).to have_content("Liked by #{author.name}")
-            click_on author.name
-          end
-          expect(page).to have_content("Liked by")
-          within "#endorsersModal-#{resource.id}" do
-            expect(page).to have_content(author.name)
-            expect(page).to have_no_content(user.name)
-          end
-        end
-      end
-
-      context "when the resource is already endorsed" do
-        let!(:endorsement) { create(:endorsement, resource:, author: user) }
-
-        it "is not able to endorse it again" do
-          visit_resource
-          within "#resource-#{resource.id}-endorsement-block" do
-            expect(page).to have_css('svg use[href*="ri-heart-fill"]')
-            expect(page).to have_css('#endorsement-button[aria-label="Undo the like"]')
-            expect(page).to have_no_css('svg use[href*="ri-heart-line"]')
-          end
-        end
-
-        it "is able to undo the endorsement" do
-          visit_resource
-          within "#resource-#{resource.id}-endorsement-block" do
-            expect(page).to have_css('svg use[href*="ri-heart-fill"]')
-            expect(page).to have_css('#endorsement-button[aria-label="Undo the like"]')
-            click_on "Like"
-            expect(page).to have_css('svg use[href*="ri-heart-line"]')
-            expect(page).to have_css('#endorsement-button[aria-label="Like"]')
-            expect(page).to have_button("Like")
-          end
-        end
-
-        it "can show the endorsements pop-up" do
-          visit_resource
-          within "#endorser-list-#{resource.id}" do
-            expect(page).to have_content("Liked by you")
-            click_on "you"
-          end
-          expect(page).to have_content("Liked by")
-          within "#endorsersModal-#{resource.id}" do
-            expect(page).to have_content(user.name)
-          end
-        end
-      end
-
-      context "when verification is required" do
-        let(:permissions) do
-          {
-            endorse: {
-              authorization_handlers: {
-                "dummy_authorization_handler" => { "options" => {} }
-              }
-            }
-          }
-        end
-
-        before do
-          organization.available_authorizations = ["dummy_authorization_handler"]
-          organization.save!
-          component.update(permissions:)
-        end
-
-        context "when user is NOT verified" do
-          it "is NOT able to endorse" do
-            visit_resource
-            within "#resource-#{resource.id}-endorsement-block" do
-              click_on "Like"
-            end
-            expect(page).to have_css("#authorizationModal", visible: :visible)
-          end
-        end
-
-        context "when user IS verified" do
-          before do
-            handler_params = { user: }
-            handler_name = "dummy_authorization_handler"
-            handler = Decidim::AuthorizationHandler.handler_for(handler_name, handler_params)
-
-            Decidim::Authorization.create_or_update_from(handler)
-          end
-
-          it "IS able to endorse", :slow do
-            visit_resource
-            within "#resource-#{resource.id}-endorsement-block" do
-              expect(page).to have_css('svg use[href*="ri-heart-line"]')
-              expect(page).to have_css('#endorsement-button[aria-label="Like"]')
-              click_on "Like"
-              expect(page).to have_button("Like")
-              expect(page).to have_css('#endorsement-button[aria-label="Undo the like"]')
-              expect(page).to have_css('svg use[href*="ri-heart-fill"]')
-            end
-          end
-        end
-      end
-
-      context "when user being a part of a group" do
-        let(:component_traits) { [:with_endorsements_enabled] }
-        let!(:user_group) do
-          create(
-            :user_group,
-            :verified,
-            name: "Tester's Organization",
-            nickname: "test_org",
-            email: "t.mail.org@example.org",
-            users: [user],
-            organization:
-          )
-        end
-
-        before do
-          organization.update(user_groups_enabled:)
-          login_as user, scope: :user
-          visit_resource
-        end
-
-        context "when organization is not allowing user groups" do
-          let(:user_groups_enabled) { false }
-
-          it "is able to endorse the resource" do
-            within "#resource-#{resource.id}-endorsement-block" do
-              click_on "Like"
-              expect(page).to have_button("Like")
-              expect(page).to have_css('svg use[href*="ri-heart-fill"]')
-              expect(page).to have_css('#endorsement-button[aria-label="Undo the like"]')
-            end
-          end
-        end
-
-        context "when organization allows user groups" do
-          let(:user_groups_enabled) { true }
-
-          it "opens a modal where you select identity as a user or a group" do
-            click_on "Like"
-            expect(page).to have_content("Select identity")
-            expect(page).to have_content("Tester's Organization")
-            expect(page).to have_content(user.name)
-          end
-
-          def add_likes
-            click_on "Like"
-            within "#user-identities" do
-              click_on "Tester's Organization"
-              click_on user.name
-              click_on "Done"
-            end
-            visit_resource
-            click_on "Like"
-          end
-
-          context "when both identities picked" do
-            it "likes the post as a group and a user" do
-              add_likes
-
-              within ".identities-modal__list" do
-                expect(page).to have_css(".is-selected", count: 2)
-              end
-            end
-          end
-
-          context "when like cancelled as a user" do
-            it "does not cancel group like" do
-              add_likes
-              find(".is-selected", match: :first).click
-              click_on "Done"
-              expect(page).to have_css('svg use[href*="ri-heart-line"]')
-              expect(page).to have_css('#select-identity-button[aria-label="Like"]')
-              visit current_path
-              click_on "Like"
-
-              within ".identities-modal__list" do
-                expect(page).to have_css(".is-selected", count: 1)
-                within ".is-selected" do
-                  expect(page).to have_content("Tester's Organization")
-                end
-              end
-            end
-          end
-
-          context "when like cancelled as a group" do
-            it "does not cancel user like" do
-              add_likes
-              page.all(".is-selected")[1].click
-              click_on "Done"
-              expect(page).to have_css('svg use[href*="ri-heart-fill"]')
-              expect(page).to have_css('#select-identity-button[aria-label="Undo the like"]')
-              visit current_path
-              expect(page).to have_css('svg use[href*="ri-heart-fill"]')
-              expect(page).to have_css('#select-identity-button[aria-label="Undo the like"]')
-              click_on "Like"
-
-              within ".identities-modal__list" do
-                expect(page).to have_css(".is-selected", count: 1)
-                within ".is-selected" do
-                  expect(page).to have_text(user.name, exact: true)
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/decidim/core/test/shared_examples/taxonomizable_interface_examples.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-shared_examples_for "taxonomizable interface" do
-  let!(:root_taxonomy) { create(:taxonomy, organization:) }
-  let!(:taxonomy) { create(:taxonomy, parent: root_taxonomy, organization:) }
-
-  before do
-    model.update(taxonomies: [taxonomy])
-  end
-
-  describe "taxonomies" do
-    let(:query) { "{ taxonomies { id } }" }
-
-    it "has taxonomies" do
-      expect(response).to include("taxonomies" => [{ "id" => taxonomy.id.to_s }])
-    end
-  end
-end

data/lib/decidim/core/test/shared_examples/timestamps_interface_examples.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-shared_examples_for "timestamps interface" do
-  describe "createdAt" do
-    let(:query) { "{ createdAt }" }
-
-    it "returns when was this query created at" do
-      expect(response["createdAt"]).to eq(model.created_at.to_time.iso8601)
-    end
-  end
-
-  describe "updatedAt" do
-    let(:query) { "{ updatedAt }" }
-
-    it "returns when was this query updated at" do
-      expect(response["updatedAt"]).to eq(model.updated_at.to_time.iso8601)
-    end
-  end
-end

data/lib/decidim/core/test/shared_examples/traceable_interface_examples.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-shared_examples_for "traceable interface" do
-  describe "traceable", versioning: true do
-    let(:version_author) { try(:author) || model.try(:creator_identity) || model.try(:normalized_author) }
-
-    before { Decidim.traceability.update!(model, version_author, title: { en: "test" }) }
-
-    context "when field createdAt" do
-      let(:query) { "{ versions { createdAt } }" }
-
-      it "returns created_at field of the version to iso format" do
-        dates = response["versions"].map { |version| version["createdAt"] }
-        expect(dates).to include(*model.versions.map { |version| version.created_at.to_time.iso8601 })
-      end
-    end
-
-    context "when field id" do
-      let(:query) { "{ versions { id } }" }
-
-      it "returns ID field of the version" do
-        ids = response["versions"].map { |version| version["id"].to_i }
-        expect(ids).to include(*model.versions.map(&:id))
-      end
-    end
-
-    context "when field editor" do
-      let(:query) { "{ versions { editor { name } } }" }
-
-      it "returns editor field of the versions" do
-        editors = response["versions"].map { |version| version["editor"]["name"] if version["editor"] }
-        expect(editors).to include(*model.versions.map { |version| version.editor.name if version.respond_to? :editor })
-      end
-    end
-
-    context "when field changeset" do
-      let(:query) { "{ versions { changeset } }" }
-
-      it "returns changeset field of the versions" do
-        changesets = response["versions"].map { |version| version["changeset"] }
-        expect(changesets).to include(*model.versions.map(&:changeset))
-      end
-    end
-  end
-end

data/lib/decidim/download_your_data_serializers/download_your_data_user_group_serializer.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  # This class serializes a User so can be exported to CSV
-  module DownloadYourDataSerializers
-    class DownloadYourDataUserGroupSerializer < Decidim::Exporters::Serializer
-      include Decidim::ResourceHelper
-
-      # Public: Exports a hash with the serialized data for this user.
-      def serialize
-        {
-          id: resource.id,
-          name: resource.name,
-          document_number: resource.document_number,
-          phone: resource.phone,
-          verified_at: resource.verified_at
-        }
-      end
-    end
-  end
-end

data/lib/decidim/endorsable.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  # This concern contains the logic related with resources that can be endorsed.
-  # Thus, it is expected to be included into a resource that is wanted to be endorsable.
-  # This resource will have many `Decidim::Endorsement`s.
-  module Endorsable
-    extend ActiveSupport::Concern
-
-    included do
-      has_many :endorsements,
-               as: :resource,
-               dependent: :destroy,
-               counter_cache: "endorsements_count"
-
-      # Public: Check if the user has endorsed the resource.
-      # - user_group: may be nil if user is not representing any user_group.
-      #
-      # Returns Boolean.
-      def endorsed_by?(user, user_group = nil)
-        if user_group
-          endorsements.where(user_group:).any?
-        else
-          endorsements.where(author: user, user_group: 0).any?
-        end
-      end
-    end
-  end
-end

data/lib/decidim/events/user_group_event.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  module Events
-    # This module is used to be included in event classes inheriting from SimpleEvent
-    # whose resource has an in the "extra" options a user_group in the keyword :group.
-    #
-    # It adds the group_name, group_nickname, group_path and group_url to the i18n interpolations.
-    module UserGroupEvent
-      extend ActiveSupport::Concern
-
-      included do
-        i18n_attributes :group_name, :group_nickname, :group_path, :group_url
-
-        def group_nickname
-          group_presenter&.nickname.to_s
-        end
-
-        def group_name
-          group_presenter&.name.to_s
-        end
-
-        def group_path
-          group_presenter&.profile_path.to_s
-        end
-
-        def group_url
-          group_presenter&.profile_url.to_s
-        end
-
-        def group_presenter
-          return unless group
-
-          @group_presenter ||= Decidim::UserGroupPresenter.new(group)
-        end
-
-        def group
-          @group ||= Decidim::UserGroup.find_by(id: extra[:group_id]) if extra[:group_id]
-        end
-      end
-    end
-  end
-end

data/lib/decidim/hashtag.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  # A hashtag is used to categorize components
-  class Hashtag < ApplicationRecord
-    self.table_name = "decidim_hashtags"
-
-    belongs_to :organization, foreign_key: "decidim_organization_id", class_name: "Decidim::Organization"
-
-    validates :name, presence: true
-    validates :name, uniqueness: { scope: [:decidim_organization_id] }
-  end
-end

data/lib/decidim/metric_manifest.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  # This class acts as a manifest for metrics.
-  #
-  # This manifest is a simple object that holds and stores currently available
-  # metrics and its managers, for calculations purpose
-  #
-  class MetricManifest
-    include ActiveModel::Model
-    include Decidim::AttributeObject::Model
-
-    attribute :metric_name, String
-    attribute :manager_class, String
-
-    validates :metric_name, :manager_class, presence: true
-
-    def has_settings?
-      settings.attributes.any?
-    end
-
-    def settings(&block)
-      @settings ||= SettingsManifest.new
-      yield(@settings) if block
-      @settings
-    end
-
-    # stat_block is a non-required parameter
-    # This method make it easier to retrieve it,
-    #  and gives an empty string if it is not configured
-    def stat_block
-      settings.attributes[:stat_block].try(:[], :default) || ""
-    end
-  end
-end

data/lib/decidim/metric_operation.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  class MetricOperation
-    # Public: Registers a operation for metrics
-    #
-    # metric_operation - a symbol representing the name of the operation involved
-    # metric_name - a symbol representing the name of the metric involved
-    #
-    # Returns nothing. Raises an error if there is already a metric
-    # registered with that metric name.
-    def register(metric_operation, metric_name)
-      metric_operation = metric_operation.to_s
-      metric_name = metric_name.to_s
-      metric_exists = self.for(metric_operation, metric_name).present?
-
-      if metric_exists
-        raise(
-          MetricOperationAlreadyRegistered,
-          "There is a metric already registered with the name `:#{metric_name}`, must be unique"
-        )
-      end
-
-      metric_manifest = MetricOperationManifest.new(metric_operation:, metric_name:)
-
-      yield(metric_manifest)
-
-      metric_manifest.validate!
-
-      metrics_manifests << metric_manifest
-    end
-
-    # Searches for MetricOperationManifest(s) depending on parameters
-    # With 'metric_operation' only:
-    #   - Returns all manifest related to that operation
-    # With 'metric_operation' and 'metric_name':
-    #   - Returns a single manifest related to that two params
-    def for(metric_operation, metric_name = nil)
-      if metric_name
-        all.find { |manifest| manifest.metric_operation == metric_operation.to_s && manifest.metric_name == metric_name.to_s }
-      else
-        all.find_all { |manifest| manifest.metric_operation == metric_operation.to_s }
-      end
-    end
-
-    def all
-      metrics_manifests
-    end
-
-    class MetricOperationAlreadyRegistered < StandardError; end
-
-    private
-
-    def metrics_manifests
-      @metrics_manifests ||= []
-    end
-  end
-end

data/lib/decidim/metric_operation_manifest.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Decidim
-  # This class acts as a manifest for metrics operations.
-  #
-  # This manifest is an expansion from Decidim::MetricManifest that holds and stores
-  # operations, metrics and measure class, for operations purpose
-  #
-  class MetricOperationManifest < Decidim::MetricManifest
-    attribute :metric_operation, String
-
-    validates :metric_operation, presence: true
-
-    def calculate(day, resource)
-      operation = manager_class.constantize.new(day, resource)
-      return unless operation.valid?
-
-      operation.calculate
-    end
-  end
-end