decidim-conferences 0.29.2 → 0.30.0.rc1

data/lib/decidim/conferences/conference_diploma_pdf.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "hexapdf"
+require "open-uri"
+
+module Decidim
+  module Conferences
+    class ConferenceDiplomaPDF
+      include ActionView::Helpers::AssetUrlHelper
+      include Shakapacker::Helper
+      include Decidim::TranslatableAttributes
+      include Decidim::SanitizeHelper
+
+      def initialize(conference, user)
+        @conference = conference
+        @user = user
+      end
+
+      def render
+        composer.styles(**styles)
+
+        create_border
+        add_logo
+
+        add_text
+
+        add_hr_line
+        add_verified_by_text
+        add_signature_picture
+        add_verified_by_signature
+
+        document.write_to_string
+      end
+
+      private
+
+      attr_reader :conference
+
+      delegate :document, to: :composer
+
+      def page_orientation = :landscape
+
+      def page = document.pages.first
+
+      def page_width = page.box(:media).width
+
+      def page_height = page.box(:media).height
+
+      def layout = document.layout
+
+      def box_width = page_width * 0.9
+
+      def box_height = page_height * 0.7
+
+      def styles
+        {
+          h1: { font: bold_font, text_align: :center, font_size: 18 },
+          h2: { font: bold_font, text_align: :center, font_size: 15 },
+          text: { font:, text_align: :center, font_size: 10 },
+          verified: { font:, text_align: :center, font_size: 8 },
+          bold: { font: bold_font, text_align: :center, font_size: 10 }
+        }
+      end
+
+      def composer
+        @composer ||= ::HexaPDF::Composer.new(page_orientation:)
+      end
+
+      def add_text
+        width = 710
+
+        composer.text(translated_attribute(conference.title), style: :h1, position: [30, box_height - 130], width:)
+        composer.text(I18n.t("decidim.conferences.admin.send_conference_diploma_mailer.diploma_user.certificate_of_attendance"),
+                      style: :h2, position: [30, box_height - 160], width:)
+
+        text = I18n.t("decidim.conferences.admin.send_conference_diploma_mailer.diploma_user.certificate_of_attendance_description",
+                      user: @user.name,
+                      title: translated_attribute(@conference.title),
+                      location: @conference.location,
+                      start: I18n.l(@conference.start_date, format: :decidim_short),
+                      end: I18n.l(@conference.end_date, format: :decidim_short))
+
+        texts_to_bold = [
+          @user.name,
+          translated_attribute(@conference.title),
+          I18n.l(@conference.start_date, format: :decidim_short),
+          I18n.l(@conference.end_date, format: :decidim_short)
+        ]
+
+        texts_to_bold = texts_to_bold.map { |bold| decidim_sanitize(bold, strip_tags: true) }
+
+        text = decidim_sanitize(text, strip_tags: true)
+        text_fragments = create_text_fragments(text, texts_to_bold)
+
+        result = HexaPDF::Layout::TextLayouter.new.fit(text_fragments, 710, 30)
+
+        x_width = (page_width - result.lines.first.width) / 2
+
+        result.draw(composer.canvas, x_width, 260)
+      end
+
+      # Function to create text fragments with bold parts
+      def create_text_fragments(text, texts_to_bold)
+        fragments = []
+        current_position = 0
+
+        texts_to_bold.sort_by! { |bold_text| text.index(bold_text) }
+
+        texts_to_bold.each do |bold_text|
+          bold_position = text.index(bold_text, current_position)
+
+          if bold_position > current_position
+            part = text[current_position...bold_position]
+            fragments << HexaPDF::Layout::TextFragment.create(part, styles[:text])
+          end
+
+          fragments << HexaPDF::Layout::TextFragment.create(bold_text, styles[:bold])
+
+          current_position = bold_position + bold_text.length
+        end
+
+        if current_position < text.length
+          part = text[current_position..-1]
+          fragments << HexaPDF::Layout::TextFragment.create(part, font: styles[:text])
+        end
+
+        fragments
+      end
+
+      def compute_dimensions(attached_image, max_width, max_height)
+        # Retrieve the image metadata
+        metadata = attached_image.blob.metadata
+
+        # If metadata does not contain width and height, return the max dimensions
+        return max_height, max_width unless metadata.has_key?(:width) && metadata.has_key?(:height)
+
+        # Calculate the aspect ratio of the image
+        aspect_ratio = metadata[:width].to_f / metadata[:height]
+
+        # Adjust the width based on the max height while preserving the aspect ratio
+        adjusted_width = (max_height * aspect_ratio).round
+
+        # Return the max height and the adjusted width
+        return max_height, adjusted_width
+      end
+
+      def font
+        @font ||= load_font("source-sans-pro-v21-cyrillic_cyrillic-ext_greek_greek-ext_latin_latin-ext_vietnamese-regular.ttf")
+      end
+
+      def bold_font
+        @bold_font ||= load_font("source-sans-pro-v21-cyrillic_cyrillic-ext_greek_greek-ext_latin_latin-ext_vietnamese-700.ttf")
+      end
+
+      def load_font(path)
+        document.fonts.add(Decidim::Core::Engine.root.join("app/packs/fonts/decidim/").join(path))
+      end
+
+      def add_verified_by_text
+        composer.text(I18n.t("decidim.conferences.admin.send_conference_diploma_mailer.diploma_user.attendance_verified_by"),
+                      style: :bold, position: [30, 160], width: 710)
+      end
+
+      def add_signature_picture
+        attached_image = conference.attached_uploader(:signature).variant(:original)
+        logo = document.images.add(StringIO.new(attached_image.download))
+        max_height, max_width = compute_dimensions(attached_image, 80, 40)
+
+        box_x = (page_width - max_width) / 2
+        box_y = 150
+        frame = ::HexaPDF::Layout::Frame.new(box_x, box_y, 80, 40)
+
+        box = document.layout.box do |canvas, _box|
+          canvas.image(logo, at: [0, 0], width: max_width, height: max_height)
+        end
+
+        result = frame.fit(box)
+        frame.draw(page.canvas, result)
+      end
+
+      def add_hr_line
+        frame = ::HexaPDF::Layout::Frame.new(66, 210, 710, 10)
+
+        box = document.layout.box do |canvas, _box|
+          canvas.line_width = 0.5
+          canvas.stroke_color(0, 0, 0)
+          canvas.line(0, 10, 710, 10).stroke
+        end
+        result = frame.fit(box)
+        frame.draw(page.canvas, result)
+      end
+
+      def add_verified_by_signature
+        composer.text([
+          I18n.l(conference.sign_date, format: :decidim_short),
+          conference.signature_name
+        ].join(", "), style: :verified, position: [30, 95], width: 710)
+      end
+
+      def add_logo
+        attached_image = conference.attached_uploader(:main_logo).variant(:original)
+        logo = document.images.add(StringIO.new(attached_image.download))
+        max_height, max_width = compute_dimensions(attached_image, 160, 80)
+
+        box_x = (page_width - max_width) / 2
+        box_y = page_height - 220
+        frame = ::HexaPDF::Layout::Frame.new(box_x, box_y, 160, 80)
+
+        box = document.layout.box do |canvas, _box|
+          canvas.image(logo, at: [0, 0], width: max_width, height: max_height)
+        end
+
+        result = frame.fit(box)
+        frame.draw(page.canvas, result)
+      end
+
+      def create_border
+        background_image = StringIO.new(Rails.root.join("public/#{image_pack_path("media/images/pattern.png")}").read)
+
+        box_x = (page_width - box_width) / 2
+        box_y = (page_height - box_height) / 2
+
+        frame = ::HexaPDF::Layout::Frame.new(box_x, box_y, box_width, box_height)
+
+        box = document.layout.image_box(background_image, width: box_width, height: box_height)
+        result = frame.fit(box)
+        frame.draw(page.canvas, result)
+
+        frame = ::HexaPDF::Layout::Frame.new(box_x, box_y, box_width, box_height)
+
+        box = document.layout.box do |canvas, _box|
+          canvas.fill_color("FFFFFF")
+          canvas.rectangle(10, 10, box_width - 20, box_height - 20)
+          canvas.fill
+        end
+
+        result = frame.fit(box)
+        frame.draw(page.canvas, result)
+      end
+    end
+  end
+end

data/lib/decidim/conferences/engine.rb

@@ -3,7 +3,6 @@
 require "rails"
 require "active_support/all"
 require "decidim/core"
-require "wicked_pdf"
 
 require "decidim/conferences/query_extensions"
 require "decidim/conferences/content_blocks/registry_manager"
@@ -51,6 +50,12 @@ module Decidim
         end
       end
 
+      initializer "decidim_conferences.mount_routes" do
+        Decidim::Core::Engine.routes do
+          mount Decidim::Conferences::Engine, at: "/", as: "decidim_conferences"
+        end
+      end
+
       initializer "decidim_conferences.register_icons" do
         Decidim.icons.register(name: "Decidim::Conference", icon: "mic-line", description: "Conference", category: "activity", engine: :conferences)
         Decidim.icons.register(name: "conference_speaker", icon: "user-voice-line", description: "Speaker", category: "conferences", engine: :conferences)

data/lib/decidim/conferences/menu.rb

@@ -48,6 +48,7 @@ module Decidim
                           active: is_active_link?(manage_component_path(component)) ||
                                   is_active_link?(decidim_admin_conferences.edit_component_path(current_participatory_space, component)) ||
                                   is_active_link?(decidim_admin_conferences.edit_component_permissions_path(current_participatory_space, component)) ||
+                                  is_active_link?(decidim_admin_conferences.component_share_tokens_path(current_participatory_space, component)) ||
                                   participatory_space_active_link?(component),
                           if: component.manifest.admin_engine && user_role_config.component_is_accessible?(component.manifest_name)
           end
@@ -100,8 +101,8 @@ module Decidim
         end
       end
 
-      def self.register_conferences_admin_menu!
-        Decidim.menu :conferences_admin_menu do |menu|
+      def self.register_conference_admin_menu!
+        Decidim.menu :conference_admin_menu do |menu|
           menu.add_item :edit_conference,
                         I18n.t("info", scope: "decidim.admin.menu.conferences_submenu"),
                         decidim_admin_conferences.edit_conference_path(current_participatory_space),
@@ -118,12 +119,6 @@ module Decidim
                                                 ["decidim/conferences/admin/components", %w(index new edit)]),
                         submenu: { target_menu: :admin_conferences_components_menu }
 
-          menu.add_item :categories,
-                        I18n.t("categories", scope: "decidim.admin.menu.conferences_submenu"),
-                        decidim_admin_conferences.categories_path(current_participatory_space),
-                        icon_name: "price-tag-3-line",
-                        if: allowed_to?(:read, :category, conference: current_participatory_space)
-
           menu.add_item :attachments,
                         I18n.t("attachments", scope: "decidim.admin.menu.conferences_submenu"),
                         decidim_admin_conferences.conference_attachments_path(current_participatory_space),
@@ -172,6 +167,25 @@ module Decidim
                         decidim_admin_conferences.moderations_path(current_participatory_space),
                         icon_name: "flag-line",
                         if: allowed_to?(:read, :moderation, conference: current_participatory_space)
+
+          menu.add_item :conference_share_tokens,
+                        I18n.t("menu.share_tokens", scope: "decidim.admin"),
+                        decidim_admin_conferences.conference_share_tokens_path(current_participatory_space),
+                        active: is_active_link?(decidim_admin_conferences.conference_share_tokens_path(current_participatory_space)),
+                        icon_name: "share-line",
+                        if: allowed_to?(:read, :share_tokens, current_participatory_space:)
+        end
+      end
+
+      def self.register_conferences_admin_menu!
+        Decidim.menu :admin_conferences_menu do |menu|
+          menu.add_item :conferences,
+                        I18n.t("menu.conferences", scope: "decidim.admin"),
+                        decidim_admin_conferences.conferences_path,
+                        position: 1,
+                        active: is_active_link?(decidim_admin_conferences.conferences_path),
+                        icon_name: "government-line",
+                        if: allowed_to?(:read, :conference_list)
         end
       end
 
@@ -182,7 +196,7 @@ module Decidim
                         decidim_admin_conferences.conferences_path,
                         icon_name: "live-line",
                         position: 2.8,
-                        active: :inclusive,
+                        active: is_active_link?(decidim_admin_conferences.conferences_path, :inclusive),
                         if: allowed_to?(:enter, :space_area, space_name: :conferences)
         end
       end

data/lib/decidim/conferences/participatory_space.rb

@@ -36,6 +36,19 @@ Decidim.register_participatory_space(:conferences) do |participatory_space|
     context.layout = "layouts/decidim/admin/conference"
   end
 
+  participatory_space.exports :conferences do |export|
+    export.collection do
+      Decidim::Conference
+        .public_spaces
+        .includes(:taxonomies, :attachment_collections)
+    end
+
+    export.include_in_open_data = true
+
+    export.serializer Decidim::Conferences::ConferenceSerializer
+    export.open_data_serializer Decidim::Conferences::OpenDataConferenceSerializer
+  end
+
   participatory_space.register_on_destroy_account do |user|
     Decidim::ConferenceUserRole.where(user:).destroy_all
     Decidim::ConferenceSpeaker.where(user:).destroy_all

data/lib/decidim/conferences/seeds.rb

@@ -6,145 +6,164 @@ module Decidim
   module Conferences
     class Seeds < Decidim::Seeds
       def call
-        organization = Decidim::Organization.first
-
-        Decidim::ContentBlock.create(
-          organization:,
-          weight: 33,
-          scope_name: :homepage,
-          manifest_name: :highlighted_conferences,
-          published_at: Time.current
-        )
+        create_content_block!
 
         2.times do |_n|
-          params = {
-            title: Decidim::Faker::Localized.sentence(word_count: 5),
-            slogan: Decidim::Faker::Localized.sentence(word_count: 2),
-            slug: Decidim::Faker::Internet.unique.slug(words: nil, glue: "-"),
-            hashtag: "##{::Faker::Lorem.word}",
-            short_description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-              Decidim::Faker::Localized.sentence(word_count: 3)
-            end,
-            description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-              Decidim::Faker::Localized.paragraph(sentence_count: 3)
-            end,
-            organization:,
-            hero_image: ::Faker::Boolean.boolean(true_ratio: 0.5) ? hero_image : nil, # Keep after organization
-            banner_image: ::Faker::Boolean.boolean(true_ratio: 0.5) ? banner_image : nil, # Keep after organization
-            promoted: true,
-            published_at: 2.weeks.ago,
-            objectives: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-              Decidim::Faker::Localized.paragraph(sentence_count: 3)
-            end,
-            start_date: Time.current,
-            end_date: 2.months.from_now.at_midnight,
-            registrations_enabled: [true, false].sample,
-            available_slots: (10..50).step(10).to_a.sample,
-            registration_terms: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-              Decidim::Faker::Localized.paragraph(sentence_count: 3)
-            end
-          }
-
-          conference = Decidim.traceability.perform_action!(
-            "publish",
-            Decidim::Conference,
-            organization.users.first,
-            visibility: "all"
-          ) do
-            Decidim::Conference.create!(params)
-          end
-          conference.add_to_index_as_search_resource
+          conference = create_conference!
 
-          # Create users with specific roles
-          Decidim::ConferenceUserRole::ROLES.each do |role|
-            email = "conference_#{conference.id}_#{role}@example.org"
-            user = find_or_initialize_user_by(email:)
+          create_conference_user_roles!(conference:)
 
-            Decidim::ConferenceUserRole.find_or_create_by!(
-              user:,
-              conference:,
-              role:
-            )
-          end
-
-          attachment_collection = create_attachment_collection(collection_for: conference)
-          create_attachment(attached_to: conference, filename: "Exampledocument.pdf", attachment_collection:)
-          create_attachment(attached_to: conference, filename: "city.jpeg")
-          create_attachment(attached_to: conference, filename: "Exampledocument.pdf")
-
-          2.times do
-            Decidim::Category.create!(
-              name: Decidim::Faker::Localized.sentence(word_count: 5),
-              description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-                Decidim::Faker::Localized.paragraph(sentence_count: 3)
-              end,
-              participatory_space: conference
-            )
-          end
+          create_attachments!(attached_to: conference)
 
           5.times do
-            Decidim::ConferenceSpeaker.create!(
-              user: conference.organization.users.sample,
-              full_name: ::Faker::Name.name,
-              position: Decidim::Faker::Localized.word,
-              affiliation: Decidim::Faker::Localized.sentence(word_count: 3),
-              short_bio: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
-                Decidim::Faker::Localized.paragraph(sentence_count: 3)
-              end,
-              twitter_handle: ::Faker::Twitter.unique.screen_name,
-              personal_url: ::Faker::Internet.url,
-              published_at: Time.current,
-              conference:
-            )
+            create_conference_speaker!(conference:)
           end
 
           Decidim::Conferences::Partner::TYPES.map do |type|
             4.times do
-              Decidim::Conferences::Partner.create!(
-                name: ::Faker::Name.name,
-                weight: ::Faker::Number.between(from: 1, to: 10),
-                link: ::Faker::Internet.url,
-                partner_type: type,
-                conference:,
-                logo: create_blob!(seeds_file: "logo.png", filename: "logo.png", content_type: "image/png")
-              )
+              create_conference_partner!(conference:, type:)
             end
           end
 
           5.times do
-            Decidim::Conferences::MediaLink.create!(
-              title: Decidim::Faker::Localized.sentence(word_count: 2),
-              link: ::Faker::Internet.url,
-              date: Date.current,
-              weight: ::Faker::Number.between(from: 1, to: 10),
-              conference:
-            )
+            create_conference_media_link!(conference:)
           end
 
           5.times do
-            Decidim::Conferences::RegistrationType.create!(
-              title: Decidim::Faker::Localized.sentence(word_count: 2),
-              description: Decidim::Faker::Localized.sentence(word_count: 5),
-              weight: ::Faker::Number.between(from: 1, to: 10),
-              price: ::Faker::Number.between(from: 1, to: 300),
-              published_at: 2.weeks.ago,
-              conference:
-            )
+            create_conference_registration_type!(conference:)
           end
 
           Decidim.component_manifests.each do |manifest|
             manifest.seed!(conference.reload)
           end
 
-          Decidim::ConferenceMeeting.where(component: conference.components).each do |conference_meeting|
-            next unless ::Faker::Boolean.boolean(true_ratio: 0.5)
+          create_conference_meeting!(conference:)
+        end
+      end
 
-            conference.speakers.sample(3).each do |speaker|
-              Decidim::ConferenceSpeakerConferenceMeeting.create!(
-                conference_meeting:,
-                conference_speaker: speaker
-              )
-            end
+      def create_content_block!
+        Decidim::ContentBlock.create(
+          organization:,
+          weight: 33,
+          scope_name: :homepage,
+          manifest_name: :highlighted_conferences,
+          published_at: Time.current
+        )
+      end
+
+      def create_conference!
+        params = {
+          title: Decidim::Faker::Localized.sentence(word_count: 5),
+          slogan: Decidim::Faker::Localized.sentence(word_count: 2),
+          slug: Decidim::Faker::Internet.unique.slug(words: nil, glue: "-"),
+          hashtag: "##{::Faker::Lorem.word}",
+          short_description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+            Decidim::Faker::Localized.sentence(word_count: 3)
+          end,
+          description: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+            Decidim::Faker::Localized.paragraph(sentence_count: 3)
+          end,
+          organization:,
+          hero_image: ::Faker::Boolean.boolean(true_ratio: 0.5) ? hero_image : nil, # Keep after organization
+          banner_image: ::Faker::Boolean.boolean(true_ratio: 0.5) ? banner_image : nil, # Keep after organization
+          promoted: true,
+          published_at: 2.weeks.ago,
+          objectives: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+            Decidim::Faker::Localized.paragraph(sentence_count: 3)
+          end,
+          start_date: Time.current,
+          end_date: 2.months.from_now.at_midnight,
+          registrations_enabled: [true, false].sample,
+          available_slots: (10..50).step(10).to_a.sample,
+          registration_terms: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+            Decidim::Faker::Localized.paragraph(sentence_count: 3)
+          end
+        }
+
+        conference = Decidim.traceability.perform_action!(
+          "publish",
+          Decidim::Conference,
+          organization.users.first,
+          visibility: "all"
+        ) do
+          Decidim::Conference.create!(params)
+        end
+        conference.add_to_index_as_search_resource
+
+        conference
+      end
+
+      def create_conference_user_roles!(conference:)
+        # Create users with specific roles
+        Decidim::ConferenceUserRole::ROLES.each do |role|
+          email = "conference_#{conference.id}_#{role}@example.org"
+          user = find_or_initialize_user_by(email:)
+
+          Decidim::ConferenceUserRole.find_or_create_by!(
+            user:,
+            conference:,
+            role:
+          )
+        end
+      end
+
+      def create_conference_speaker!(conference:)
+        Decidim::ConferenceSpeaker.create!(
+          user: conference.organization.users.sample,
+          full_name: ::Faker::Name.name,
+          position: Decidim::Faker::Localized.word,
+          affiliation: Decidim::Faker::Localized.sentence(word_count: 3),
+          short_bio: Decidim::Faker::Localized.wrapped("<p>", "</p>") do
+            Decidim::Faker::Localized.paragraph(sentence_count: 3)
+          end,
+          twitter_handle: ::Faker::Twitter.unique.screen_name,
+          personal_url: ::Faker::Internet.url,
+          published_at: Time.current,
+          conference:
+        )
+      end
+
+      def create_conference_partner!(conference:, type:)
+        Decidim::Conferences::Partner.create!(
+          name: ::Faker::Name.name,
+          weight: ::Faker::Number.between(from: 1, to: 10),
+          link: ::Faker::Internet.url,
+          partner_type: type,
+          conference:,
+          logo: create_blob!(seeds_file: "logo.png", filename: "logo.png", content_type: "image/png")
+        )
+      end
+
+      def create_conference_media_link!(conference:)
+        Decidim::Conferences::MediaLink.create!(
+          title: Decidim::Faker::Localized.sentence(word_count: 2),
+          link: ::Faker::Internet.url,
+          date: Date.current,
+          weight: ::Faker::Number.between(from: 1, to: 10),
+          conference:
+        )
+      end
+
+      def create_conference_registration_type!(conference:)
+        Decidim::Conferences::RegistrationType.create!(
+          title: Decidim::Faker::Localized.sentence(word_count: 2),
+          description: Decidim::Faker::Localized.sentence(word_count: 5),
+          weight: ::Faker::Number.between(from: 1, to: 10),
+          price: ::Faker::Number.between(from: 1, to: 300),
+          published_at: 2.weeks.ago,
+          conference:
+        )
+      end
+
+      def create_conference_meeting!(conference:)
+        Decidim::ConferenceMeeting.where(component: conference.components).each do |conference_meeting|
+          next unless ::Faker::Boolean.boolean(true_ratio: 0.5)
+
+          conference.speakers.sample(3).each do |speaker|
+            Decidim::ConferenceSpeakerConferenceMeeting.create!(
+              conference_meeting:,
+              conference_speaker: speaker
+            )
           end
         end
       end