decidim-decidim_awesome 0.6.7 → 0.8.1

data/app/helpers/decidim/decidim_awesome/amendments_helper_override.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module AmendmentsHelperOverride
+      extend ActiveSupport::Concern
+
+      included do
+        # original method
+        alias_method :decidim_amendments_form_field_for, :amendments_form_field_for
+
+        # override with custom fields if scope applies
+        def amendments_form_field_for(attribute, form, original_resource)
+          custom_fields = awesome_custom_fields(attribute, form)
+          return decidim_amendments_form_field_for(attribute, form, original_resource) if custom_fields.blank?
+
+          render_amendment_custom_fields_override(custom_fields, attribute, form, original_resource)
+        end
+
+        private
+
+        def render_amendment_custom_fields_override(fields, attribute, form, original_resource)
+          custom_fields = Decidim::DecidimAwesome::CustomFields.new(fields)
+          custom_fields.translate!
+          body = amendments_form_fields_value(original_resource, attribute)
+          custom_fields.apply_xml(body) if body.present?
+          # TODO: find a way to add errors as form is not the parent form
+          # form.object.errors.add(attribute, custom_fields.errors) if custom_fields.errors
+          render partial: "decidim/decidim_awesome/custom_fields/form_render", locals: { spec: custom_fields.to_json, form: form, name: attribute }
+        end
+
+        # Amendments don't use a URL specifying participatory space and component
+        # context for awesome config constraints must be obtained from the resource
+        def awesome_custom_fields(attribute, _form)
+          return unless attribute == :body
+
+          component = amendable.try(:component)
+          return unless component
+          return if component.settings.participatory_texts_enabled?
+
+          awesome_config = Decidim::DecidimAwesome::Config.new(component.organization)
+          awesome_config.context_from_component(component)
+          awesome_config.collect_sub_configs_values("proposal_custom_field")
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/decidim_awesome/map_helper.rb

@@ -5,13 +5,23 @@ module Decidim
     module MapHelper
       include Decidim::MapHelper
 
+      def api_ready?
+        Decidim::Api::Schema.max_complexity >= 1300
+      end
+
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity:
       def awesome_map_for(components, &block)
-        return legacy_map_for(components, &block) unless defined?(Decidim::Map)
+        return unless map_utility_dynamic
 
-        map = dynamic_map_for({}, {}, &block)
-        return unless map
+        map = awesome_builder.map_element({ class: "google-map", id: "awesome-map-container" }, &block)
+        help = content_tag(:div, class: "map__help") do
+          sr_content = content_tag(:p, t("screen_reader_explanation", scope: "decidim.map.dynamic"), class: "show-for-sr")
+
+          sr_content
+        end
 
-        map_html_options = {
+        html_options = {
           "class" => "awesome-map",
           "id" => "awesome-map",
           "data-components" => components.map do |component|
@@ -23,75 +33,53 @@ module Decidim
                                    amendments: component.manifest.name == :proposals ? Decidim::Proposals::Proposal.where(component: component).only_emendations.count : 0
                                  }
                                end.to_json,
-          "data-collapsed" => current_component.settings.collapse,
-          "data-truncate" => current_component.settings.truncate,
-          "data-map-center" => current_component.settings.map_center,
-          "data-map-zoom" => current_component.settings.map_zoom,
-          "data-menu-amendments" => current_component.settings.menu_amendments,
-          "data-menu-meetings" => current_component.settings.menu_meetings,
-          "data-menu-hashtags" => current_component.settings.menu_hashtags,
-          "data-show-not-answered" => current_component.current_settings.show_not_answered,
-          "data-show-accepted" => current_component.current_settings.show_accepted,
-          "data-show-withdrawn" => current_component.current_settings.show_withdrawn,
-          "data-show-evaluating" => current_component.current_settings.show_evaluating,
-          "data-show-rejected" => current_component.current_settings.show_rejected
-        }
-        content_tag(:div, map, map_html_options)
-      end
-
-      # TODO: remove when 0.22 support is diched
-      def legacy_map_for(components)
-        return if Decidim.geocoder.blank?
-
-        map_html_options = {
-          class: "google-map",
-          id: "map",
-          "data-components" => components.map do |component|
-                                 {
-                                   id: component.id,
-                                   type: component.manifest.name,
-                                   name: translated_attribute(component.name),
-                                   url: Decidim::EngineRouter.main_proxy(component).root_path,
-                                   amendments: component.manifest.name == :proposals ? Decidim::Proposals::Proposal.where(component: component).only_emendations.count : 0
-                                 }
-                               end.to_json,
-          "data-collapsed" => current_component.settings.collapse,
-          "data-show-not-answered" => current_component.current_settings.show_not_answered,
-          "data-show-accepted" => current_component.current_settings.show_accepted,
-          "data-show-withdrawn" => current_component.current_settings.show_withdrawn,
-          "data-show-evaluating" => current_component.current_settings.show_evaluating,
-          "data-show-rejected" => current_component.current_settings.show_rejected,
-          "data-markers-data" => [].to_json
+          "data-hide-controls" => settings_source.try(:hide_controls),
+          "data-collapsed" => global_settings.collapse,
+          "data-truncate" => global_settings.truncate || 255,
+          "data-map-center" => global_settings.map_center,
+          "data-map-zoom" => global_settings.map_zoom || 8,
+          "data-menu-merge-components" => global_settings.menu_merge_components,
+          "data-menu-amendments" => global_settings.menu_amendments,
+          "data-menu-meetings" => global_settings.menu_meetings,
+          "data-menu-categories" => global_settings.menu_categories,
+          "data-menu-hashtags" => global_settings.menu_hashtags,
+          "data-show-not-answered" => step_settings&.show_not_answered,
+          "data-show-accepted" => step_settings&.show_accepted,
+          "data-show-withdrawn" => step_settings&.show_withdrawn,
+          "data-show-evaluating" => step_settings&.show_evaluating,
+          "data-show-rejected" => step_settings&.show_rejected
         }
 
-        if Decidim.geocoder[:here_api_key]
-          map_html_options["data-here-api-key"] = Decidim.geocoder[:here_api_key]
-        else
-          # Compatibility mode for old api_id/app_code configurations
-          map_html_options["data-here-app-id"] = Decidim.geocoder[:here_app_id]
-          map_html_options["data-here-app-code"] = Decidim.geocoder[:here_app_code]
+        content_tag(:div, html_options) do
+          content_tag :div, class: "row column" do
+            help + map
+          end
         end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity:
 
-        content = capture { yield }.html_safe
-        help = content_tag(:div, class: "map__help") do
-          content_tag(:p, I18n.t("screen_reader_explanation", scope: "decidim.map.dynamic"), class: "show-for-sr")
-        end
-        content_tag :div, class: "awesome-map" do
-          map = content_tag(:div, "", map_html_options)
+      def step_settings
+        settings_source.try(:current_settings)
+      end
 
-          help + map + content
-        end
+      def global_settings
+        settings_source.try(:settings)
+      end
+
+      def settings_source
+        try(:current_component) || self
       end
 
       # rubocop:disable Rails/HelperInstanceVariable
-      def current_categories
+      def current_categories(categories)
         return @current_categories if @current_categories
 
         @golden_ratio_conjugate = 0.618033988749895
         # @h = rand # use random start value
-        @h = 0.4
+        @h = 0.41
         @current_categories = []
-        current_participatory_space.categories.first_class.each do |category|
+        categories.first_class.each do |category|
           append_category category
           category.subcategories.each do |subcat|
             append_category subcat
@@ -102,11 +90,35 @@ module Decidim
 
       private
 
+      def awesome_builder
+        options = {
+          popup_template_id: "marker-popup",
+          markers: []
+        }
+        builder = map_utility_dynamic.create_builder(self, options)
+
+        # We need awesome map listeners before initialize the official map
+        unless snippets.any?(:awesome_map)
+          snippets.add(:awesome_map, javascript_pack_tag("decidim_decidim_awesome_map", defer: false))
+          snippets.add(:awesome_map, stylesheet_pack_tag("decidim_decidim_awesome_map"))
+          snippets.add(:head, snippets.for(:awesome_map))
+        end
+
+        unless snippets.any?(:map)
+          snippets.add(:map, builder.stylesheet_snippets)
+          snippets.add(:map, builder.javascript_snippets)
+          snippets.add(:head, snippets.for(:map))
+        end
+
+        builder
+      end
+
+      # rubocop:disable Style/FormatStringToken
       def append_category(category)
         @h += @golden_ratio_conjugate
         @h %= 1
         # r,g,b = hsv_to_rgb(@h, 0.5, 0.95)
-        r, g, b = hsv_to_rgb(@h, 0.99, 0.96)
+        r, g, b = hsv_to_rgb(@h, 0.99, 0.95)
         @current_categories.append(
           id: category.id,
           name: translated_attribute(category.name),
@@ -114,11 +126,12 @@ module Decidim
           color: format("#%02x%02x%02x", r, g, b)
         )
       end
+      # rubocop:enable Style/FormatStringToken
       # rubocop:enable Rails/HelperInstanceVariable
 
-      # rubocop:disable Naming/UncommunicativeMethodParamName
       # HSV values in [0..1[
       # returns [r, g, b] values from 0 to 255
+      # rubocop:disable Naming/MethodParameterName
       def hsv_to_rgb(h, s, v)
         h_i = (h * 6).to_i
         f = h * 6 - h_i
@@ -157,7 +170,7 @@ module Decidim
         end
         [(r * 256).to_i, (g * 256).to_i, (b * 256).to_i]
       end
-      # rubocop:enable Naming/UncommunicativeMethodParamName
     end
+    # rubocop:enable Naming/MethodParameterName
   end
 end

data/app/helpers/decidim/decidim_awesome/proposals/application_helper_override.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    module Proposals
+      module ApplicationHelperOverride
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method :decidim_text_editor_for_proposal_body, :text_editor_for_proposal_body
+          alias_method :decidim_safe_content?, :safe_content?
+
+          # replace safe content to consider all custom fields save (then embeded html will be rendered)
+          def safe_content?
+            awesome_proposal_custom_fields.present? || decidim_safe_content?
+          end
+
+          # replace normal method to draw the editor
+          def text_editor_for_proposal_body(form)
+            custom_fields = awesome_proposal_custom_fields
+
+            return decidim_text_editor_for_proposal_body(form) if custom_fields.blank?
+
+            render_proposal_custom_fields_override(custom_fields, form, :body)
+          end
+
+          # replace admin method to draw the editor (multi lang)
+          def admin_editor_for_proposal_body(form)
+            custom_fields = awesome_proposal_custom_fields
+
+            return form.translated(:editor, :body, hashtaggable: true) if custom_fields.blank?
+
+            locales = form.send(:locales)
+
+            return render_proposal_custom_fields_override(custom_fields, form, "body_#{locales.first}", locales.first) if locales.length == 1
+
+            tabs_id = form.send(:sanitize_tabs_selector, form.options[:tabs_id] || "#{form.object_name}-body-tabs")
+
+            label_tabs = form.content_tag(:div, class: "label--tabs") do
+              field_label = form.send(:label_i18n, "body", form.label_for("proposal_custom_fields"))
+
+              language_selector = "".html_safe
+              language_selector = form.create_language_selector(locales, tabs_id, "body") if form.options[:label] != false
+
+              safe_join [field_label, language_selector]
+            end
+
+            tabs_content = form.content_tag(:div, class: "tabs-content", data: { tabs_content: tabs_id }) do
+              locales.each_with_index.inject("".html_safe) do |string, (locale, index)|
+                tab_content_id = "#{tabs_id}-body-panel-#{index}"
+                string + content_tag(:div, class: form.send(:tab_element_class_for, "panel", index), id: tab_content_id) do
+                  render_proposal_custom_fields_override(custom_fields, form, "body_#{locale}", locale)
+                end
+              end
+            end
+
+            safe_join [label_tabs, tabs_content]
+          end
+
+          def render_proposal_custom_fields_override(fields, form, name, locale = nil)
+            custom_fields = Decidim::DecidimAwesome::CustomFields.new(fields)
+            custom_fields.translate!
+
+            body = if form_presenter.proposal.body.is_a?(Hash) && locale.present?
+                     form_presenter.body(extras: false, all_locales: true).with_indifferent_access[locale]
+                   else
+                     form_presenter.body(extras: false)
+                   end
+
+            custom_fields.apply_xml(body) if body.present?
+            form.object.errors.add(name, custom_fields.errors) if custom_fields.errors
+            render partial: "decidim/decidim_awesome/custom_fields/form_render", locals: { spec: custom_fields.to_json, form: form, name: name }
+          end
+        end
+      end
+    end
+  end
+end

data/app/jobs/decidim/decidim_awesome/migrate_legacy_images_job.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    class MigrateLegacyImagesJob < ApplicationJob
+      queue_as :default
+
+      def perform(organization_id, mappings = [], logger = Rails.logger)
+        @organization_id = organization_id
+        @routes_mappings = mappings
+        @logger = logger
+
+        migrate_all!
+        transform_images_urls
+      end
+
+      private
+
+      attr_reader :routes_mappings, :logger
+
+      def migrate_all!
+        Decidim::CarrierWaveMigratorService.migrate_attachment!(
+          klass: Decidim::DecidimAwesome::EditorImage,
+          cw_attribute: "image",
+          cw_uploader: Decidim::Cw::DecidimAwesome::ImageUploader,
+          as_attribute: "file",
+          logger: @logger,
+          routes_mappings: routes_mappings
+        )
+      end
+
+      def transform_images_urls
+        mappings = routes_mappings.map do |mapping|
+          klass, id = mapping[:instance].split("#")
+          next unless klass == "Decidim::DecidimAwesome::EditorImage"
+
+          instance = Decidim::DecidimAwesome::EditorImage.find_by(id: id)
+
+          next if instance.blank?
+
+          mapping.merge!(instance: instance)
+        end.compact
+
+        editor_images_available_attributes.each do |model, attributes|
+          model.all.each do |item|
+            attributes.each do |attribute|
+              item.update(attribute => rewrite_value(item.send(attribute), mappings))
+            end
+          end
+          @logger.info "Updated model #{model.name} (attributes: #{attributes.join(", ")})"
+        end
+      end
+
+      def rewrite_value(value, mappings)
+        if value.is_a?(Hash)
+          value.transform_values do |nested_value|
+            rewrite_value(nested_value, mappings)
+          end
+        else
+          parser = Decidim::DecidimAwesome::ContentParsers::EditorImagesParser.new(value, routes_mappings: mappings)
+          parser.rewrite
+        end
+      end
+
+      def editor_images_available_attributes
+        {
+          "Decidim::Accountability::Result" => %w(description),
+          "Decidim::Proposals::Proposal" => %w(body answer cost_report execution_period),
+          "Decidim::Votings::Voting" => %w(description),
+          "Decidim::Elections::Question" => %w(description),
+          "Decidim::Elections::Answer" => %w(description),
+          "Decidim::Elections::Election" => %w(description),
+          "Decidim::Initiative" => %w(description answer),
+          "Decidim::InitiativesType" => %w(description extra_fields_legal_information),
+          "Decidim::Assembly" => %w(short_description description purpose_of_action composition internal_organisation announcement closing_date_reason special_features),
+          "Decidim::Forms::Questionnaire" => %w(description tos),
+          "Decidim::Forms::Question" => %w(description),
+          "Decidim::Organization" => %w(welcome_notification_body admin_terms_of_use_body description highlighted_content_banner_short_description id_documents_explanation_text),
+          "Decidim::StaticPage" => %w(content),
+          "Decidim::ContextualHelpSection" => %w(content),
+          "Decidim::Category" => %w(description),
+          "Decidim::Blogs::Post" => %w(body),
+          "Decidim::Pages::Page" => %w(body),
+          "Decidim::Sortitions::Sortition" => %w(additional_info witnesses cancel_reason),
+          "Decidim::Consultations::Question" => %w(title question_context what_is_decided instructions),
+          "Decidim::Consultation" => %w(description),
+          "Decidim::Debates::Debate" => %w(description instructions information_updates conclusions),
+          "Decidim::Budgets::Budget" => %w(description),
+          "Decidim::Budgets::Project" => %w(description),
+          "Decidim::ConferenceSpeaker" => %w(short_bio),
+          "Decidim::Conferences::RegistrationType" => %w(description),
+          "Decidim::Conference" => %w(short_description description objectives registration_terms),
+          "Decidim::ParticipatoryProcessGroup" => %w(description),
+          "Decidim::ParticipatoryProcess" => %w(short_description description announcement),
+          "Decidim::ParticipatoryProcessStep" => %w(description),
+          "Decidim::Meetings::AgendaItem" => %w(description),
+          "Decidim::Meetings::Meeting" => %w(registration_terms description registration_email_custom_content closing_report)
+        }.each_with_object({}) do |(main_model, attributes), hash|
+          hash[main_model.constantize] = attributes
+        rescue NameError
+          hash
+        end
+      end
+    end
+  end
+end

data/app/middleware/decidim/decidim_awesome/current_config.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+module Decidim
+  module DecidimAwesome
+    # A middleware that stores the current awesome context by parsing the request
+    class CurrentConfig
+      # Initializes the Rack Middleware.
+      #
+      # app - The Rack application
+      def initialize(app)
+        @app = app
+      end
+
+      # Main entry point for a Rack Middleware.
+      #
+      # env - A Hash.
+      def call(env)
+        @request = Rack::Request.new(env)
+        if @request.env["decidim.current_organization"] && processable_path?
+          @config = awesome_config_instance
+          env["decidim_awesome.current_config"] = @config
+          tamper_user_model
+          add_flash_message_from_request(env)
+
+          # puts "requested path: #{env["PATH_INFO"]}"
+          # puts "current_organization: #{@request.env["decidim.current_organization"]&.id}"
+          # puts "potential_admins: #{Decidim::User.awesome_potential_admins}"
+          # puts "scoped admins: #{Decidim::User.awesome_admins_for_current_scope}"
+        else
+          reset_user_model
+        end
+
+        @app.call(env)
+      end
+
+      private
+
+      # a workaround to set a flash message if comming from the error controller (route not found)
+      def add_flash_message_from_request(env)
+        return unless scoped_admins_active?
+        return unless @request.params.has_key? "unauthorized"
+
+        env["rack.session"]["flash"] = ActionDispatch::Flash::FlashHash.new(alert: I18n.t("decidim.core.actions.unauthorized")).to_session_value
+      end
+
+      def awesome_config_instance
+        @awesome_config_instance = Config.new @request.env["decidim.current_organization"]
+        @awesome_config_instance.context_from_request @request
+        @awesome_config_instance
+      end
+
+      def reset_user_model
+        return unless scoped_admins_active?
+
+        Decidim::User.awesome_potential_admins = []
+        Decidim::User.awesome_admins_for_current_scope = []
+      end
+
+      def tamper_user_model
+        return unless scoped_admins_active?
+
+        Decidim::User.awesome_potential_admins = potential_admins
+
+        Decidim::User.awesome_admins_for_current_scope = if safe_get_route? || safe_post_route?
+                                                           Decidim::User.awesome_potential_admins
+                                                         else
+                                                           valid_admins
+                                                         end
+      end
+
+      def potential_admins
+        @config.collect_sub_configs_values("scoped_admin") do |subconfig|
+          subconfig&.constraints&.detect { |c| c.settings["participatory_space_manifest"] == "none" } ? false : true
+        end.flatten.uniq.map(&:to_i)
+      end
+
+      def valid_admins
+        @config.collect_sub_configs_values("scoped_admin") do |subconfig|
+          # allow index controllers if scoped to a subspace/component
+          constraints = subconfig&.constraints || []
+          additional_constraints = additional_get_constraints(constraints) + additional_post_constraints(constraints)
+          # inject additional constraints here for further use
+          @config.inject_sub_config_constraints("scoped_admin", subconfig.var[13..], additional_constraints) if subconfig
+          @config.valid_in_context?(constraints + additional_constraints)
+        end.flatten.uniq.map(&:to_i)
+      end
+
+      # avoid unnecessary processing for non-user routes
+      def processable_path?
+        return true if safe_get_route?
+
+        spaces = ContextAnalyzers::RequestAnalyzer.participatory_spaces_routes.keys.join("|^(/admin){0,1}/")
+        case @request.path
+        when %r{"|^(/admin){0,1}/#{spaces}}
+          true
+        when %r{^/admin/}
+          true
+        end
+      end
+
+      def safe_get_route?
+        return unless @request.get?
+
+        case @request.path
+        when "/"
+          true
+        when "/admin/"
+          true
+        when %r{^/admin/admin_terms}
+          true
+        when %r{^/profiles/|^/notifications/|^/conversations/|^/pages/}
+          true
+        end
+      end
+
+      def safe_post_route?
+        return unless @request.post? || @request.put? || @request.patch?
+
+        case @request.path
+        when %r{^/admin/admin_terms}
+          true
+        end
+      end
+
+      # to access certain deeper routes it requires first to click on a parent route, even without Post permissions in there
+      # this adds this additional routes to these cases
+      # For instance:
+      #        accessing /admin/participatory_processes/som-procress requires access first to /admin/participatory_processes
+      def additional_get_constraints(constraints)
+        return [] unless @request.get?
+
+        additions = []
+        constraints.each do |constraint|
+          next if constraint.settings["participatory_space_manifest"].blank?
+
+          # processes groups must give access to processes generic url
+          if constraint.settings["participatory_space_manifest"] == "process_groups"
+            additions << OpenStruct.new(settings: { "participatory_space_manifest" => "participatory_processes", "match" => "exclusive" })
+          end
+
+          # adds a exclusive constraint to the parent participatory space (so index page can be accessed)
+          next unless constraint.settings.size > 1
+
+          additions << OpenStruct.new(settings: {
+                                        "participatory_space_manifest" => constraint.settings["participatory_space_manifest"],
+                                        "match" => "exclusive"
+                                      })
+        end
+
+        additions
+      end
+
+      # adds access to REST routes with id instead of the slug ot allow editing
+      # rubocop:disable Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/PerceivedComplexity
+      def additional_post_constraints(constraints)
+        return [] unless @request.post? || @request.patch?
+
+        constraints.filter_map do |constraint|
+          settings = constraint.settings.dup
+          next unless settings["participatory_space_manifest"].present? && settings["participatory_space_slug"].present?
+
+          # replicate the constraint with the id of the participatory space
+          manifest = Decidim.participatory_space_manifests.find { |s| s.name.to_s == settings["participatory_space_manifest"] }
+          next unless manifest
+
+          model = manifest.model_class_name.try(:constantize)
+          next unless model
+
+          settings["participatory_space_slug"] = model.find_by(slug: settings["participatory_space_slug"])&.id
+          OpenStruct.new(settings: settings) if settings["participatory_space_slug"]
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/PerceivedComplexity
+
+      def scoped_admins_active?
+        Decidim::User.respond_to?(:awesome_admins_for_current_scope) && Decidim::User.respond_to?(:awesome_potential_admins)
+      end
+    end
+  end
+end

data/app/models/decidim/decidim_awesome/awesome_config.rb

@@ -15,9 +15,24 @@ module Decidim
       validates :organization, presence: true
       validates :var, uniqueness: { scope: :decidim_organization_id }
 
+      def additional_constraints
+        @additional_constraints ||= []
+      end
+
+      def add_constraints(constraints)
+        return if constraints.blank?
+
+        additional_constraints.concat(constraints.respond_to?(:each) ? constraints : [constraints])
+      end
+
       def self.for_organization(organization)
         where(organization: organization)
       end
+
+      # use this instead of "constraints" to evaluate dynamically added constants
+      def all_constraints
+        constraints + additional_constraints
+      end
     end
   end
 end

data/app/models/decidim/decidim_awesome/editor_image.rb

@@ -3,6 +3,8 @@
 module Decidim
   module DecidimAwesome
     class EditorImage < ApplicationRecord
+      include Decidim::HasUploadValidations
+
       self.table_name = "decidim_awesome_editor_images"
 
       belongs_to :author, foreign_key: :decidim_author_id, class_name: "Decidim::User"
@@ -11,15 +13,8 @@ module Decidim
       validates :organization, presence: true
       validates :author, presence: true
 
-      validates :image, presence: true
-      # validates :image,
-      #           file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_attachment_size } },
-      #           file_content_type: { allow: ["image/jpeg", "image/png"] }
-
-      mount_uploader :image, Decidim::DecidimAwesome::ImageUploader
-
-      delegate :url, to: :image
-      delegate :thumbnail, to: :image
+      has_one_attached :file
+      validates_upload :file, uploader: Decidim::DecidimAwesome::ImageUploader
     end
   end
 end