decidim-core 0.7.4 → 0.8.0

data/app/helpers/decidim/feature_path_helper.rb

@@ -9,7 +9,8 @@ module Decidim
     #
     # Returns a url.
     def main_feature_path(feature)
-      EngineRouter.main_proxy(feature).root_path
+      current_params = try(:params) || {}
+      EngineRouter.main_proxy(feature).root_path(locale: current_params[:locale])
     end
 
     # Returns the defined admin root path for a given feature.
@@ -18,7 +19,8 @@ module Decidim
     #
     # Returns a url.
     def manage_feature_path(feature)
-      EngineRouter.admin_proxy(feature).root_path
+      current_params = try(:params) || {}
+      EngineRouter.admin_proxy(feature).root_path(locale: current_params[:locale])
     end
   end
 end

data/app/helpers/decidim/layout_helper.rb

@@ -51,9 +51,7 @@ module Decidim
     #
     # Returns an <img /> tag with the SVG icon.
     def external_icon(path, options = {})
-      # Ugly hack to prevent PhantomJS from freaking out with SVGs.
       classes = _icon_classes(options) + ["external-icon"]
-      return content_tag(:span, "?", class: classes.join(" "), "data-src" => path) if Rails.env.test?
 
       if path.split(".").last == "svg"
         asset = Rails.application.assets_manifest.find_sources(path).first

data/app/helpers/decidim/menu_helper.rb

@@ -12,5 +12,15 @@ module Decidim
         active_class: "main-nav__link--active"
       )
     end
+
+    # Public: Returns the user menu presenter object
+    def user_menu
+      @user_menu ||= ::Decidim::InlineMenuPresenter.new(
+        :user_menu,
+        self,
+        element_class: "tabs-title",
+        active_class: "is-active"
+      )
+    end
   end
 end

data/app/helpers/decidim/messaging/conversation_helper.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Messaging
+    module ConversationHelper
+      #
+      # Builds a link to the conversation between the current user and another
+      # user.
+      #
+      # * If there's no current user, it links to the login form.
+      #
+      # * If there's no prior existing conversation between the users, it links
+      #   to the new conversation form.
+      #
+      # * Otherwise, it links to the existing conversation.
+      #
+      # @param user [Decidim::User] The user to link to a conversation with
+      #
+      # @return [String] The resulting route
+      #
+      def link_to_current_or_new_conversation_with(user)
+        return decidim.new_user_session_path unless user_signed_in?
+
+        conversation_between = UserConversations.for(current_user).find do |conversation|
+          conversation.participants.to_set == [current_user, user].to_set
+        end
+
+        if conversation_between
+          decidim.conversation_path(conversation_between)
+        else
+          decidim.new_conversation_path(recipient_id: user.id)
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/sanitize_helper.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Decidim
+  # Helper that provides methods to render order selector and links
+  module SanitizeHelper
+    include ActionView::Helpers::SanitizeHelper
+
+    # Public: It sanitizes a user-inputted string with the
+    # `Decidim::UserInputScrubber` scrubber, so that video embeds work
+    # as expected. Uses Rails' `sanitize` internally.
+    #
+    # html - A string representing user-inputted HTML.
+    #
+    # Returns an HTML-safe String.
+    def decidim_sanitize(html)
+      sanitize(html, scrubber: Decidim::UserInputScrubber.new)
+    end
+  end
+end

data/app/helpers/decidim/traceability_helper.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A Helper to find and render the author of a version.
+  module TraceabilityHelper
+    include Decidim::SanitizeHelper
+    # Renders the avatar and author name of the author of the last version of the given
+    # resource.
+    #
+    # resource - an object implementing `Decidim::Traceable`
+    #
+    # Returns an HTML-safe String representing the HTML to render the author.
+    def render_resource_last_editor(resource)
+      render partial: "decidim/shared/version_author",
+             locals: {
+               author: Decidim.traceability.last_editor(resource)
+             }
+    end
+
+    # Renders the avatar and author name of the author of the given version.
+    #
+    # version - an object that responds to `whodunnit` and returns a String.
+    #
+    # Returns an HTML-safe String representing the HTML to render the author.
+    def render_resource_editor(version)
+      render partial: "decidim/shared/version_author",
+             locals: {
+               author: Decidim.traceability.version_editor(version)
+             }
+    end
+
+    # Caches a DiffRenderer instance for the `current_version`.
+    def diff_renderer
+      @diff_renderer ||= Decidim::Accountability::DiffRenderer.new(current_version)
+    end
+
+    # Renders the diff between `:old_data` and `:new_data` keys in the `data` param.
+    #
+    # data - A Hash with `old_data`, `:new_data` and `:type` keys.
+    #
+    # Returns an HTML-safe string.
+    def render_diff_data(data)
+      content_tag(:div, class: "card card--list diff diff-#{data[:type]}") do
+        if [:i18n, :i18n_html].include?(data[:type])
+          render_diff_value(
+            " ",
+            data[:type],
+            nil,
+            data: {
+              old_value: data[:old_value].to_s.gsub("</p>", "</p>\n"),
+              new_value: data[:new_value].to_s.gsub("</p>", "</p>\n")
+            }
+          )
+        else
+          render_diff_value(data[:old_value], data[:type], :removal) +
+            render_diff_value(data[:new_value], data[:type], :addition)
+        end
+      end
+    end
+
+    private
+
+    # Renders the given value in a user-friendly way based on the value class.
+    #
+    # value - an object to be rendered
+    #
+    # Returns an HTML-ready String.
+    def render_diff_value(value, type, action, options = {})
+      return "".html_safe if value.blank?
+
+      value_to_render = case type
+                        when :date
+                          l value, format: :long
+                        when :percentage
+                          number_to_percentage value, precision: 2
+                        else
+                          value
+                        end
+
+      content_tag(:div, class: "card--list__item #{action}") do
+        content_tag(:div, class: "card--list__text") do
+          content_tag(:div, { class: "diff__value" }.merge(options)) do
+            value_to_render
+          end
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/translations_helper.rb

@@ -4,14 +4,16 @@ module Decidim
   # Helper that provides convenient methods to deal with translated attributes.
   module TranslationsHelper
     # Public: Returns the translation of an attribute using the current locale,
-    # if available.
+    # if available. Checks for the organization default locale as fallback.
     #
     # attribute - A Hash where keys (strings) are locales, and their values are
     #             the translation for each locale.
     #
     # Returns a String with the translation.
     def translated_attribute(attribute)
-      attribute.try(:[], I18n.locale.to_s) || ""
+      attribute.try(:[], I18n.locale.to_s).presence ||
+        attribute.try(:[], current_organization.default_locale).presence ||
+        ""
     end
 
     # Public: Creates a translation for each available language in the list

data/app/helpers/decidim/view_hooks_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  # This module includes helpers to manage view hooks in layout
+  module ViewHooksHelper
+    # Public: Renders all hooks registered as `hook_name`.
+    #
+    # hook_name - a Symbol representing the name of the hook.
+    #
+    # Returns an HTML safe String.
+    def render_hook(hook_name)
+      Decidim.view_hooks.render(hook_name, self)
+    end
+  end
+end

data/app/jobs/decidim/email_notification_generator_job.rb

@@ -2,7 +2,7 @@
 
 module Decidim
   class EmailNotificationGeneratorJob < ApplicationJob
-    queue_as :decidim_events
+    queue_as :events
 
     def perform(event, event_class_name, resource, recipient_ids, extra)
       event_class = event_class_name.constantize

data/app/jobs/decidim/notification_generator_for_recipient_job.rb

@@ -2,7 +2,7 @@
 
 module Decidim
   class NotificationGeneratorForRecipientJob < ApplicationJob
-    queue_as :decidim_events
+    queue_as :events
 
     def perform(event, event_class_name, resource, recipient_id, extra)
       event_class = event_class_name.constantize

data/app/jobs/decidim/notification_generator_job.rb

@@ -2,7 +2,7 @@
 
 module Decidim
   class NotificationGeneratorJob < ApplicationJob
-    queue_as :decidim_events
+    queue_as :events
 
     def perform(event, event_class_name, resource, recipient_ids, extra)
       event_class = event_class_name.constantize

data/app/mailers/decidim/messaging/conversation_mailer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Messaging
+    # A custom mailer for sending notifications to users when they receive
+    # private messages
+    class ConversationMailer < Decidim::ApplicationMailer
+      def new_conversation(originator, user, conversation)
+        notification_mail(
+          from: originator,
+          to: user,
+          conversation: conversation,
+          action: "new_conversation"
+        )
+      end
+
+      def new_message(sender, user, conversation)
+        notification_mail(
+          from: sender,
+          to: user,
+          conversation: conversation,
+          action: "new_conversation"
+        )
+      end
+
+      private
+
+      def notification_mail(from:, to:, conversation:, action:)
+        with_user(to) do
+          @organization = to.organization
+          @conversation = conversation
+          @sender = from.name
+          @recipient = to.name
+          @host = @organization.host
+
+          subject = I18n.t(
+            "conversation_mailer.#{action}.subject",
+            scope: "decidim.messaging",
+            sender: @sender
+          )
+
+          mail(to: to.email, subject: subject)
+        end
+      end
+    end
+  end
+end

data/app/mailers/decidim/newsletter_mailer.rb

@@ -2,6 +2,7 @@
 
 module Decidim
   class NewsletterMailer < ApplicationMailer
+    helper Decidim::SanitizeHelper
     add_template_helper Decidim::TranslationsHelper
 
     def newsletter(user, newsletter)

data/app/models/decidim/abilities/base_ability.rb

@@ -25,8 +25,12 @@ module Decidim
           merge ability.constantize.new(user, context)
         end
 
-        can :manage, Authorization do |authorization|
-          authorization.user == user
+        can :create, Authorization do |authorization|
+          authorization.user == user && not_already_active?(user, authorization)
+        end
+
+        can :update, Authorization do |authorization|
+          authorization.user == user && !authorization.granted?
         end
 
         can :manage, Follow do |follow|
@@ -36,6 +40,16 @@ module Decidim
         can :manage, Notification do |notification|
           notification.user == user
         end
+
+        can :manage, Messaging::Conversation do |conversation|
+          conversation.participants.include?(user)
+        end
+      end
+
+      private
+
+      def not_already_active?(user, authorization)
+        Verifications::Authorizations.new(user: user, name: authorization.name).none?
       end
     end
   end

data/app/models/decidim/authorization.rb

@@ -11,16 +11,34 @@ module Decidim
   # depending on the response it allows the creation of the authorization or
   # not.
   class Authorization < ApplicationRecord
-    belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User", inverse_of: :authorizations
+    mount_uploader :verification_attachment, Decidim::Verifications::AttachmentUploader
+
+    belongs_to :user, foreign_key: "decidim_user_id", class_name: "Decidim::User"
 
     validates :name, uniqueness: { scope: :decidim_user_id }
+    validates :verification_metadata, absence: true, if: :granted?
+    validates :verification_attachment, absence: true, if: :granted?
 
     validate :active_handler?
 
+    def grant!
+      remove_verification_attachment!
+
+      update!(granted_at: Time.zone.now, verification_metadata: {})
+    end
+
+    def granted?
+      !granted_at.nil?
+    end
+
     private
 
     def active_handler?
-      AuthorizationHandler.active_handler?(name)
+      if Decidim::Verifications.find_workflow_manifest(name)
+        true
+      else
+        false
+      end
     end
   end
 end

data/app/models/decidim/messaging/conversation.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Messaging
+    #
+    # Holds a conversation between a number of participants. Each conversation
+    # would be equivalent to an entry in your Telegram conversation list, be it
+    # a group or a one-to-one conversation.
+    #
+    class Conversation < ApplicationRecord
+      has_many :participations, foreign_key: :decidim_conversation_id,
+                                class_name: "Decidim::Messaging::Participation",
+                                dependent: :destroy,
+                                inverse_of: :conversation
+
+      has_many :participants, through: :participations
+
+      has_many :messages, foreign_key: :decidim_conversation_id,
+                          class_name: "Decidim::Messaging::Message",
+                          dependent: :destroy,
+                          inverse_of: :conversation
+
+      has_many :receipts, through: :messages
+
+      scope :unread_by, lambda { |user|
+        joins(:receipts).merge(Receipt.unread_by(user)).distinct
+      }
+
+      delegate :mark_as_read, to: :receipts
+
+      #
+      # Initiates a conversation between a user and a set of interlocutors with
+      # an initial message. Works just like .start, but saves all the dependent
+      # objects into DB.
+      #
+      # @param (see .start)
+      #
+      # @return (see .start)
+      #
+      def self.start!(originator:, interlocutors:, body:)
+        conversation = start(
+          originator: originator,
+          interlocutors: interlocutors,
+          body: body
+        )
+
+        conversation.save!
+
+        conversation
+      end
+
+      #
+      # Initiates a conversation between a user and a set of interlocutors with
+      # an initial message.
+      #
+      # @param originator [Decidim::User] The user starting the conversation
+      # @param interlocutors [Array<Decidim::User>] The set of interlocutors in
+      #   the conversation (not including the originator).
+      # @param body [String] The content of the initial message
+      #
+      # @return [Decidim::Messaging::Conversation] The newly created conversation
+      #
+      def self.start(originator:, interlocutors:, body:)
+        conversation = new(participants: [originator] + interlocutors)
+
+        conversation.add_message(sender: originator, body: body)
+
+        conversation
+      end
+
+      # Appends a message to this conversation and saves everything to DB.
+      #
+      # @param (see #add_message)
+      #
+      # @return (see #add_message)
+      #
+      def add_message!(sender:, body:)
+        add_message(sender: sender, body: body)
+
+        save!
+      end
+
+      #
+      # Appends a message to this conversation
+      #
+      # @param sender [Decidim::User] The sender of the message
+      # @param body [String] The content of the message
+      #
+      # @return [Decidim::Messaging::Message] The newly created message
+      #
+      def add_message(sender:, body:)
+        message = messages.build(sender: sender, body: body)
+
+        message.envelope_for(interlocutors(sender))
+
+        message
+      end
+
+      #
+      # Given a user, returns her interlocutors in this conversation
+      #
+      # @param user [Decidim::User] The user to find interlocutors for
+      #
+      # @return [Array<Decidim::User>]
+      #
+      def interlocutors(user)
+        participants.reject { |participant| participant.id == user.id }
+      end
+
+      #
+      # The most recent message in this conversation
+      #
+      # @return [Decidim::Messaging::Message]
+      #
+      def last_message
+        messages.last
+      end
+
+      #
+      # The number of messages in this conversation a user has not yet read
+      #
+      # @return [Integer]
+      #
+      def unread_count(user)
+        receipts.unread_by(user).count
+      end
+    end
+  end
+end