decidim-conferences 0.15.1 → 0.16.0

data/app/controllers/decidim/conferences/admin/registration_types_controller.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # Controller that allows managing conference speakers.
+      #
+      class RegistrationTypesController < Decidim::Conferences::Admin::ApplicationController
+        include Concerns::ConferenceAdmin
+        include Decidim::ApplicationHelper
+
+        def index
+          enforce_permission_to :index, :registration_type
+
+          @registration_types = collection.page(params[:page]).per(15)
+        end
+
+        def new
+          enforce_permission_to :create, :registration_type
+          @form = form(Decidim::Conferences::Admin::RegistrationTypeForm).instance
+        end
+
+        def create
+          enforce_permission_to :create, :registration_type
+          @form = form(Decidim::Conferences::Admin::RegistrationTypeForm).from_params(params)
+
+          CreateRegistrationType.call(@form, current_user, current_conference) do
+            on(:ok) do
+              flash[:notice] = I18n.t("registration_types.create.success", scope: "decidim.admin")
+              redirect_to conference_registration_types_path(current_conference)
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("registration_types.create.error", scope: "decidim.admin")
+              render :new
+            end
+          end
+        end
+
+        def edit
+          @registration_type = collection.find(params[:id])
+          enforce_permission_to :update, :registration_type, registration_type: @registration_type
+          @form = form(Decidim::Conferences::Admin::RegistrationTypeForm).from_model(@registration_type)
+        end
+
+        def update
+          @registration_type = collection.find(params[:id])
+          enforce_permission_to :update, :registration_type, registration_type: @registration_type
+          @form = form(Decidim::Conferences::Admin::RegistrationTypeForm).from_params(params)
+
+          UpdateRegistrationType.call(@form, @registration_type) do
+            on(:ok) do
+              flash[:notice] = I18n.t("registration_types.update.success", scope: "decidim.admin")
+              redirect_to conference_registration_types_path(current_conference)
+            end
+
+            on(:invalid) do
+              flash.now[:alert] = I18n.t("registration_types.update.error", scope: "decidim.admin")
+              render :edit
+            end
+          end
+        end
+
+        def destroy
+          @registration_type = collection.find(params[:id])
+          enforce_permission_to :destroy, :registration_type, registration_type: @registration_type
+
+          DestroyRegistrationType.call(@registration_type, current_user) do
+            on(:ok) do
+              flash[:notice] = I18n.t("registration_types.destroy.success", scope: "decidim.admin")
+              redirect_to conference_registration_types_path(current_conference)
+            end
+          end
+        end
+
+        private
+
+        def collection
+          @collection ||= Decidim::Conferences::RegistrationType.where(conference: current_conference)
+        end
+      end
+    end
+  end
+end

data/app/controllers/decidim/conferences/application_controller.rb

@@ -6,6 +6,8 @@ module Decidim
     class ApplicationController < Decidim::ApplicationController
       helper Decidim::ApplicationHelper
       helper Decidim::ResourceHelper
+      helper Decidim::Conferences::ConferenceHelper
+
       include NeedsPermission
 
       private

data/app/controllers/decidim/conferences/conference_registrations_controller.rb

@@ -7,7 +7,7 @@ module Decidim
       def create
         enforce_permission_to :join, :conference, conference: conference
 
-        JoinConference.call(conference, current_user) do
+        JoinConference.call(conference, registration_type, current_user) do
           on(:ok) do
             flash[:notice] = I18n.t("conference_registrations.create.success", scope: "decidim.conferences")
             redirect_after_path
@@ -23,7 +23,7 @@ module Decidim
       def destroy
         enforce_permission_to :leave, :conference, conference: conference
 
-        LeaveConference.call(conference, current_user) do
+        LeaveConference.call(conference, registration_type, current_user) do
           on(:ok) do
             flash[:notice] = I18n.t("conference_registrations.destroy.success", scope: "decidim.conferences")
             redirect_after_path
@@ -58,6 +58,10 @@ module Decidim
         @conference ||= Conference.find_by(slug: params[:conference_slug])
       end
 
+      def registration_type
+        conference.registration_types.find_by(id: params[:registration_type_id])
+      end
+
       def redirect_after_path
         referer = request.headers["Referer"]
         return redirect_to(conference_path(conference)) if referer =~ /invitation_token/

data/app/controllers/decidim/conferences/conferences_controller.rb

@@ -27,6 +27,10 @@ module Decidim
         check_current_user_can_visit_space
       end
 
+      def user_diploma
+        render layout: "decidim/diploma"
+      end
+
       private
 
       def current_participatory_space

data/app/controllers/decidim/conferences/registration_types_controller.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    class RegistrationTypesController < Decidim::Conferences::ApplicationController
+      include ParticipatorySpaceContext
+
+      participatory_space_layout only: :index
+
+      helper_method :collection, :conference
+
+      def index
+        raise ActionController::RoutingError, "No registration types for this conference " if registration_types.empty? && current_participatory_space.registrations_enabled.empty?
+        enforce_permission_to :list, :registration_types
+        redirect_to decidim_conferences.conference_path(current_participatory_space) unless current_user_can_visit_space?
+      end
+
+      private
+
+      def registration_types
+        @registration_types ||= current_participatory_space.registration_types.published
+      end
+
+      alias collection registration_types
+
+      def current_participatory_space
+        return unless params[:conference_slug]
+
+        @current_participatory_space ||= OrganizationConferences.new(current_organization).query.where(slug: params[:conference_slug]).or(
+          OrganizationConferences.new(current_organization).query.where(id: params[:conference_slug])
+        ).first!
+      end
+
+      def conference
+        current_participatory_space
+      end
+    end
+  end
+end

data/app/events/decidim/conferences/conference_registration_notification_event.rb

@@ -0,0 +1,21 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Conferences
+    class ConferenceRegistrationNotificationEvent < Decidim::Events::BaseEvent
+      include Decidim::Events::NotificationEvent
+
+      def notification_title
+        I18n.t("notification_title", i18n_options).html_safe
+      end
+
+      def i18n_options
+        {
+          resource_title: resource_title,
+          resource_url: resource_url,
+          scope: event_name
+        }
+      end
+    end
+  end
+end

data/app/forms/decidim/conferences/admin/conference_form.rb

@@ -49,8 +49,8 @@ module Decidim
         validates :banner_image, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_attachment_size } }, file_content_type: { allow: ["image/jpeg", "image/png"] }
         validate :available_slots_greater_than_or_equal_to_registrations_count, if: ->(form) { form.registrations_enabled? && form.available_slots.positive? }
 
-        validates :start_date, presence: true, date: { before: :end_date }
-        validates :end_date, presence: true, date: { after: :start_date }
+        validates :start_date, presence: true, date: { before_or_equal_to: :end_date }
+        validates :end_date, presence: true, date: { after_or_equal_to: :start_date }
 
         def map_model(model)
           self.scope_id = model.decidim_scope_id
@@ -61,6 +61,7 @@ module Decidim
         end
 
         def processes_for_select
+          return unless Decidim.participatory_space_manifests.map(&:name).include?(:participatory_processes)
           @processes_for_select ||= Decidim.find_participatory_space_manifest(:participatory_processes)
                                            .participatory_spaces.call(current_organization)&.order(title: :asc)&.map do |process|
             [
@@ -71,6 +72,7 @@ module Decidim
         end
 
         def assemblies_for_select
+          return unless Decidim.participatory_space_manifests.map(&:name).include?(:assemblies)
           @assemblies_for_select ||= Decidim.find_participatory_space_manifest(:assemblies)
                                             .participatory_spaces.call(current_organization)&.order(title: :asc)&.map do |assembly|
             [
@@ -81,6 +83,7 @@ module Decidim
         end
 
         def consultations_for_select
+          return unless Decidim.participatory_space_manifests.map(&:name).include?(:consultations)
           @consultations_for_select ||= Decidim.find_participatory_space_manifest(:consultations)
                                                .participatory_spaces.call(current_organization)&.order(title: :asc)&.map do |consultation|
             [

data/app/forms/decidim/conferences/admin/conference_registration_invite_form.rb

@@ -6,9 +6,11 @@ module Decidim
       # A form object used to invite users to join a conference.
       #
       class ConferenceRegistrationInviteForm < Form
+        include TranslatableAttributes
         attribute :name, String
         attribute :email, String
         attribute :user_id, Integer
+        attribute :registration_type_id, Integer
         attribute :existing_user, Boolean, default: false
 
         validates :name, presence: true, unless: proc { |object| object.existing_user }
@@ -18,6 +20,19 @@ module Decidim
         def user
           @user ||= current_organization.users.find_by(id: user_id)
         end
+
+        def registration_type
+          @registration_type ||= current_participatory_space.registration_types.find_by(id: registration_type_id)
+        end
+
+        def registration_types_for_select
+          @registration_types_for_select ||= current_participatory_space.registration_types&.map do |registration_type|
+            [
+              translated_attribute(registration_type.title),
+              registration_type.id
+            ]
+          end
+        end
       end
     end
   end

data/app/forms/decidim/conferences/admin/diploma_form.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A form object used to update conference diploma configuration
+      # from the admin dashboard
+      #
+      class DiplomaForm < Form
+        mimic :conference
+
+        attribute :main_logo
+        attribute :signature
+        attribute :signature_name, String
+        attribute :sign_date, Decidim::Attributes::LocalizedDate
+
+        validates :signature_name, :sign_date, :main_logo, :signature, presence: true
+
+        validates :main_logo, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_attachment_size } }, file_content_type: { allow: ["image/jpeg", "image/png"] }
+        validates :signature, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_attachment_size } }, file_content_type: { allow: ["image/jpeg", "image/png"] }
+      end
+    end
+  end
+end

data/app/forms/decidim/conferences/admin/registration_type_form.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A form object used to create conference registration types from the admin dashboard.
+      class RegistrationTypeForm < Form
+        include TranslatableAttributes
+        include Decidim::ApplicationHelper
+
+        mimic :conference_registration_type
+
+        translatable_attribute :title, String
+        translatable_attribute :description, String
+
+        attribute :weight, Integer
+        attribute :price, Decimal
+        attribute :conference_meeting_ids, Array[Integer]
+
+        validates :title, :description, :weight, presence: true
+        validates :weight, numericality: { greater_than_or_equal_to: 0 }
+        validates :price, numericality: { greater_than_or_equal_to: 0 }, if: ->(form) { form.price.present? }
+
+        def meetings
+          meeting_components = current_participatory_space.components.where(manifest_name: "meetings")
+          @meetings ||= Decidim::ConferenceMeeting.where(component: meeting_components)
+                                                   &.order(title: :asc)
+                                                   &.map do |meeting|
+                                                     OpenStruct.new(
+                                                       title: present(meeting).title,
+                                                       value: meeting.id
+                                                     )
+                                                   end
+        end
+
+        def conference_meetings
+          meeting_components = current_participatory_space.components.where(manifest_name: "meetings")
+          return unless meeting_components || conference_meeting_ids.delete("").present?
+          @conference_meetings ||= Decidim::ConferenceMeeting.where(component: meeting_components).where(id: conference_meeting_ids)
+        end
+      end
+    end
+  end
+end

data/app/helpers/decidim/conferences/conference_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Decidim
+  # A Helper to render conferences.
+  module Conferences
+    module ConferenceHelper
+      # Renders the dates of a conference
+      #
+      def render_date(conference)
+        return l(conference.start_date, format: :decidim_with_month_name_short) if conference.start_date == conference.end_date
+        "#{l(conference.start_date, format: :decidim_with_month_name_short)} - #{l(conference.end_date, format: :decidim_with_month_name_short)}"
+      end
+    end
+  end
+end

data/app/jobs/decidim/conferences/admin/send_conference_diploma_job.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      class SendConferenceDiplomaJob < ApplicationJob
+        queue_as :conference_diplomas
+
+        def perform(conference)
+          confirmed_registrations = conference.conference_registrations.confirmed
+          return unless confirmed_registrations.any?
+
+          confirmed_registrations.each do |registration_confirmed|
+            SendConferenceDiplomaMailer.diploma(conference, registration_confirmed.user).deliver_now
+          end
+        end
+      end
+    end
+  end
+end

data/app/jobs/decidim/conferences/upcoming_conference_notification_job.rb

@@ -21,7 +21,7 @@ module Decidim
           event: "decidim.events.conferences.upcoming_conference",
           event_class: Decidim::Conferences::UpcomingConferenceEvent,
           resource: conference,
-          recipient_ids: conference.followers.pluck(:id)
+          followers: conference.followers
         )
       end
 

data/app/mailers/decidim/conferences/admin/invite_join_conference_mailer.rb

@@ -19,13 +19,14 @@ module Decidim
         # user - The user being invited
         # conference - The conference being joined.
         # invited_by - The user performing the invitation.
-        def invite(user, conference, invited_by)
+        def invite(user, conference, registration_type, invited_by)
           with_user(user) do
             @user = user
             @conference = conference
             @invited_by = invited_by
             @organization = @conference.organization
             @locator = Decidim::ResourceLocatorPresenter.new(@conference)
+            @registration_type = registration_type
 
             subject = I18n.t("invite.subject", scope: "decidim.conferences.mailer.invite_join_conference_mailer")
             mail(to: user.email, subject: subject)

data/app/mailers/decidim/conferences/admin/send_conference_diploma_mailer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A custom mailer for sending the diploma of the conference to
+      # a registered user who attends to the conference.
+      class SendConferenceDiplomaMailer < Decidim::ApplicationMailer
+        include Decidim::TranslationsHelper
+        include Decidim::SanitizeHelper
+
+        helper Decidim::ResourceHelper
+        helper Decidim::TranslationsHelper
+
+        # Send an email to an user with the diploma of conference attendance attached.
+        #
+        # user - The user being invited
+        # conference - The conference being joined.
+        def diploma(conference, user)
+          with_user(user) do
+            @user = user
+            @conference = conference
+            @organization = @conference.organization
+            @locator = Decidim::ResourceLocatorPresenter.new(@conference)
+
+            add_diploma_attachment
+
+            subject = I18n.t("diploma.subject", scope: "decidim.conferences.mailer.send_conference_diploma_mailer")
+            mail(to: user.email, subject: subject)
+          end
+        end
+
+        private
+
+        def add_diploma_attachment
+          diploma = WickedPdf.new.pdf_from_string(
+            render_to_string(pdf: "conference-diploma",
+                             template: "decidim/conferences/admin/send_conference_diploma_mailer/diploma_user.html.erb",
+                             layout: "decidim/diploma.html.erb"),
+            orientation: "Landscape"
+          )
+
+          attachments["conference-#{@user.nickname.parameterize}-diploma.pdf"] = diploma
+        end
+      end
+    end
+  end
+end