decidim-admin 0.21.0 → 0.23.2

data/app/helpers/decidim/admin/application_helper.rb

@@ -13,6 +13,7 @@ module Decidim
       include Decidim::MapHelper
       include Decidim::Admin::LogRenderHelper
       include Decidim::Admin::UserRolesHelper
+      include Decidim::Admin::ResourceScopeHelper
 
       def title
         current_organization.name

data/app/helpers/decidim/admin/filterable_helper.rb

@@ -5,44 +5,46 @@ module Decidim
     # Helper that provides methods related to Decidim::Admin::Filterable concern.
     module FilterableHelper
       # Renders the filters selector with tags in the admin panel.
-      def admin_filter_selector
-        render partial: "decidim/admin/shared/filters"
+      def admin_filter_selector(i18n_ctx = nil)
+        render partial: "decidim/admin/shared/filters", locals: { i18n_ctx: i18n_ctx }
       end
 
       # Builds a tree of links from Decidim::Admin::Filterable::filters_with_values
-      def submenu_options_tree
+      def submenu_options_tree(i18n_ctx = nil)
+        i18n_scope = filterable_i18n_scope_from_ctx(i18n_ctx)
+
         filters_with_values.each_with_object({}) do |(filter, values), hash|
-          link = filter_link_label(filter)
+          link = filter_link_label(filter, i18n_scope)
           hash[link] = if values.is_a?(Array)
-                         build_submenu_options_tree_from_array(filter, values)
+                         build_submenu_options_tree_from_array(filter, values, i18n_scope)
                        elsif values.is_a?(Hash)
-                         build_submenu_options_tree_from_hash(filter, values)
+                         build_submenu_options_tree_from_hash(filter, values, i18n_scope)
                        end
         end
       end
 
       # Builds a tree of links from an array. The tree will have only one level.
-      def build_submenu_options_tree_from_array(filter, values)
+      def build_submenu_options_tree_from_array(filter, values, i18n_scope)
         links = []
-        links += extra_dropdown_submenu_options_items(filter)
-        links += values.map { |value| filter_link_value(filter, value) }
+        links += extra_dropdown_submenu_options_items(filter, i18n_scope)
+        links += values.map { |value| filter_link_value(filter, value, i18n_scope) }
         links.each_with_object({}) { |link, hash| hash[link] = nil }
       end
 
       # To be overriden. Useful for adding links that do not match with the filter.
       # Must return an Array.
-      def extra_dropdown_submenu_options_items(_filter)
+      def extra_dropdown_submenu_options_items(_filter, _i18n_scope)
         []
       end
 
       # Builds a tree of links from an Hash. The tree can have many levels.
-      def build_submenu_options_tree_from_hash(filter, values)
+      def build_submenu_options_tree_from_hash(filter, values, i18n_scope)
         values.each_with_object({}) do |(key, value), hash|
-          link = filter_link_value(filter, key)
+          link = filter_link_value(filter, key, i18n_scope)
           hash[link] = if value.nil?
                          nil
                        elsif value.is_a?(Hash)
-                         build_submenu_options_tree_from_hash(filter, value)
+                         build_submenu_options_tree_from_hash(filter, value, i18n_scope)
                        end
         end
       end
@@ -63,21 +65,21 @@ module Decidim
         end
       end
 
-      def filter_link_label(filter)
-        link_to(i18n_filter_label(filter), href: "#")
+      def filter_link_label(filter, i18n_scope)
+        link_to(i18n_filter_label(filter, i18n_scope), href: "#")
       end
 
-      def filter_link_value(filter, value)
-        link_to(i18n_filter_value(filter, value), query_params_with(filter => value))
+      def filter_link_value(filter, value, i18n_scope)
+        link_to(i18n_filter_value(filter, value, i18n_scope), query_params_with(filter => value))
       end
 
-      def i18n_filter_label(filter)
-        t("decidim.admin.filters.#{filter}.label")
+      def i18n_filter_label(filter, i18n_scope)
+        t("#{i18n_scope}.#{filter}.label")
       end
 
-      def i18n_filter_value(filter, value)
-        if I18n.exists?("decidim.admin.filters.#{filter}.values.#{value}")
-          t(value, scope: "decidim.admin.filters.#{filter}.values")
+      def i18n_filter_value(filter, value, i18n_scope)
+        if I18n.exists?("#{i18n_scope}.#{filter}.values.#{value}")
+          t(value, scope: "#{i18n_scope}.#{filter}.values")
         else
           find_dynamic_translation(filter, value)
         end
@@ -94,16 +96,16 @@ module Decidim
         html.join.html_safe
       end
 
-      def applied_filters_tags
+      def applied_filters_tags(i18n_ctx)
         ransack_params.slice(*filters).map do |filter, value|
-          applied_filter_tag(filter, value)
+          applied_filter_tag(filter, value, filterable_i18n_scope_from_ctx(i18n_ctx))
         end.join.html_safe
       end
 
-      def applied_filter_tag(filter, value)
+      def applied_filter_tag(filter, value, i18n_scope)
         content_tag(:span, class: "label secondary") do
-          concat "#{i18n_filter_label(filter)}: "
-          concat i18n_filter_value(filter, value)
+          concat "#{i18n_filter_label(filter, i18n_scope)}: "
+          concat i18n_filter_value(filter, value, i18n_scope)
           concat remove_filter_icon_link(filter)
         end
       end
@@ -116,6 +118,12 @@ module Decidim
           class: "action-icon--remove"
         )
       end
+
+      def filterable_i18n_scope_from_ctx(i18n_ctx)
+        i18n_scope = "decidim.admin.filters"
+        i18n_scope += ".#{i18n_ctx}" if i18n_ctx
+        i18n_scope
+      end
     end
   end
 end

data/app/helpers/decidim/admin/icon_link_helper.rb

@@ -23,7 +23,7 @@ module Decidim
                 target: options[:target]) do
           content_tag(:span, data: { tooltip: true, disable_hover: false, click_open: false },
                              title: title) do
-            icon(icon_name)
+            icon(icon_name, aria_label: title, role: "img")
           end
         end
       end

data/app/helpers/decidim/admin/newsletters_helper.rb

@@ -141,9 +141,11 @@ module Decidim
       end
 
       def newsletter_recipients_count_callout_args
+        spinner = "<span id='recipients_count_spinner' class='loading-spinner hide'></span>"
+        body = "#{t("recipients_count", scope: "decidim.admin.newsletters.select_recipients_to_deliver", count: recipients_count_query)} #{spinner}"
         {
           announcement: {
-            body: t("recipients_count", scope: "decidim.admin.newsletters.select_recipients_to_deliver", count: recipients_count_query)
+            body: body
           },
           callout_class: "warning"
         }

data/app/helpers/decidim/admin/resource_scope_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # This module includes helpers to show scopes in admin
+    module ResourceScopeHelper
+      # Public: This helper shows the th with the scope label.
+      #
+      # scope_label - I18n translation to show
+      #
+      def th_resource_scope_label(scope_label = t("decidim.admin.resources.index.headers.scope"))
+        return unless resource_with_scopes_enabled?
+
+        content_tag(:th, scope_label)
+      end
+
+      # Public: This helper shows the td for the given scope.
+      #
+      # current_scope - Scope object to show
+      #
+      def td_resource_scope_for(current_scope)
+        return unless resource_with_scopes_enabled?
+
+        scope_name = if current_scope
+                       translated_attribute(current_scope.name)
+                     else
+                       t("decidim.scopes.global")
+                     end
+        content_tag(:td, scope_name)
+      end
+
+      private
+
+      def resource_with_scopes_enabled?
+        if defined? current_component
+          current_component.scopes_enabled? || current_participatory_space.scopes_enabled?
+        else
+          current_participatory_space.scopes_enabled?
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/admin/settings_helper.rb

@@ -5,11 +5,15 @@ module Decidim
     # This class contains helpers needed in order for component settings to
     # properly render.
     module SettingsHelper
+      include Decidim::ScopesHelper
+
       TYPES = {
         boolean: :check_box,
         integer: :number_field,
         string: :text_field,
-        text: :text_area
+        text: :text_area,
+        scope: :scope_field,
+        enum: :collection_radio_buttons
       }.freeze
 
       # Public: Renders a form field that matches a settings attribute's
@@ -22,67 +26,67 @@ module Decidim
       # options   - Extra options to be passed to the field helper.
       #
       # Returns a rendered form field.
-      def settings_attribute_input(form, attribute, name, options = {})
-        if name == :amendments_visibility
-          amendments_visibility_form_field(form, options)
-        elsif attribute.translated?
-          form_method = form_method_for_attribute(attribute)
-          tab_options = { tabs_id: "#{options[:tabs_prefix]}-#{name}-tabs" }
-          extra_options = tab_options.merge(extra_options_for_type(form_method))
-          form.send(:translated, form_method, name, options.merge(extra_options))
-        else
-          form_method = form_method_for_attribute(attribute)
-          extra_options = extra_options_for(name).merge(extra_options_for_type(form_method))
-          form.send(form_method, name, options.merge(extra_options))
+      def settings_attribute_input(form, attribute, name, i18n_scope, options = {})
+        form_method = form_method_for_attribute(attribute)
+
+        container_class = "#{name}_container"
+        if options[:readonly]
+          container_class += " readonly_container"
+          help_text = text_for_setting(name, "readonly", i18n_scope)
         end
-      end
+        help_text ||= text_for_setting(name, "help", i18n_scope)
+        help_text_options = help_text ? { help_text: help_text } : {}
 
-      # Returns a translation or nil. If nil, ZURB Foundation won't add the help_text.
-      def help_text_for_component_setting(field_name, settings_name, component_name)
-        key = "decidim.components.#{component_name}.settings.#{settings_name}.#{field_name}_help"
-        return t(key) if I18n.exists?(key)
+        options = { label: t(name, scope: i18n_scope) }
+                  .merge(help_text_options)
+                  .merge(extra_options_for_type(form_method))
+                  .merge(options)
+
+        content_tag(:div, class: container_class) do
+          if attribute.translated?
+            options[:tabs_id] = "#{options.delete(:tabs_prefix)}-#{name}-tabs"
+            form.send(:translated, form_method, name, options)
+          elsif form_method == :collection_radio_buttons
+            render_enum_form_field(form, attribute, name, i18n_scope, options)
+          elsif form_method == :scope_field
+            scopes_picker_field(form, name)
+          else
+            form.send(form_method, name, options)
+          end
+        end.html_safe
       end
 
       private
 
-      # Returns a radio buttons collection input for the component's step setting
-      # :amendments_visibility; all wrap in a label tag and with help text.
-      def amendments_visibility_form_field(form, options)
-        html = label_tag(:amendments_visibility) do
+      # Returns a radio buttons collection input for the given attribute
+      def render_enum_form_field(form, attribute, name, i18n_scope, options)
+        html = label_tag(name) do
           concat options[:label]
           concat tag(:br)
-          concat form.collection_radio_buttons(:amendments_visibility,
-                                               Decidim::Amendment::VisibilityStepSetting.options,
+          concat form.collection_radio_buttons(name,
+                                               build_enum_choices(name, i18n_scope, attribute.build_choices),
                                                :last,
                                                :first,
-                                               { checked: form.object.amendments_visibility },
-                                               amendments_extra_options) { |b| b.label { b.radio_button + b.text } }
+                                               { checked: form.object.send(name) },
+                                               options) { |b| b.label { b.radio_button + b.text } }
         end
-        html << content_tag(:p, help_text_for_component_setting(:amendments_visibility, :step, :proposals), class: "help-text")
-        html.html_safe
+        html << content_tag(:p, options[:help_text], class: "help-text") if options[:help_text]
+        html
+      end
+
+      # Returns a translation or nil. If nil, ZURB Foundation won't add the help_text.
+      def text_for_setting(name, suffix, i18n_scope)
+        key = "#{i18n_scope}.#{name}_#{suffix}"
+        return t(key) if I18n.exists?(key)
       end
 
+      # Returns the FormBuilder's method used to render
       def form_method_for_attribute(attribute)
         return :editor if attribute.type.to_sym == :text && attribute.editor?
 
         TYPES[attribute.type.to_sym]
       end
 
-      # Handles special cases.
-      # Returns an empty Hash or a Hash with extra HTML options.
-      def extra_options_for(field_name)
-        case field_name
-        when :participatory_texts_enabled
-          participatory_texts_extra_options
-        when :amendment_creation_enabled,
-            :amendment_reaction_enabled,
-            :amendment_promotion_enabled
-          amendments_extra_options
-        else
-          {}
-        end
-      end
-
       # Handles special cases.
       # Returns an empty Hash or a Hash with extra HTML options.
       def extra_options_for_type(input_type)
@@ -94,22 +98,11 @@ module Decidim
         end
       end
 
-      # Marks :participatory_texts_enabled setting with a CSS class if the
-      # Proposals component has existing proposals, so it can be identified
-      # in "decidim/admin/form.js". Also, adds a help_text.
-      def participatory_texts_extra_options
-        return {} unless Decidim::Proposals::Proposal.where(component: @component).any?
-
-        {
-          class: "participatory_texts_disabled",
-          help_text: help_text_for_component_setting(:participatory_texts_disabled, :global, :proposals)
-        }
-      end
-
-      # Marks component_step_settings related to amendments with a CSS class,
-      # so they can be identified in "decidim/admin/form.js".
-      def amendments_extra_options
-        { class: "amendments_step_settings" }
+      # Build options for enum attributes
+      def build_enum_choices(name, i18n_scope, choices)
+        choices.map do |choice|
+          [t("#{name}_choices.#{choice}", scope: i18n_scope), choice]
+        end
       end
     end
   end

data/app/helpers/decidim/admin/uploader_image_dimensions_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # This class contains helpers needed to obtain information about
+    # image dimensions from the processors defined in the specific image's Uploader class
+    module UploaderImageDimensionsHelper
+      # Find the dimensions info of a model's image field and get the first value for dimensions ([w, h])
+      #
+      # model - The model to which the image belongs (An instance of `ActiveRecord`)
+      # image_name - The attribute name for the image (either a `symbol` or a `string`)
+      #
+      # Returns an integer array with [width, height]
+      def image_dimensions(model, image_name)
+        versions = model.send(image_name).dimensions_info
+        [:small, :medium, :default].map { |v| versions.dig(v, :dimensions) }.compact.first
+      end
+
+      # Find the first value for the processed image width
+      def image_width(model, image_name)
+        image_dimensions(model, image_name)[0]
+      end
+
+      # Find the first value for the processed image height
+      def image_height(model, image_name)
+        image_dimensions(model, image_name)[1]
+      end
+    end
+  end
+end

data/app/models/decidim/admin/fake_newsletter.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Admin
+    # This class is used to generate fake newsletters and data to preview
+    # newsletter templates.
+    class FakeNewsletter
+      def initialize(organization, manifest)
+        @organization = organization
+        @manifest = manifest
+      end
+
+      def id
+        1
+      end
+
+      def template
+        @template ||= Decidim::ContentBlock.new(
+          in_preview: true,
+          manifest_name: manifest.name,
+          scope_name: :newsletter_template,
+          settings: manifest.settings.attributes.inject({}) do |acc, (name, attrs)|
+            value = if attrs.preview.respond_to?(:call)
+                      attrs.preview.call
+                    else
+                      attrs.preview
+                    end
+
+            acc.update(name => value)
+          end
+        )
+      end
+
+      def subject
+        organization.available_locales.inject({}) do |acc, locale|
+          acc.update(locale => "Lorem ipsum")
+        end
+      end
+
+      def sent_at
+        nil
+      end
+
+      private
+
+      attr_reader :organization, :manifest
+    end
+  end
+end

data/app/permissions/decidim/admin/permissions.rb

@@ -31,6 +31,7 @@ module Decidim
 
         if user.admin? && admin_terms_accepted?
           allow! if read_admin_log_action?
+          allow! if read_metrics_action?
           allow! if static_page_action?
           allow! if organization_action?
           allow! if user_action?
@@ -44,13 +45,13 @@ module Decidim
           allow! if permission_action.subject == :scope_type
           allow! if permission_action.subject == :area
           allow! if permission_action.subject == :area_type
-          allow! if permission_action.subject == :oauth_application
           allow! if permission_action.subject == :user_group
           allow! if permission_action.subject == :officialization
           allow! if permission_action.subject == :authorization
           allow! if permission_action.subject == :authorization_workflow
           allow! if permission_action.subject == :static_page_topic
           allow! if permission_action.subject == :help_sections
+          allow! if permission_action.subject == :share_token
         end
 
         permission_action
@@ -96,6 +97,11 @@ module Decidim
         end
       end
 
+      def read_metrics_action?
+        permission_action.subject == :metrics &&
+          permission_action.action == :read
+      end
+
       def read_admin_log_action?
         permission_action.subject == :admin_log &&
           permission_action.action == :read