decidim-conferences 0.15.1

data/app/commands/decidim/conferences/admin/destroy_partner.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A command with all the business logic when destroying an conference
+      # partner in the system.
+      class DestroyPartner < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # conference_partner - the Partner to destroy
+        # current_user - the user performing this action
+        def initialize(conference_partner, current_user)
+          @conference_partner = conference_partner
+          @current_user = current_user
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          destroy_partner!
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :conference_partner, :current_user
+
+        def destroy_partner!
+          log_info = {
+            resource: {
+              title: conference_partner.name
+            },
+            participatory_space: {
+              title: conference_partner.conference.title
+            }
+          }
+
+          Decidim.traceability.perform_action!(
+            "delete",
+            conference_partner,
+            current_user,
+            log_info
+          ) do
+            conference_partner.destroy!
+            conference_partner
+          end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/conferences/admin/export_conference_registrations.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # This command is executed when the user exports the registrations of
+      # a Conference from the admin panel.
+      class ExportConferenceRegistrations < Rectify::Command
+        # conference - The current instance of the page to be closed.
+        # format - a string representing the export format
+        # current_user - the user performing the action
+        def initialize(conference, format, current_user)
+          @conference = conference
+          @format = format
+          @current_user = current_user
+        end
+
+        # Exports the conference registrations.
+        #
+        # Broadcasts :ok if successful, :invalid otherwise.
+        def call
+          broadcast(:ok, export_data)
+        end
+
+        private
+
+        attr_reader :current_user, :conference, :format
+
+        def export_data
+          Decidim.traceability.perform_action!(
+            :export_conference_registrations,
+            conference,
+            current_user
+          ) do
+            Decidim::Exporters
+              .find_exporter(format)
+              .new(conference.conference_registrations, Decidim::Conferences::ConferenceRegistrationSerializer)
+              .export
+          end
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/conferences/admin/invite_user_to_join_conference.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A command with all the business logic to invite users to join a conference.
+      #
+      class InviteUserToJoinConference < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # form         - A form object with the params.
+        # conference      - The conference which the user is invited to.
+        # invited_by   - The user performing the operation
+        def initialize(form, conference, invited_by)
+          @form = form
+          @conference = conference
+          @invited_by = invited_by
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid? || already_invited?
+
+          invite_user
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :form, :invited_by, :conference
+
+        def already_invited?
+          return false unless user.persisted?
+          return false unless conference.conference_invites.where(user: user).exists?
+
+          form.errors.add(:email, :already_invited)
+          true
+        end
+
+        def create_invitation!
+          log_info = {
+            resource: {
+              title: conference.title
+            },
+            participatory_space: {
+              title: conference.title
+            }
+          }
+
+          @conference_invite = Decidim.traceability.create!(
+            Decidim::Conferences::ConferenceInvite,
+            invited_by,
+            {
+              user: user,
+              conference: conference,
+              sent_at: Time.current
+            },
+            log_info
+          )
+        end
+
+        def invite_user
+          if user.persisted?
+            create_invitation!
+
+            # The user has already been invited to sign up to another
+            # conference or resource and has not yet accepted the invitation
+            if user.invited_to_sign_up?
+              invite_user_to_sign_up
+            else
+              InviteJoinConferenceMailer.invite(user, conference, invited_by).deliver_later
+            end
+          else
+            user.name = form.name
+            user.nickname = User.nicknamize(user.name, organization: user.organization)
+            invite_user_to_sign_up
+            create_invitation!
+          end
+        end
+
+        def user
+          @user ||= begin
+            if form.existing_user
+              form.user
+            else
+              Decidim::User.find_or_initialize_by(
+                organization: form.current_organization,
+                email: form.email.downcase
+              )
+            end
+          end
+        end
+
+        def invite_user_to_sign_up
+          user.skip_reconfirmation!
+          user.invite!(invited_by, invitation_instructions: "join_conference", conference: conference)
+        end
+      end
+    end
+  end
+end

data/app/commands/decidim/conferences/admin/publish_conference.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A command that sets an conference as published.
+      class PublishConference < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # conference - A Conference that will be published
+        # current_user - the user performing the action
+        def initialize(conference, current_user)
+          @conference = conference
+          @current_user = current_user
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the data wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if conference.nil? || conference.published?
+
+          Decidim.traceability.perform_action!("publish", conference, current_user) do
+            conference.publish!
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :conference, :current_user
+      end
+    end
+  end
+end

data/app/commands/decidim/conferences/admin/unpublish_conference.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A command that sets an conference as unpublished.
+      class UnpublishConference < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # conference - A Conference that will be published
+        # current_user - the user performing the action
+        def initialize(conference, current_user)
+          @conference = conference
+          @current_user = current_user
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the data wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if conference.nil? || !conference.published?
+
+          Decidim.traceability.perform_action!("unpublish", conference, current_user) do
+            conference.unpublish!
+          end
+
+          broadcast(:ok)
+        end
+
+        private
+
+        attr_reader :conference, :current_user
+      end
+    end
+  end
+end

data/app/commands/decidim/conferences/admin/update_conference.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A command with all the business logic when creating a new participatory
+      # conference in the system.
+      class UpdateConference < Rectify::Command
+        # Public: Initializes the command.
+        #
+        # conference - the Conference to update
+        # form - A form object with the params.
+        def initialize(conference, form)
+          @conference = conference
+          @form = form
+        end
+
+        # Executes the command. Broadcasts these events:
+        #
+        # - :ok when everything is valid.
+        # - :invalid if the form wasn't valid and we couldn't proceed.
+        #
+        # Returns nothing.
+        def call
+          return broadcast(:invalid) if form.invalid?
+          update_conference
+          link_participatory_processes
+          link_assemblies
+          link_consultations
+
+          if @conference.valid?
+            broadcast(:ok, @conference)
+          else
+            form.errors.add(:hero_image, @conference.errors[:hero_image]) if @conference.errors.include? :hero_image
+            form.errors.add(:banner_image, @conference.errors[:banner_image]) if @conference.errors.include? :banner_image
+            broadcast(:invalid)
+          end
+        end
+
+        private
+
+        attr_reader :form, :conference
+
+        def update_conference
+          @conference.assign_attributes(attributes)
+          save_conference if @conference.valid?
+        end
+
+        def save_conference
+          transaction do
+            update_conference_registrations
+            @conference.save!
+            send_notification_registrations_enabled if should_notify_followers_registrations_enabled?
+            send_notification_update_conference if should_notify_followers_update_conference?
+            schedule_upcoming_conference_notification if start_date_changed?
+            Decidim.traceability.perform_action!(:update, @conference, form.current_user) do
+              @conference
+            end
+          end
+        end
+
+        def update_conference_registrations
+          @conference.registrations_enabled = form.registrations_enabled
+
+          if form.registrations_enabled
+            @conference.available_slots = form.available_slots
+            @conference.registration_terms = form.registration_terms
+          end
+        end
+
+        def attributes
+          {
+            title: form.title,
+            slogan: form.slogan,
+            slug: form.slug,
+            hashtag: form.hashtag,
+            description: form.description,
+            short_description: form.short_description,
+            objectives: form.objectives,
+            location: form.location,
+            start_date: form.start_date,
+            end_date: form.end_date,
+            hero_image: form.hero_image,
+            banner_image: form.banner_image,
+            promoted: form.promoted,
+            scopes_enabled: form.scopes_enabled,
+            scope: form.scope,
+            show_statistics: form.show_statistics
+          }
+        end
+
+        def send_notification_registrations_enabled
+          Decidim::EventsManager.publish(
+            event: "decidim.events.conferences.registrations_enabled",
+            event_class: Decidim::Conferences::ConferenceRegistrationsEnabledEvent,
+            resource: @conference,
+            recipient_ids: @conference.followers.pluck(:id)
+          )
+        end
+
+        def should_notify_followers_registrations_enabled?
+          @conference.previous_changes["registrations_enabled"].present? && @conference.registrations_enabled?
+        end
+
+        def send_notification_update_conference
+          Decidim::EventsManager.publish(
+            event: "decidim.events.conferences.conference_updated",
+            event_class: Decidim::Conferences::UpdateConferenceEvent,
+            resource: @conference,
+            recipient_ids: @conference.followers.pluck(:id)
+          )
+        end
+
+        def should_notify_followers_update_conference?
+          important_attributes.any? { |attr| @conference.previous_changes[attr].present? }
+        end
+
+        def important_attributes
+          %w(start_date end_date location)
+        end
+
+        def start_date_changed?
+          @conference.previous_changes["start_date"].present?
+        end
+
+        def schedule_upcoming_conference_notification
+          checksum = Decidim::Conferences::UpcomingConferenceNotificationJob.generate_checksum(@conference)
+
+          Decidim::Conferences::UpcomingConferenceNotificationJob
+            .set(wait_until: (@conference.start_date - 2.days).to_s)
+            .perform_later(@conference.id, checksum)
+        end
+
+        def participatory_processes
+          @participatory_processes ||= @conference.participatory_space_sibling_scope(:participatory_processes).where(id: @form.participatory_processes_ids)
+        end
+
+        def link_participatory_processes
+          @conference.link_participatory_spaces_resources(participatory_processes, "included_participatory_processes")
+        end
+
+        def assemblies
+          @assemblies ||= @conference.participatory_space_sibling_scope(:assemblies).where(id: @form.assemblies_ids)
+        end
+
+        def link_assemblies
+          @conference.link_participatory_spaces_resources(assemblies, "included_assemblies")
+        end
+
+        def consultations
+          @consultations ||= @conference.participatory_space_sibling_scope(:consultations)
+                                        .where(id: @form.consultations_ids)
+        end
+
+        def link_consultations
+          @conference.link_participatory_spaces_resources(consultations, "included_consultations")
+        end
+      end
+    end
+  end
+end