decidim-conferences 0.15.1

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    # The main admin application controller for conferences
+    class ApplicationController < Decidim::ApplicationController
+      helper Decidim::ApplicationHelper
+      helper Decidim::ResourceHelper
+      include NeedsPermission
+
+      private
+
+      def permissions_context
+        super.merge(
+          current_participatory_space: try(:current_participatory_space)
+        )
+      end
+
+      def permission_class_chain
+        [
+          Decidim::Conferences::Permissions,
+          Decidim::Admin::Permissions,
+          Decidim::Permissions
+        ]
+      end
+
+      def permission_scope
+        :public
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    class ConferenceProgramController < Decidim::Conferences::ApplicationController
+      include ParticipatorySpaceContext
+      helper Decidim::SanitizeHelper
+      helper Decidim::Conferences::ConferenceProgramHelper
+      participatory_space_layout only: :show
+
+      helper_method :collection, :conference, :meeting_days, :meeting_component
+
+      def show
+        raise ActionController::RoutingError, "No meetings for this conference " if meetings.empty?
+        enforce_permission_to :list, :program
+        redirect_to decidim_conferences.conference_path(current_participatory_space) unless current_user_can_visit_space?
+      end
+
+      private
+
+      def meeting_component
+        return if params[:id].blank?
+        @meeting_component ||= current_participatory_space.components.where(manifest_name: "meetings").find_by(id: params[:id])
+      end
+
+      def meetings
+        return unless meeting_component.published? || !meeting_component.presence
+        @meetings ||= Decidim::Meetings::Meeting.where(component: meeting_component).visible_meeting_for(current_user).order(:start_time)
+      end
+
+      def meeting_days
+        @meeting_days ||= meetings.map { |m| [m.start_time.to_date] }.uniq.flatten
+      end
+
+      alias collection meetings
+
+      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/controllers/decidim/conferences/conference_registrations_controller.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    # Exposes the registration resource so users can join and leave conferences.
+    class ConferenceRegistrationsController < Decidim::Conferences::ApplicationController
+      def create
+        enforce_permission_to :join, :conference, conference: conference
+
+        JoinConference.call(conference, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("conference_registrations.create.success", scope: "decidim.conferences")
+            redirect_after_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("conference_registrations.create.invalid", scope: "decidim.conferences")
+            redirect_after_path
+          end
+        end
+      end
+
+      def destroy
+        enforce_permission_to :leave, :conference, conference: conference
+
+        LeaveConference.call(conference, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("conference_registrations.destroy.success", scope: "decidim.conferences")
+            redirect_after_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("conference_registrations.destroy.invalid", scope: "decidim.conferences")
+            redirect_after_path
+          end
+        end
+      end
+
+      def decline_invitation
+        enforce_permission_to :decline_invitation, :conference, conference: conference
+
+        DeclineInvitation.call(conference, current_user) do
+          on(:ok) do
+            flash[:notice] = I18n.t("conference_registrations.decline_invitation.success", scope: "decidim.conferences")
+            redirect_after_path
+          end
+
+          on(:invalid) do
+            flash.now[:alert] = I18n.t("conference_registrations.decline_invitation.invalid", scope: "decidim.conferences")
+            redirect_after_path
+          end
+        end
+      end
+
+      private
+
+      def conference
+        @conference ||= Conference.find_by(slug: params[:conference_slug])
+      end
+
+      def redirect_after_path
+        referer = request.headers["Referer"]
+        return redirect_to(conference_path(conference)) if referer =~ /invitation_token/
+        redirect_back fallback_location: conference_path(conference)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    class ConferenceSpeakersController < Decidim::Conferences::ApplicationController
+      include ParticipatorySpaceContext
+
+      participatory_space_layout only: :index
+
+      helper_method :collection, :conference
+
+      def index
+        raise ActionController::RoutingError, "No speakers for this conference " if speakers.empty?
+        enforce_permission_to :list, :speakers
+        redirect_to decidim_conferences.conference_path(current_participatory_space) unless current_user_can_visit_space?
+      end
+
+      private
+
+      def speakers
+        @speakers ||= current_participatory_space.speakers
+      end
+
+      alias collection speakers
+
+      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/controllers/decidim/conferences/conference_widgets_controller.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    class ConferenceWidgetsController < Decidim::WidgetsController
+      helper Decidim::SanitizeHelper
+
+      private
+
+      def model
+        @model ||= Conference.find_by(slug: params[:conference_slug])
+      end
+
+      def current_participatory_space
+        model
+      end
+
+      def iframe_url
+        @iframe_url ||= conference_conference_widget_url(model)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    # A controller that holds the logic to show Conferences in a
+    # public layout.
+    class ConferencesController < Decidim::Conferences::ApplicationController
+      include ParticipatorySpaceContext
+      participatory_space_layout only: :show
+
+      helper Decidim::AttachmentsHelper
+      helper Decidim::IconHelper
+      helper Decidim::WidgetUrlsHelper
+      helper Decidim::SanitizeHelper
+      helper Decidim::ResourceReferenceHelper
+      helper Decidim::Conferences::PartnersHelper
+
+      helper_method :collection, :promoted_conferences, :conferences, :stats
+
+      def index
+        redirect_to "/404" if published_conferences.none?
+
+        enforce_permission_to :list, :conference
+      end
+
+      def show
+        check_current_user_can_visit_space
+      end
+
+      private
+
+      def current_participatory_space
+        return unless params[:slug]
+
+        @current_participatory_space ||= OrganizationConferences.new(current_organization).query.where(slug: params[:slug]).or(
+          OrganizationConferences.new(current_organization).query.where(id: params[:slug])
+        ).first!
+      end
+
+      def published_conferences
+        @published_conferences ||= OrganizationPublishedConferences.new(current_organization, current_user)
+      end
+
+      def conferences
+        @conferences ||= OrganizationPrioritizedConferences.new(current_organization, current_user)
+      end
+
+      alias collection conferences
+
+      def promoted_conferences
+        @promoted_conferences ||= conferences | PromotedConferences.new
+      end
+
+      def stats
+        @stats ||= ConferenceStatsPresenter.new(conference: current_participatory_space)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    class MediaController < Decidim::Conferences::ApplicationController
+      include ParticipatorySpaceContext
+      helper Decidim::Conferences::MediaAttachmentsHelper
+      helper Decidim::SanitizeHelper
+
+      participatory_space_layout only: :index
+
+      helper_method :collection, :conference
+
+      def index
+        raise ActionController::RoutingError, "No media_links for this conference " if media_links.empty? && current_participatory_space.attachments.empty?
+        enforce_permission_to :list, :media_links
+        redirect_to decidim_conferences.conference_path(current_participatory_space) unless current_user_can_visit_space?
+      end
+
+      private
+
+      def media_links
+        @media_links ||= current_participatory_space.media_links
+      end
+
+      alias collection media_links
+
+      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_registrations_enabled_event.rb

@@ -0,0 +1,8 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Conferences
+    class ConferenceRegistrationsEnabledEvent < Decidim::Events::SimpleEvent
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen-string_literal: true
+
+module Decidim
+  module Conferences
+    class ConferenceRegistrationsOverPercentageEvent < Decidim::Events::SimpleEvent
+      i18n_attributes :percentage
+
+      def percentage
+        extra["percentage"] * 100
+      end
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    class UpcomingConferenceEvent < Decidim::Events::SimpleEvent
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    class UpdateConferenceEvent < Decidim::Events::SimpleEvent
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A form object used to copy a conferences from the admin
+      # dashboard.
+      #
+      class ConferenceCopyForm < Form
+        include TranslatableAttributes
+
+        translatable_attribute :title, String
+
+        mimic :conference
+
+        attribute :slug, String
+        attribute :copy_categories, Boolean
+        attribute :copy_components, Boolean
+
+        validates :slug, presence: true, format: { with: Decidim::Conference.slug_format }
+        validates :title, translatable_presence: true
+        validate :slug_uniqueness
+
+        private
+
+        def slug_uniqueness
+          return unless OrganizationConferences.new(current_organization).query.where(slug: slug).where.not(id: id).any?
+
+          errors.add(:slug, :taken)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Decidim
+  module Conferences
+    module Admin
+      # A form object used to create conferences from the admin
+      # dashboard.
+      #
+      class ConferenceForm < Form
+        include TranslatableAttributes
+
+        translatable_attribute :title, String
+        translatable_attribute :slogan, String
+        translatable_attribute :short_description, String
+        translatable_attribute :description, String
+        translatable_attribute :objectives, String
+        translatable_attribute :registration_terms, String
+
+        mimic :conference
+
+        attribute :slug, String
+        attribute :hashtag, String
+        attribute :promoted, Boolean
+        attribute :scopes_enabled, Boolean
+        attribute :scope_id, Integer
+        attribute :hero_image
+        attribute :remove_hero_image
+        attribute :banner_image
+        attribute :remove_banner_image
+        attribute :show_statistics, Boolean
+        attribute :start_date, Decidim::Attributes::LocalizedDate
+        attribute :end_date, Decidim::Attributes::LocalizedDate
+        attribute :registrations_enabled, Boolean
+        attribute :available_slots, Integer
+        attribute :location, String
+        attribute :participatory_processes_ids, Array[Integer]
+        attribute :assemblies_ids, Array[Integer]
+        attribute :consultations_ids, Array[Integer]
+
+        validates :slug, presence: true, format: { with: Decidim::Conference.slug_format }
+        validates :title, :slogan, :description, :short_description, translatable_presence: true
+
+        validate :slug_uniqueness
+
+        validates :registration_terms, translatable_presence: true, if: ->(form) { form.registrations_enabled? }
+        validates :available_slots, numericality: { greater_than_or_equal_to: 0 }, if: ->(form) { form.registrations_enabled? }
+
+        validates :hero_image, file_size: { less_than_or_equal_to: ->(_record) { Decidim.maximum_attachment_size } }, file_content_type: { allow: ["image/jpeg", "image/png"] }
+        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 }
+
+        def map_model(model)
+          self.scope_id = model.decidim_scope_id
+        end
+
+        def scope
+          @scope ||= current_organization.scopes.find_by(id: scope_id)
+        end
+
+        def processes_for_select
+          @processes_for_select ||= Decidim.find_participatory_space_manifest(:participatory_processes)
+                                           .participatory_spaces.call(current_organization)&.order(title: :asc)&.map do |process|
+            [
+              translated_attribute(process.title),
+              process.id
+            ]
+          end
+        end
+
+        def assemblies_for_select
+          @assemblies_for_select ||= Decidim.find_participatory_space_manifest(:assemblies)
+                                            .participatory_spaces.call(current_organization)&.order(title: :asc)&.map do |assembly|
+            [
+              translated_attribute(assembly.title),
+              assembly.id
+            ]
+          end
+        end
+
+        def consultations_for_select
+          @consultations_for_select ||= Decidim.find_participatory_space_manifest(:consultations)
+                                               .participatory_spaces.call(current_organization)&.order(title: :asc)&.map do |consultation|
+            [
+              translated_attribute(consultation.title),
+              consultation.id
+            ]
+          end
+        end
+
+        private
+
+        def available_slots_greater_than_or_equal_to_registrations_count
+          conference = OrganizationConferences.new(current_organization).query.find_by(slug: slug)
+          return true if conference.blank?
+          errors.add(:available_slots, :invalid) if available_slots < conference.conference_registrations.count
+        end
+
+        def slug_uniqueness
+          return unless OrganizationConferences.new(current_organization).query.where(slug: slug).where.not(id: context[:conference_id]).any?
+
+          errors.add(:slug, :taken)
+        end
+      end
+    end
+  end
+end