fix: non bloccare go-live se agent slate Hetzner è down

Se il push della cover custom all'agent fallisce (timeout/connection refused),
usa lo slate di default invece di abortire la creazione sessione.

Co-authored-by: Cursor <cursoragent@cursor.com>

backend/app/controllers/admin/billing_controller.rb

@@ -2,6 +2,7 @@ module Admin
   class BillingController < BaseController
     def index
       @pending_payments = pending_scope.recent
+      @pending_transfers = transfer_scope
       @completed_payments = Billing::Payment.with_invoice_pdf.includes(:club, :invoice).recent.limit(40)
       @filter_club = Club.find_by(id: params[:club_id]) if params[:club_id].present?
       @clubs = Club.order(:name)
@@ -18,6 +19,25 @@ module Admin
                   alert: e.message
     end
 
+    def confirm_transfer
+      order = Billing::TransferOrder.find(params[:id])
+      Billing::ConfirmBankTransfer.call(
+        order: order,
+        admin: current_admin_account,
+        pdf: params[:pdf]
+      )
+      redirect_to admin_billing_path(club_id: order.club_id),
+                  notice: t("admin.flash.transfer_confirmed", plan: order.plan.name, club: order.club.name)
+    rescue Billing::ConfirmBankTransfer::Error, Billing::AttachPaymentInvoice::Error, Billing::IssueInvoice::Error => e
+      redirect_to admin_billing_path, alert: e.message
+    end
+
+    def cancel_transfer
+      order = Billing::TransferOrder.find(params[:id])
+      order.cancel!
+      redirect_to admin_billing_path(club_id: order.club_id), notice: t("admin.flash.transfer_cancelled")
+    end
+
     private
 
     def pending_scope
@@ -26,6 +46,12 @@ module Admin
       scope
     end
 
+    def transfer_scope
+      scope = Billing::TransferOrder.awaiting_payment.includes(:club, :requested_by_user)
+      scope = scope.where(club_id: params[:club_id]) if params[:club_id].present?
+      scope
+    end
+
     def billing_redirect_params(payment)
       { club_id: payment.club_id, anchor: "payment-#{payment.id}" }.compact
     end

backend/app/controllers/admin/clubs_controller.rb

@@ -1,9 +1,9 @@
 module Admin
   class ClubsController < BaseController
-    before_action :set_club, only: %i[show grant_comped revoke_comped]
+    before_action :set_club, only: %i[show grant_comped revoke_comped set_quote revoke_quote]
 
     def index
-      @clubs = Club.includes(:teams, subscription: %i[plan admin_comped_by])
+      @clubs = Club.includes(:teams, :billing_quote, subscription: %i[plan admin_comped_by])
                    .order(:name)
     end
 
@@ -11,6 +11,7 @@ module Admin
       @subscription = @club.subscription || @club.build_subscription(plan: Plan["free"], status: "active")
       @plans = Plan.ordered.reject { |p| p.slug == "free" }
       @teams = @club.teams.order(:name)
+      @quote = @club.active_billing_quote
     end
 
     def grant_comped
@@ -32,6 +33,32 @@ module Admin
       redirect_back_or_club alert: e.message
     end
 
+    def set_quote
+      quote = Billing::SetClubQuote.upsert(
+        club: @club,
+        plan_slug: params.require(:plan_slug),
+        interval: params[:interval],
+        amount_euros: params[:amount_euros],
+        note: params[:note],
+        admin: current_admin_account
+      )
+      redirect_back_or_club notice: t(
+        "admin.flash.quote_saved",
+        club: @club.name,
+        plan: quote.plan.name,
+        amount: quote.formatted_amount
+      )
+    rescue Billing::SetClubQuote::Error, ActionController::ParameterMissing => e
+      redirect_back_or_club alert: e.message
+    end
+
+    def revoke_quote
+      Billing::SetClubQuote.revoke(club: @club, admin: current_admin_account)
+      redirect_back_or_club notice: t("admin.flash.quote_revoked", club: @club.name)
+    rescue Billing::SetClubQuote::Error => e
+      redirect_back_or_club alert: e.message
+    end
+
     private
 
     def set_club

backend/app/controllers/api/v1/base_controller.rb

@@ -2,6 +2,7 @@ module Api
   module V1
     class BaseController < ApplicationController
       rescue_from Teams::EntitlementError, with: :render_entitlement_error
+      rescue_from BrandingAttachments::CoverUploadError, with: :render_cover_upload_error
       rescue_from Youtube::BroadcastService::Error, with: :render_youtube_error
 
       private
@@ -20,6 +21,10 @@ module Api
           billing_url: error.billing_url
         }, status: :forbidden
       end
+
+      def render_cover_upload_error(error)
+        render json: { error: error.message, error_code: "cover_upload_invalid" }, status: :unprocessable_entity
+      end
     end
   end
 end

backend/app/controllers/api/v1/matches_controller.rb

@@ -2,6 +2,7 @@ module Api
   module V1
     class MatchesController < BaseController
       include Api::UrlHelper
+      include Api::CoverJson
       include BrandingAttachments
 
       before_action :set_team, only: %i[index create]
@@ -21,6 +22,7 @@ module Api
         normalize_scoring_rules!(attrs)
         match = @team.matches.create!(attrs)
         attach_opponent_logo(match)
+        attach_match_cover(match)
         render json: match_json(match), status: :created
       end
 
@@ -34,6 +36,7 @@ module Api
         normalize_opponent_color!(attrs)
         @match.update!(attrs)
         attach_opponent_logo(@match)
+        attach_match_cover(@match)
         render json: match_json(@match)
       end
 
@@ -98,6 +101,11 @@ module Api
         match.opponent_logo_file.attach(file) if file.present?
       end
 
+      def attach_match_cover(match)
+        attach_cover_image(match, entitlements: match.team.entitlements)
+        enqueue_cover_slate_generation(match)
+      end
+
       def match_json(match, detail: false)
         active = active_session_for(match)
         team = match.team
@@ -123,6 +131,7 @@ module Api
           home_logo_url: api_absolute_url(team.effective_logo_url),
           opponent_primary_color: match.effective_opponent_primary_color,
           opponent_logo_url: api_absolute_url(match.opponent_logo_url),
+          **match_cover_json(match),
           active_session_id: active&.id,
           active_session_status: active&.status,
           stream_completed: match.stream_completed?,

backend/app/controllers/api/v1/teams_controller.rb

@@ -137,7 +137,8 @@ module Api
           youtube_mode: ent.plan.youtube_mode,
           staff_role: current_user.staff_role_for(team),
           can_stream: current_user.can_stream_for?(team),
-          can_connect_youtube: team.club.owned_by?(current_user) && ent.premium_full? && ent.youtube_enabled?
+          can_connect_youtube: team.club.owned_by?(current_user) && ent.premium_full? && ent.youtube_enabled?,
+          custom_cover_enabled: ent.can_use_custom_cover?
         }
         if detail
           data[:members] = team.user_teams.includes(:user).where.not(role: "owner").map do |ut|

backend/app/controllers/concerns/api/cover_json.rb

@@ -0,0 +1,16 @@
+module Api
+  module CoverJson
+    extend ActiveSupport::Concern
+
+    private
+
+    def match_cover_json(match)
+      resolver = Streams::CoverResolver.new(match)
+      {
+        effective_cover_url: api_absolute_url(resolver.effective_cover_url),
+        cover_source: resolver.cover_source,
+        custom_cover_enabled: match.team.entitlements.can_use_custom_cover?
+      }
+    end
+  end
+end

backend/app/controllers/concerns/branding_attachments.rb

@@ -8,6 +8,48 @@ module BrandingAttachments
     record.logo_file.attach(file) if file.present?
   end
 
+  def attach_cover_image(record, entitlements:)
+    remove_flag = params[:remove_cover].to_s == "1" || params.dig(:match, :remove_cover).to_s == "1"
+    if remove_flag
+      record.cover_image.purge if record.cover_image.attached?
+      record.cover_slate.purge if record.cover_slate.attached?
+      return
+    end
+
+    file = params.dig(:branding, :cover_image) || params[:cover_image]
+    return if file.blank?
+
+    entitlements.assert_can_upload_cover!
+    validate_cover_file!(file)
+    record.cover_slate.purge if record.cover_slate.attached?
+    record.cover_image.attach(file)
+  end
+
+  def validate_cover_file!(file)
+    allowed_types = Coverable::COVER_IMAGE_TYPES
+
+    # Rileva MIME dal contenuto (magic bytes) ignorando il declared_type del client.
+    io = file.respond_to?(:tempfile) ? file.tempfile : file
+    io.rewind if io.respond_to?(:rewind)
+    detected = Marcel::MimeType.for(io, name: file.respond_to?(:original_filename) ? file.original_filename : nil)
+    io.rewind if io.respond_to?(:rewind)
+
+    unless detected.in?(allowed_types)
+      raise CoverUploadError, I18n.t("coverable.errors.invalid_type")
+    end
+
+    byte_size = file.respond_to?(:size) ? file.size : File.size(file.path)
+    if byte_size > Coverable::MAX_COVER_BYTES
+      raise CoverUploadError, I18n.t("coverable.errors.too_large")
+    end
+  end
+
+  class CoverUploadError < StandardError; end
+
+  def enqueue_cover_slate_generation(record)
+    GenerateCoverSlateJob.enqueue_for(record) if record.cover_image.attached?
+  end
+
   def normalize_hex_color(value, fallback)
     v = value.to_s.strip
     v = "##{v}" if v.match?(/\A[0-9A-Fa-f]{6}\z/)

backend/app/controllers/public/club_billing_controller.rb

@@ -11,11 +11,15 @@ module Public
       @club.assign_attributes(billing_profile_params)
       if @club.save(context: :billing_profile)
         if premium_checkout_return_params.present? && @club.billing_profile_complete?
-          redirect_to public_club_checkout_path(
+          if @club.active_billing_quote.present?
-            @club,
+            redirect_to public_club_billing_path(@club), notice: t("flash.club_billing.profile_updated")
-            plan: premium_checkout_return_params[:plan],
+          else
-            interval: premium_checkout_return_params[:interval]
+            redirect_to public_club_checkout_path(
-          ), notice: t("flash.club_billing.profile_saved_proceed_payment")
+              @club,
+              plan: premium_checkout_return_params[:plan],
+              interval: premium_checkout_return_params[:interval]
+            ), notice: t("flash.club_billing.profile_saved_proceed_payment")
+          end
         else
           redirect_to public_club_billing_path(@club), notice: t("flash.club_billing.profile_updated")
         end
@@ -42,6 +46,29 @@ module Public
       redirect_to public_club_billing_path(@club), alert: t("flash.club_billing.stripe_error", message: e.message)
     end
 
+    def request_bank_transfer
+      if @club.subscription&.admin_comped?
+        redirect_to public_club_billing_path(@club), alert: t("flash.clubs.comped_change_denied")
+        return
+      end
+
+      unless @club.billing_profile_complete?
+        redirect_to public_club_billing_profile_path(@club, plan: params[:plan], interval: params[:interval]),
+                    alert: t("flash.clubs.complete_billing_first")
+        return
+      end
+
+      Billing::RequestBankTransfer.call(
+        club: @club,
+        user: current_user,
+        plan_slug: params[:plan],
+        interval: params[:interval]
+      )
+      redirect_to public_club_billing_path(@club), notice: t("flash.club_billing.bank_transfer_requested")
+    rescue Billing::RequestBankTransfer::Error, ArgumentError => e
+      redirect_to public_club_billing_path(@club), alert: e.message
+    end
+
     def download_invoice
       invoice = @club.billing_invoices.find(params[:invoice_id])
       unless invoice.pdf.attached?

backend/app/controllers/public/clubs_controller.rb

@@ -23,23 +23,28 @@ module Public
       ClubMembership.create!(user: current_user, club: club, role: "owner")
 
       first_team_name = params.dig(:first_team, :name).presence || t("club.new.default_first_team_name")
-      club.teams.create!(
+      first_team = club.teams.create!(
         name: first_team_name,
         sport: club.sport
       )
 
-      plan = params[:plan].presence_in(%w[free premium_light premium_full]) || "free"
+      desired_plan = params[:plan].presence_in(%w[free premium_light premium_full]) || "free"
-      Billing::AssignPlan.call(club: club, plan_slug: plan)
+      Billing::AssignPlan.call(club: club, plan_slug: "free")
+      Teams::StaffAssignment.designate_club_owner!(team: first_team, user: current_user)
 
-      if plan.in?(%w[premium_light premium_full]) && MatchLiveTv.stripe_enabled?
+      if desired_plan.in?(%w[premium_light premium_full])
-        unless club.billing_profile_complete?
+        interval = Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
-          redirect_to public_club_billing_profile_path(club, plan: plan, interval: checkout_interval_param),
+        if MatchLiveTv.stripe_enabled?
-                      alert: t("flash.clubs.complete_billing_first")
+          unless club.billing_profile_complete?
-          return
+            redirect_to public_club_billing_profile_path(club, plan: desired_plan, interval: interval),
+                        alert: t("flash.clubs.complete_billing_first")
+            return
+          end
+
+          redirect_to public_club_checkout_path(club, plan: desired_plan, interval: interval)
+        else
+          redirect_to public_club_billing_path(club), notice: t("flash.clubs.created_complete_subscription")
         end
-
-        interval = checkout_interval_param
-        redirect_to public_club_checkout_path(club, plan: plan, interval: interval)
       else
         redirect_to public_club_path(club), notice: t("flash.clubs.created")
       end
@@ -59,17 +64,26 @@ module Public
 
     def edit
       require_club_owner!(@club)
+      @entitlements = @club.teams.first&.entitlements
     end
 
     def update
       require_club_owner!(@club)
+      @entitlements = @club.teams.first!.entitlements
       @club.assign_attributes(club_params)
       attach_branding_logo(@club)
+      attach_cover_image(@club, entitlements: @entitlements)
       @club.save!
+      enqueue_cover_slate_generation(@club)
       redirect_to public_club_path(@club), notice: t("flash.clubs.updated")
     rescue ActiveRecord::RecordInvalid => e
+      @entitlements = @club.teams.first&.entitlements
       flash.now[:alert] = e.record.errors.full_messages.join(", ")
       render :edit, status: :unprocessable_entity
+    rescue Teams::EntitlementError, BrandingAttachments::CoverUploadError => e
+      @entitlements = @club.teams.first&.entitlements
+      flash.now[:alert] = e.message
+      render :edit, status: :unprocessable_entity
     end
 
     def billing
@@ -82,6 +96,8 @@ module Public
       @entitlements = @team.entitlements
       @plans = Plan.ordered
       @payments = @club.billing_payments.recent.includes(:invoice).limit(50)
+      @quote = @club.active_billing_quote
+      @pending_transfer = @club.billing_transfer_orders.awaiting_payment.first
     end
 
     def checkout
@@ -92,6 +108,12 @@ module Public
         return
       end
 
+      if @club.active_billing_quote.present?
+        redirect_to public_club_billing_path(@club),
+                    alert: t("flash.club_billing.quote_checkout_denied")
+        return
+      end
+
       unless MatchLiveTv.stripe_enabled?
         redirect_to public_club_billing_path(@club), alert: t("flash.clubs.stripe_not_configured")
         return

backend/app/controllers/public/live_controller.rb

@@ -51,6 +51,7 @@ module Public
         @session.status.in?(%w[connecting live reconnecting paused])
       )
       @publisher_online = !@stream_closed && mediamtx_publisher_online?(@session)
+      @cover_poster_url = Streams::CoverResolver.new(@match).effective_cover_url
     end
 
     def status

backend/app/controllers/public/teams_controller.rb

@@ -19,6 +19,7 @@ module Public
       require_club_owner!(@club)
       team = @club.teams.create!(team_params)
       attach_branding_logo(team)
+      Teams::StaffAssignment.designate_club_owner!(team: team, user: current_user)
       redirect_to public_club_path(@club), notice: t("flash.teams.added", name: team.name)
     rescue ActiveRecord::RecordInvalid => e
       flash.now[:alert] = e.record.errors.full_messages.join(", ")
@@ -41,19 +42,28 @@ module Public
     def edit
       require_club_owner_for_team!(@team)
       @club = @team.club
+      @entitlements = @team.entitlements
     end
 
     def update
       require_club_owner_for_team!(@team)
       @team.assign_attributes(team_params)
       attach_branding_logo(@team)
+      attach_cover_image(@team, entitlements: @team.entitlements)
       attach_team_photo(@team)
       @team.save!
+      enqueue_cover_slate_generation(@team)
       redirect_to public_team_details_path(@team), notice: t("flash.teams.updated")
     rescue ActiveRecord::RecordInvalid => e
       @club = @team.club
+      @entitlements = @team.entitlements
       flash.now[:alert] = e.record.errors.full_messages.join(", ")
       render :edit, status: :unprocessable_entity
+    rescue Teams::EntitlementError, BrandingAttachments::CoverUploadError => e
+      @club = @team.club
+      @entitlements = @team.entitlements
+      flash.now[:alert] = e.message
+      render :edit, status: :unprocessable_entity
     end
 
     def invite

backend/app/helpers/public/billing_helper.rb

@@ -1,6 +1,6 @@
 module Public
   module BillingHelper
-    def plan_billing_action(current_slug:, target_plan:, stripe_subscription_active:, current_interval: nil, subscription: nil)
+    def plan_billing_action(current_slug:, target_plan:, stripe_subscription_active:, current_interval: nil, subscription: nil, club: nil)
       if target_plan.slug == "free"
         return { kind: :current, label: I18n.t("billing.actions.current_plan") } if current_slug == "free"
         return { kind: :none } if stripe_subscription_active
@@ -8,17 +8,50 @@ module Public
         return { kind: :contact, label: I18n.t("billing.actions.contact_for_free") }
       end
 
+      quote = club&.active_billing_quote
+      if quote
+        if quote.plan_slug == target_plan.slug
+          if current_paid_plan?(subscription, target_plan)
+            return {
+              kind: :current,
+              label: "#{I18n.t('billing.actions.current_plan')} — #{quote.price_label}"
+            }
+          end
+
+          return { kind: :quoted, plan: target_plan, quote: quote, intervals: [quote.billing_interval] }
+        end
+
+        return { kind: :quoted_other, label: I18n.t("billing.bank_transfer.quoted_other") }
+      end
+
+      intervals = bank_transfer_intervals_for(target_plan)
       unless MatchLiveTv.stripe_enabled?
+        if current_paid_plan?(subscription, target_plan)
+          return { kind: :current, label: current_plan_label(target_plan, subscription) }
+        end
+        if MatchLiveTv.bank_transfer_configured?
+          return { kind: :bank_only, plan: target_plan, intervals: intervals }
+        end
+
         return { kind: :disabled, label: I18n.t("billing.actions.stripe_not_configured") }
       end
 
-      intervals = Billing::Stripe::PriceCatalog.available_intervals(plan_slug: target_plan.slug)
+      stripe_intervals = Billing::Stripe::PriceCatalog.available_intervals(plan_slug: target_plan.slug)
-      return { kind: :disabled, label: I18n.t("billing.actions.stripe_prices_not_configured") } if intervals.empty?
+      if stripe_intervals.empty?
+        if current_paid_plan?(subscription, target_plan)
+          return { kind: :current, label: current_plan_label(target_plan, subscription) }
+        end
+        if MatchLiveTv.bank_transfer_configured?
+          return { kind: :bank_only, plan: target_plan, intervals: intervals }
+        end
+
+        return { kind: :disabled, label: I18n.t("billing.actions.stripe_prices_not_configured") }
+      end
 
       active_interval = current_interval.presence || Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
 
       if current_slug == target_plan.slug && stripe_subscription_active && !subscription&.plan_change_pending?
-        other_intervals = intervals - [active_interval]
+        other_intervals = stripe_intervals - [active_interval]
         if other_intervals.empty?
           label = "#{I18n.t('billing.actions.current_plan')} — #{Billing::Stripe::PriceCatalog.label(plan_slug: target_plan.slug, interval: active_interval)}"
           return { kind: :current, label: label }
@@ -34,13 +67,17 @@ module Public
         }
       end
 
+      if current_paid_plan?(subscription, target_plan)
+        return { kind: :current, label: current_plan_label(target_plan, subscription) }
+      end
+
       if current_slug == "free" || !stripe_subscription_active
-        { kind: :checkout_options, plan: target_plan, intervals: intervals, subscription: subscription }
+        { kind: :checkout_options, plan: target_plan, intervals: stripe_intervals.presence || intervals, subscription: subscription }
       else
         {
           kind: :change_options,
           plan: target_plan,
-          intervals: intervals,
+          intervals: stripe_intervals,
           current_slug: current_slug,
           current_interval: active_interval,
           subscription: subscription
@@ -96,5 +133,41 @@ module Public
       I18n.t("billing.actions.profile_missing", fields: missing.join(", "))
     end
 
+    def bank_transfer_intervals_for(plan)
+      Billing::Stripe::PriceCatalog.catalog_intervals(plan_slug: plan.slug)
+    end
+
+    def bank_transfer_price_label(plan, interval, quote: nil)
+      if quote&.matches?(plan.slug, interval)
+        quote.price_label
+      else
+        Billing::Stripe::PriceCatalog.format_interval_price(
+          Billing::Stripe::PriceCatalog.amount_cents(plan_slug: plan.slug, interval: interval),
+          interval
+        )
+      end
+    end
+
+    def show_bank_transfer_for?(club:, plan:, interval:, quote: nil, pending_transfer: nil)
+      return false unless club.present? && plan.slug != "free"
+      return false unless MatchLiveTv.bank_transfer_configured?
+      return false if quote && !quote.matches?(plan.slug, interval)
+      return false if pending_transfer&.awaiting_payment?
+      return false if current_paid_plan?(club.subscription, plan)
+
+      true
+    end
+
+    def current_paid_plan?(subscription, target_plan)
+      return false unless subscription&.active? && subscription.premium?
+      return false if subscription.plan_change_pending?
+
+      subscription.plan.slug == target_plan.slug
+    end
+
+    def current_plan_label(target_plan, subscription)
+      interval = subscription&.billing_interval.presence || Billing::Stripe::PriceCatalog::DEFAULT_INTERVAL
+      "#{I18n.t('billing.actions.current_plan')} — #{Billing::Stripe::PriceCatalog.label(plan_slug: target_plan.slug, interval: interval)}"
+    end
   end
 end

backend/app/helpers/public/regia_helper.rb

@@ -52,6 +52,18 @@ module Public
         muteError: t("regia.js.mute_error"),
         closeError: t("regia.js.close_error"),
         closeConfirm: t("regia.js.close_confirm"),
+        pauseConfirmTitle: t("regia.js.pause_confirm_title"),
+        pauseConfirmBody: t("regia.js.pause_confirm_body"),
+        resumeConfirmTitle: t("regia.js.resume_confirm_title"),
+        resumeConfirmBody: t("regia.js.resume_confirm_body"),
+        muteConfirmTitle: t("regia.js.mute_confirm_title"),
+        muteConfirmBody: t("regia.js.mute_confirm_body"),
+        unmuteConfirmTitle: t("regia.js.unmute_confirm_title"),
+        unmuteConfirmBody: t("regia.js.unmute_confirm_body"),
+        advancePeriodTitle: t("regia.js.advance_period_title"),
+        advancePeriodBody: t("regia.js.advance_period_body"),
+        confirmAction: t("regia.modal.confirm_action"),
+        stopConfirmTitle: t("regia.js.stop_confirm_title"),
         linkUnavailable: t("regia.js.link_unavailable"),
         linkCopied: t("regia.js.link_copied"),
         copyPrompt: t("regia.js.copy_prompt"),

backend/app/jobs/expire_ended_subscriptions_job.rb

@@ -6,12 +6,37 @@ class ExpireEndedSubscriptionsJob
     free_plan = Plan["free"]
 
     Subscription.where(cancel_at_period_end: true)
-                  .where("current_period_end <= ?", Time.current)
+                .where("current_period_end <= ?", Time.current)
-                  .where.not(plan_id: free_plan.id)
+                .where.not(plan_id: free_plan.id)
-                  .find_each do |sub|
+                .where(admin_comped: false)
-      Billing::Stripe::FinalizeSubscription.call(club: sub.club)
+                .find_each do |sub|
+      expire!(sub)
     rescue StandardError => e
       Rails.logger.warn("[ExpireEndedSubscriptions] club=#{sub.club_id} #{e.message}")
     end
   end
+
+  private
+
+  def expire!(sub)
+    if sub.stripe_subscription_id.present?
+      Billing::Stripe::FinalizeSubscription.call(club: sub.club)
+    else
+      Billing::AssignPlan.call(
+        club: sub.club,
+        plan_slug: "free",
+        status: "active",
+        stripe_attrs: {
+          stripe_subscription_id: nil,
+          stripe_schedule_id: nil,
+          current_period_start: nil,
+          current_period_end: nil,
+          cancel_at_period_end: false,
+          billing_interval: nil,
+          pending_plan_id: nil,
+          pending_billing_interval: nil
+        }
+      )
+    end
+  end
 end

backend/app/jobs/generate_cover_slate_job.rb

@@ -0,0 +1,19 @@
+class GenerateCoverSlateJob < ApplicationJob
+  queue_as :default
+
+  def self.enqueue_for(record)
+    return unless record&.cover_image&.attached?
+
+    queue = record.is_a?(Match) ? :critical : :default
+    set(queue: queue).perform_later(record.class.name, record.id)
+  end
+
+  def perform(class_name, record_id)
+    record = class_name.constantize.find_by(id: record_id)
+    return unless record&.cover_image&.attached?
+
+    Streams::GenerateCoverSlate.call(record)
+  rescue Streams::GenerateCoverSlate::Error => e
+    Rails.logger.warn("[GenerateCoverSlateJob] #{class_name}##{record_id} #{e.message}")
+  end
+end

backend/app/mailers/billing/bank_transfer_mailer.rb

@@ -0,0 +1,35 @@
+module Billing
+  class BankTransferMailer < ApplicationMailer
+    def instructions
+      @order = params[:order]
+      @club = @order.club
+      @iban = MatchLiveTv.bank_transfer_iban
+      @holder = MatchLiveTv.bank_transfer_account_holder
+      @bank_name = MatchLiveTv.bank_transfer_bank_name
+      @bic = MatchLiveTv.bank_transfer_bic
+      @proof_email = MatchLiveTv.bank_transfer_proof_email
+
+      mail(
+        to: recipient_email,
+        subject: t("mailers.bank_transfer.instructions.subject", plan: @order.plan.name)
+      )
+    end
+
+    def plan_activated
+      @order = params[:order]
+      @club = @order.club
+      @subscription = @club.subscription
+
+      mail(
+        to: recipient_email,
+        subject: t("mailers.bank_transfer.plan_activated.subject", plan: @order.plan.name)
+      )
+    end
+
+    private
+
+    def recipient_email
+      @club.billing_email.presence || @club.owner&.email
+    end
+  end
+end

backend/app/mailers/billing/invoice_mailer.rb

@@ -5,17 +5,37 @@ module Billing
       @club = @invoice.club
 
       I18n.with_locale(I18n.locale) do
-        prefix = t("mailers.invoice.attachment_prefix")
+        attach_invoice_pdf!
-        attachments["#{prefix}-#{@invoice.number.parameterize}.pdf"] = {
-          mime_type: "application/pdf",
-          content: @invoice.pdf.download
-        }
-
         mail(
           to: @club.billing_email,
           subject: t("mailers.invoice.subject", number: @invoice.display_number)
         )
       end
     end
+
+    def plan_activated_with_invoice
+      @invoice = params[:invoice]
+      @club = @invoice.club
+
+      I18n.with_locale(I18n.locale) do
+        attach_invoice_pdf!
+        mail(
+          to: @club.billing_email,
+          subject: t("mailers.invoice_activated.subject",
+                     plan: @club.subscription&.plan&.name || @invoice.display_number,
+                     number: @invoice.display_number)
+        )
+      end
+    end
+
+    private
+
+    def attach_invoice_pdf!
+      prefix = t("mailers.invoice.attachment_prefix")
+      attachments["#{prefix}-#{@invoice.number.parameterize}.pdf"] = {
+        mime_type: "application/pdf",
+        content: @invoice.pdf.download
+      }
+    end
   end
 end

backend/app/models/billing/club_quote.rb

@@ -0,0 +1,34 @@
+module Billing
+  class ClubQuote < ApplicationRecord
+    self.table_name = "billing_club_quotes"
+
+    PLAN_SLUGS = %w[premium_light premium_full].freeze
+    INTERVALS = Billing::Stripe::PriceCatalog::INTERVALS
+
+    belongs_to :club
+    belongs_to :created_by_admin, class_name: "AdminAccount", optional: true
+
+    validates :plan_slug, inclusion: { in: PLAN_SLUGS }
+    validates :billing_interval, inclusion: { in: INTERVALS }
+    validates :amount_cents, numericality: { greater_than: 0 }
+    validates :currency, presence: true
+
+    scope :active, -> { where(active: true) }
+
+    def matches?(plan_slug, interval)
+      self.plan_slug == plan_slug.to_s && billing_interval == interval.to_s
+    end
+
+    def plan
+      Plan[plan_slug]
+    end
+
+    def formatted_amount
+      Billing::Stripe::PriceCatalog.format_eur(amount_cents)
+    end
+
+    def price_label
+      Billing::Stripe::PriceCatalog.format_interval_price(amount_cents, billing_interval)
+    end
+  end
+end

backend/app/models/billing/payment.rb

@@ -2,14 +2,17 @@ module Billing
   class Payment < ApplicationRecord
     self.table_name = "billing_payments"
 
-    STATUSES = %w[paid failed refunded].freeze
+    STATUSES = %w[pending paid failed refunded].freeze
+    PROVIDERS = %w[stripe bank_transfer].freeze
 
     belongs_to :club
     has_one :invoice, class_name: "Billing::Invoice", foreign_key: :billing_payment_id, dependent: :nullify
+    has_one :transfer_order, class_name: "Billing::TransferOrder", foreign_key: :billing_payment_id, dependent: :nullify
 
     validates :amount_cents, numericality: { greater_than: 0 }
     validates :currency, presence: true
     validates :status, inclusion: { in: STATUSES }
+    validates :provider, inclusion: { in: PROVIDERS }
     validates :stripe_invoice_id, uniqueness: true, allow_nil: true
 
     scope :recent, -> { order(paid_at: :desc, created_at: :desc) }
@@ -62,7 +65,12 @@ module Billing
     end
 
     def display_status
-      { "paid" => "Pagato", "failed" => "Non riuscito", "refunded" => "Rimborsato" }[status] || status
+      {
+        "pending" => "In attesa di bonifico",
+        "paid" => "Pagato",
+        "failed" => "Non riuscito",
+        "refunded" => "Rimborsato"
+      }[status] || status
     end
 
     def invoice_for_display

backend/app/models/billing/transfer_order.rb

@@ -0,0 +1,67 @@
+module Billing
+  class TransferOrder < ApplicationRecord
+    self.table_name = "billing_transfer_orders"
+
+    KINDS = %w[list_price commercial_quote].freeze
+    STATUSES = %w[awaiting_payment paid cancelled].freeze
+    PLAN_SLUGS = ClubQuote::PLAN_SLUGS
+    INTERVALS = ClubQuote::INTERVALS
+
+    belongs_to :club
+    belongs_to :billing_club_quote, class_name: "Billing::ClubQuote", optional: true
+    belongs_to :billing_payment, class_name: "Billing::Payment", optional: true
+    belongs_to :requested_by_user, class_name: "User", optional: true
+    belongs_to :confirmed_by_admin, class_name: "AdminAccount", optional: true
+
+    validates :plan_slug, inclusion: { in: PLAN_SLUGS }
+    validates :billing_interval, inclusion: { in: INTERVALS }
+    validates :amount_cents, numericality: { greater_than: 0 }
+    validates :kind, inclusion: { in: KINDS }
+    validates :status, inclusion: { in: STATUSES }
+    validates :reference_code, presence: true, uniqueness: true
+    validates :currency, presence: true
+
+    scope :awaiting_payment, -> { where(status: "awaiting_payment").order(created_at: :desc) }
+    scope :recent, -> { order(created_at: :desc) }
+
+    def awaiting_payment?
+      status == "awaiting_payment"
+    end
+
+    def paid?
+      status == "paid"
+    end
+
+    def quoted?
+      kind == "commercial_quote"
+    end
+
+    def plan
+      Plan[plan_slug]
+    end
+
+    def formatted_amount
+      format("%.2f €", amount_cents / 100.0)
+    end
+
+    def price_label
+      Billing::Stripe::PriceCatalog.format_interval_price(amount_cents, billing_interval)
+    end
+
+    def payment_causal
+      "MLTV #{reference_code} #{club.name}".truncate(140, omission: "")
+    end
+
+    def cancel!
+      return self unless awaiting_payment?
+
+      transaction do
+        update!(status: "cancelled", cancelled_at: Time.current)
+        if billing_payment&.status == "pending"
+          billing_payment.update!(status: "failed")
+        end
+      end
+      self
+    end
+  end
+end

backend/app/models/club.rb

@@ -1,5 +1,6 @@
 class Club < ApplicationRecord
   include Brandable
+  include Coverable
   include ClubBillingProfile
 
   has_many :club_memberships, dependent: :destroy
@@ -7,8 +8,11 @@ class Club < ApplicationRecord
   has_many :teams, dependent: :destroy
   has_one :youtube_credential, dependent: :destroy
   has_one :subscription, dependent: :destroy
+  has_one :billing_quote, -> { where(active: true) }, class_name: "Billing::ClubQuote", inverse_of: :club
+  has_many :billing_quotes, class_name: "Billing::ClubQuote", dependent: :destroy, inverse_of: :club
   has_many :billing_payments, class_name: "Billing::Payment", dependent: :destroy
   has_many :billing_invoices, class_name: "Billing::Invoice", dependent: :destroy
+  has_many :billing_transfer_orders, class_name: "Billing::TransferOrder", dependent: :destroy
 
   validates :name, presence: true
   validates :sport, presence: true
@@ -23,6 +27,14 @@ class Club < ApplicationRecord
     club_memberships.exists?(user: user, role: "owner")
   end
 
+  def active_billing_quote
+    billing_quote
+  end
+
+  def pending_transfer_order
+    billing_transfer_orders.awaiting_payment.first
+  end
+
   private
 
   def branding_parent

backend/app/models/concerns/coverable.rb

@@ -0,0 +1,50 @@
+module Coverable
+  extend ActiveSupport::Concern
+
+  COVER_IMAGE_TYPES = %w[image/png image/jpeg image/webp].freeze
+  MAX_COVER_BYTES = 5.megabytes
+
+  included do
+    has_one_attached :cover_image
+    has_one_attached :cover_slate
+
+    validate :cover_image_file_type, if: -> { cover_image.attached? }
+    validate :cover_image_file_size, if: -> { cover_image.attached? }
+  end
+
+  def cover_image_attached?
+    cover_image.attached?
+  end
+
+  def cover_url
+    return unless cover_image.attached?
+
+    Rails.application.routes.url_helpers.rails_blob_path(cover_image, only_path: true)
+  end
+
+  def effective_cover_url
+    if cover_image.attached?
+      cover_url
+    else
+      cover_parent&.effective_cover_url
+    end
+  end
+
+  private
+
+  def cover_parent
+    nil
+  end
+
+  def cover_image_file_type
+    return if cover_image.content_type.in?(COVER_IMAGE_TYPES)
+
+    errors.add(:cover_image, I18n.t("coverable.errors.invalid_type"))
+  end
+
+  def cover_image_file_size
+    return if cover_image.byte_size <= MAX_COVER_BYTES
+
+    errors.add(:cover_image, I18n.t("coverable.errors.too_large"))
+  end
+end

backend/app/models/match.rb

@@ -1,4 +1,6 @@
 class Match < ApplicationRecord
+  include Coverable
+
   belongs_to :team
   has_many :stream_sessions, dependent: :destroy
 
@@ -174,4 +176,8 @@ class Match < ApplicationRecord
   rescue ArgumentError => e
     errors.add(:scoring_rules, e.message)
   end
+
+  def cover_parent
+    nil
+  end
 end

backend/app/models/plan.rb

@@ -84,6 +84,10 @@ class Plan < ApplicationRecord
     feature("youtube_enabled") == true
   end
 
+  def custom_cover_enabled?
+    feature("custom_cover") == true
+  end
+
   def premium?
     slug.in?(PREMIUM_SLUGS)
   end

backend/app/models/stream_node.rb

@@ -35,4 +35,20 @@ class StreamNode < ApplicationRecord
   def allocatable?
     status == "ready" && free_slots.positive?
   end
+
+  # Agent ffmpeg sul CPX (cloud-init :9100). Home Sidekiq lo chiama senza worker Docker per nodo.
+  def relay_agent_url
+    return unless role == "cloud"
+
+    ip = (metadata || {})["public_ip"].presence
+    if ip.blank?
+      host = URI.parse(api_base_url.to_s).host
+      ip = host if host.present? && host != "localhost"
+    end
+    return if ip.blank? || ip == "127.0.0.1"
+
+    "http://#{ip}:#{ENV.fetch("STREAM_NODE_AGENT_PORT", "9100")}"
+  rescue URI::InvalidURIError
+    nil
+  end
 end

backend/app/models/subscription.rb

@@ -35,4 +35,8 @@ class Subscription < ApplicationRecord
   def admin_comped?
     admin_comped
   end
+
+  def bank_transfer?
+    premium? && stripe_subscription_id.blank? && !admin_comped? && current_period_end.present?
+  end
 end

backend/app/models/team.rb

@@ -1,5 +1,6 @@
 class Team < ApplicationRecord
   include Brandable
+  include Coverable
 
   belongs_to :club
   has_many :user_teams, dependent: :destroy
@@ -99,6 +100,10 @@ class Team < ApplicationRecord
     club
   end
 
+  def cover_parent
+    club
+  end
+
   def assign_slug
     self.slug = Teams::GenerateSlug.call(self) if slug.blank?
   end

backend/app/services/billing/admin_comped_subscription.rb

@@ -23,6 +23,7 @@ module Billing
       raise Error, "Piano non valido" unless @plan_slug.in?(VALID_PLANS)
 
       release_stripe_schedule!
+      cancel_awaiting_transfers!
 
       AssignPlan.call(
         club: @club,
@@ -97,5 +98,9 @@ module Billing
     ensure
       sub&.update!(stripe_schedule_id: nil, pending_plan_id: nil, pending_billing_interval: nil)
     end
+
+    def cancel_awaiting_transfers!
+      @club.billing_transfer_orders.awaiting_payment.find_each(&:cancel!)
+    end
   end
 end

backend/app/services/billing/attach_payment_invoice.rb

@@ -2,13 +2,14 @@ module Billing
   class AttachPaymentInvoice
     class Error < StandardError; end
 
-    def self.call(payment:, pdf:)
+    def self.call(payment:, pdf:, mailer_action: :invoice_pdf)
-      new(payment: payment, pdf: pdf).call
+      new(payment: payment, pdf: pdf, mailer_action: mailer_action).call
     end
 
-    def initialize(payment:, pdf:)
+    def initialize(payment:, pdf:, mailer_action: :invoice_pdf)
       @payment = payment
       @pdf = pdf
+      @mailer_action = mailer_action
     end
 
     def call
@@ -17,7 +18,7 @@ module Billing
 
       club = @payment.club
       invoice = @payment.invoice || build_invoice!(club)
-      IssueInvoice.call(invoice: invoice, pdf: @pdf)
+      IssueInvoice.call(invoice: invoice, pdf: @pdf, mailer_action: @mailer_action)
     end
 
     private

backend/app/services/billing/confirm_bank_transfer.rb

@@ -0,0 +1,102 @@
+module Billing
+  class ConfirmBankTransfer
+    class Error < StandardError; end
+
+    def self.call(order:, admin:, pdf: nil)
+      new(order: order, admin: admin, pdf: pdf).call
+    end
+
+    def initialize(order:, admin:, pdf: nil)
+      @order = order
+      @admin = admin
+      @pdf = pdf
+    end
+
+    def call
+      raise Error, "Bonifico già gestito" unless @order.awaiting_payment?
+
+      club = @order.club
+      payment = @order.billing_payment
+      raise Error, "Pagamento collegato mancante" if payment.blank?
+
+      ApplicationRecord.transaction do
+        cancel_existing_stripe!(club.subscription)
+
+        period_start, period_end = period_bounds(club.subscription)
+        AssignPlan.call(
+          club: club,
+          plan_slug: @order.plan_slug,
+          status: "active",
+          stripe_attrs: {
+            stripe_subscription_id: nil,
+            stripe_schedule_id: nil,
+            pending_plan_id: nil,
+            pending_billing_interval: nil,
+            billing_interval: @order.billing_interval,
+            current_period_start: period_start,
+            current_period_end: period_end,
+            cancel_at_period_end: true,
+            admin_comped: false,
+            admin_comped_reason: nil,
+            admin_comped_at: nil,
+            admin_comped_by_id: nil
+          }
+        )
+
+        payment.update!(status: "paid", paid_at: Time.current, provider: "bank_transfer")
+        @order.update!(
+          status: "paid",
+          confirmed_by_admin: @admin,
+          confirmed_at: Time.current
+        )
+      end
+
+      deliver_activation!(payment)
+      @order.reload
+    end
+
+    private
+
+    def period_bounds(subscription)
+      start_at = Time.current
+      if subscription&.premium? &&
+         !subscription.admin_comped? &&
+         subscription.plan.slug == @order.plan_slug &&
+         subscription.current_period_end.present? &&
+         subscription.current_period_end > Time.current
+        start_at = subscription.current_period_end
+      end
+
+      end_at = @order.billing_interval == "yearly" ? start_at.advance(years: 1) : start_at.advance(months: 1)
+      [start_at, end_at]
+    end
+
+    def cancel_existing_stripe!(subscription)
+      return if subscription.blank? || subscription.stripe_subscription_id.blank?
+      return unless MatchLiveTv.stripe_enabled?
+
+      ::Stripe::Subscription.cancel(subscription.stripe_subscription_id)
+    rescue ::Stripe::InvalidRequestError => e
+      Rails.logger.warn("[BankTransfer] stripe cancel club=#{subscription.club_id} #{e.message}")
+    end
+
+    def deliver_activation!(payment)
+      if pdf_present?
+        AttachPaymentInvoice.call(
+          payment: payment.reload,
+          pdf: @pdf,
+          mailer_action: :plan_activated_with_invoice
+        )
+      else
+        MatchLiveTv.deliver_mail(BankTransferMailer.with(order: @order.reload).plan_activated)
+      end
+    end
+
+    def pdf_present?
+      return false if @pdf.blank?
+      return @pdf.present? unless @pdf.respond_to?(:tempfile)
+
+      @pdf.original_filename.present?
+    end
+  end
+end

backend/app/services/billing/euro_amount.rb

@@ -0,0 +1,26 @@
+module Billing
+  class EuroAmount
+    class Error < StandardError; end
+
+    def self.to_cents(value)
+      raw = value.to_s.strip
+      raise Error, "Indica l'importo in euro" if raw.blank?
+
+      normalized = raw.gsub(/\s+/, "")
+      if normalized.match?(/\A\d{1,3}(\.\d{3})*,\d{1,2}\z/)
+        normalized = normalized.gsub(".", "").tr(",", ".")
+      elsif normalized.match?(/\A\d+,\d{1,2}\z/)
+        normalized = normalized.tr(",", ".")
+      elsif normalized.match?(/\A\d{1,3}(,\d{3})*\.\d{1,2}\z/)
+        normalized = normalized.gsub(",", "")
+      end
+
+      raise Error, "Importo non valido" unless normalized.match?(/\A\d+(\.\d{1,2})?\z/)
+
+      cents = (BigDecimal(normalized) * 100).round
+      raise Error, "L'importo deve essere maggiore di zero" unless cents.positive?
+
+      cents.to_i
+    end
+  end
+end

backend/app/services/billing/issue_invoice.rb

@@ -2,13 +2,17 @@ module Billing
   class IssueInvoice
     class Error < StandardError; end
 
-    def self.call(invoice:, pdf: nil)
+    MAILER_ACTIONS = %i[invoice_pdf plan_activated_with_invoice].freeze
-      new(invoice: invoice, pdf: pdf).call
+
+    def self.call(invoice:, pdf: nil, mailer_action: :invoice_pdf)
+      new(invoice: invoice, pdf: pdf, mailer_action: mailer_action).call
     end
 
-    def initialize(invoice:, pdf: nil)
+    def initialize(invoice:, pdf: nil, mailer_action: :invoice_pdf)
       @invoice = invoice
       @pdf = pdf
+      @mailer_action = mailer_action.to_sym
+      raise Error, "Azione email non valida" unless MAILER_ACTIONS.include?(@mailer_action)
     end
 
     def call
@@ -22,8 +26,10 @@ module Billing
 
       @invoice.update!(status: "issued")
 
-      Billing::InvoiceMailer.with(invoice: @invoice).invoice_pdf.deliver_now
+      mail = Billing::InvoiceMailer.with(invoice: @invoice).public_send(@mailer_action)
-      @invoice.update!(status: "sent", emailed_at: Time.current)
+      if MatchLiveTv.deliver_mail(mail)
+        @invoice.update!(status: "sent", emailed_at: Time.current)
+      end
 
       @invoice
     end

backend/app/services/billing/request_bank_transfer.rb

@@ -0,0 +1,95 @@
+module Billing
+  class RequestBankTransfer
+    class Error < StandardError; end
+
+    PLAN_SLUGS = %w[premium_light premium_full].freeze
+
+    def self.call(club:, user:, plan_slug:, interval:)
+      new(club: club, user: user, plan_slug: plan_slug, interval: interval).call
+    end
+
+    def initialize(club:, user:, plan_slug:, interval:)
+      @club = club
+      @user = user
+      @plan_slug = plan_slug.to_s
+      @interval = interval
+    end
+
+    def call
+      raise Error, "Bonifico non configurato sul server" unless MatchLiveTv.bank_transfer_configured?
+      raise Error, "Piano non valido" unless @plan_slug.in?(PLAN_SLUGS)
+      raise Error, "Completa i dati di fatturazione prima di richiedere il bonifico." unless @club.billing_profile_complete?
+      raise Error, "Il piano è un abbonamento omaggio. Contatta il supporto per passarlo a pagamento." if @club.subscription&.admin_comped?
+
+      @interval = Billing::Stripe::PriceCatalog.normalize_interval(@interval)
+      quote = @club.active_billing_quote
+      amount_cents, kind = resolve_amount(quote)
+
+      existing = @club.billing_transfer_orders.awaiting_payment.first
+      if existing
+        if existing.plan_slug == @plan_slug && existing.billing_interval == @interval && existing.amount_cents == amount_cents
+          return existing
+        end
+
+        existing.cancel!
+      end
+
+      order = nil
+      ApplicationRecord.transaction do
+        payment = @club.billing_payments.create!(
+          provider: "bank_transfer",
+          amount_cents: amount_cents,
+          currency: "eur",
+          status: "pending",
+          plan_slug: @plan_slug,
+          description: payment_description(kind, amount_cents)
+        )
+        order = @club.billing_transfer_orders.create!(
+          billing_club_quote: kind == "commercial_quote" ? quote : nil,
+          billing_payment: payment,
+          plan_slug: @plan_slug,
+          billing_interval: @interval,
+          amount_cents: amount_cents,
+          currency: "eur",
+          kind: kind,
+          status: "awaiting_payment",
+          reference_code: generate_reference_code,
+          requested_by_user: @user
+        )
+      end
+
+      # Le istruzioni (IBAN/causale) le manda a mano l'admin da /admin/billing.
+      Rails.logger.info("[BankTransfer] ordine #{order.reference_code} in attesa, nessuna mail istruzioni")
+      order
+    end
+
+    private
+
+    def resolve_amount(quote)
+      if quote
+        unless quote.matches?(@plan_slug, @interval)
+          raise Error, "Per questa società è attivo un prezzo concordato su #{quote.plan.name} (#{quote.price_label})."
+        end
+
+        return [quote.amount_cents, "commercial_quote"]
+      end
+
+      [Billing::Stripe::PriceCatalog.amount_cents(plan_slug: @plan_slug, interval: @interval), "list_price"]
+    end
+
+    def payment_description(kind, amount_cents)
+      label = Billing::Stripe::PriceCatalog.format_interval_price(amount_cents, @interval)
+      suffix = kind == "commercial_quote" ? "prezzo concordato, bonifico" : "bonifico"
+      "#{Plan[@plan_slug].name} — #{label} (#{suffix})"
+    end
+
+    def generate_reference_code
+      8.times do
+        code = "MLTV-#{SecureRandom.alphanumeric(6).upcase}"
+        return code unless TransferOrder.exists?(reference_code: code)
+      end
+
+      raise Error, "Impossibile generare il riferimento del bonifico"
+    end
+  end
+end

backend/app/services/billing/set_club_quote.rb

@@ -0,0 +1,74 @@
+module Billing
+  class SetClubQuote
+    class Error < StandardError; end
+
+    PLAN_SLUGS = %w[premium_light premium_full].freeze
+
+    def self.upsert(club:, plan_slug:, interval:, amount_euros:, note:, admin:)
+      new(club: club, plan_slug: plan_slug, interval: interval, amount_euros: amount_euros, note: note, admin: admin).upsert
+    end
+
+    def self.revoke(club:, admin:)
+      new(club: club, admin: admin).revoke
+    end
+
+    def initialize(club:, plan_slug: nil, interval: nil, amount_euros: nil, note: nil, admin: nil)
+      @club = club
+      @plan_slug = plan_slug.to_s.presence
+      @interval = interval
+      @amount_euros = amount_euros
+      @note = note.to_s.strip.presence
+      @admin = admin
+    end
+
+    def upsert
+      raise Error, "Piano non valido" unless @plan_slug.in?(PLAN_SLUGS)
+
+      interval = Billing::Stripe::PriceCatalog.normalize_interval(@interval)
+      amount_cents = EuroAmount.to_cents(@amount_euros)
+      quote = @club.billing_quotes.active.first || @club.billing_quotes.build
+
+      ApplicationRecord.transaction do
+        quote.assign_attributes(
+          plan_slug: @plan_slug,
+          billing_interval: interval,
+          amount_cents: amount_cents,
+          currency: "eur",
+          note: @note,
+          active: true,
+          created_by_admin: @admin || quote.created_by_admin
+        )
+        quote.save!
+
+        cancel_incompatible_orders!(quote)
+      end
+
+      quote
+    rescue EuroAmount::Error, ArgumentError => e
+      raise Error, e.message
+    end
+
+    def revoke
+      quote = @club.active_billing_quote
+      raise Error, "Nessun prezzo concordato attivo" if quote.blank?
+
+      ApplicationRecord.transaction do
+        quote.update!(active: false)
+        @club.billing_transfer_orders.awaiting_payment.where(kind: "commercial_quote").find_each(&:cancel!)
+      end
+      quote
+    end
+
+    private
+
+    def cancel_incompatible_orders!(quote)
+      @club.billing_transfer_orders.awaiting_payment.find_each do |order|
+        next if order.plan_slug == quote.plan_slug &&
+                order.billing_interval == quote.billing_interval &&
+                order.amount_cents == quote.amount_cents
+
+        order.cancel!
+      end
+    end
+  end
+end

backend/app/services/billing/stripe/price_catalog.rb

@@ -86,6 +86,24 @@ module Billing
           end
         end
 
+        def catalog_intervals(plan_slug:)
+          INTERVALS.select { |interval| AMOUNTS.dig(plan_slug.to_s, interval, :charge).present? }
+        end
+
+        def amount_cents(plan_slug:, interval:)
+          interval = normalize_interval(interval)
+          cents = charge_cents(plan_slug, interval)
+          raise ArgumentError, "Prezzo listino non disponibile per #{plan_slug} (#{interval})" if cents.blank?
+
+          cents
+        end
+
+        def format_interval_price(cents, interval)
+          return nil if cents.blank?
+
+          I18n.t("billing.prices.#{interval}", amount: format_eur(cents))
+        end
+
         private
 
         def charge_cents(plan_slug, interval)
@@ -96,12 +114,6 @@ module Billing
           AMOUNTS.dig(plan_slug.to_s, interval, :list)
         end
 
-        def format_interval_price(cents, interval)
-          return nil if cents.blank?
-
-          I18n.t("billing.prices.#{interval}", amount: format_eur(cents))
-        end
-
         def price_id_for(plan_slug, interval)
           case [plan_slug, interval]
           when %w[premium_light monthly]

backend/app/services/mediamtx/client.rb

@@ -28,7 +28,7 @@ module Mediamtx
         overridePublisher: true
       )
       body[:alwaysAvailable] = true
-      body[:alwaysAvailableFile] = slate_file_path
+      body[:alwaysAvailableFile] = slate_file_path(session)
       # YouTube: telefono → MediaMTX; relay copy verso RTMPS in sidekiq.
       response = @conn.post("/v3/config/paths/add/#{CGI.escape(path)}", body)
       unless response.success?
@@ -74,14 +74,55 @@ module Mediamtx
       set_always_available(session, enabled: true)
     end
 
-      # Slate alwaysAvailable: copertina sullo stesso path quando il telefono è offline.
+    # Garantisce path config + slate: se MediaMTX ha perso la config (restart → all_others),
+    # in pausa non resterebbe nessuno stream verso HLS/YouTube.
+    def ensure_path_with_slate!(session)
+      path = session.mediamtx_path_name
+      response = @conn.get("/v3/config/paths/get/#{CGI.escape(path)}")
+      missing = response.status == 404 ||
+        (response.body.is_a?(Hash) && response.body["error"].present?)
+
+      if missing
+        forget_always_available(path)
+        begin
+          create_path(session)
+        rescue Error
+          # Path creato in parallelo o già presente: forza solo la slate.
+          forget_always_available(path)
+          set_always_available(session, enabled: true)
+        end
+        return true
+      end
+
+      conf = response.body.is_a?(Hash) ? response.body : {}
+      desired = slate_file_path(session)
+      if conf["alwaysAvailable"] == true && conf["alwaysAvailableFile"].to_s == desired.to_s
+        remember_always_available(path, enabled: true)
+        return true
+      end
+
+      forget_always_available(path)
+      set_always_available(session, enabled: true)
+    end
+
+    # Spegnere record solo se attivo: ogni PATCH path ricarica MediaMTX e distrugge i muxer HLS.
+    def disable_recording_if_active!(session)
+      path = session.mediamtx_path_name
+      response = @conn.get("/v3/config/paths/get/#{CGI.escape(path)}")
+      return true unless response.success?
+      return true unless response.body.is_a?(Hash) && response.body["record"] == true
+
+      set_path_recording(session, enabled: false)
+    end
+
+    # Slate alwaysAvailable: copertina sullo stesso path quando il telefono è offline.
     # Resta accesa anche con publisher in onda (MediaMTX usa il publisher se presente).
     def set_always_available(session, enabled:)
       path = session.mediamtx_path_name
       return true if always_available_remembered?(path, enabled: enabled)
 
       body = if enabled
-               { alwaysAvailable: true, alwaysAvailableFile: slate_file_path }
+               { alwaysAvailable: true, alwaysAvailableFile: slate_file_path(session) }
              else
                { alwaysAvailable: false }
              end
@@ -173,7 +214,13 @@ module Mediamtx
       SCRIPT
     end
 
-    def slate_file_path
+    def slate_file_path(session)
+      return default_slate_file_path if session.blank?
+
+      Streams::SlateDistributor.slate_path_for_session(session)
+    end
+
+    def default_slate_file_path
       ENV.fetch("MEDIAMTX_SLATE_FILE", "/slates/offline.mp4")
     end
 

backend/app/services/mediamtx/publisher_sync.rb

@@ -79,9 +79,8 @@ module Mediamtx
     end
 
     def restore_slate_path!(session)
-      return if session.platform == "matchlivetv"
+      # Anche su matchlivetv: dopo restart MediaMTX la path può cadere su all_others senza slate.
-
+      Client.for_session(session).ensure_path_with_slate!(session)
-      Client.for_session(session).set_always_available(session, enabled: true)
     rescue Client::Error => e
       Rails.logger.warn("[PublisherSync] enable slate session=#{session.id}: #{e.message}")
     end
@@ -146,6 +145,14 @@ module Mediamtx
       nil
     end
 
+    def self.remember_recording_off!(session_id)
+      redis = Redis.new(url: ENV.fetch("REDIS_URL", "redis://localhost:6379/0"))
+      redis.set("mediamtx:recording:#{session_id}", "0", ex: 48.hours.to_i)
+      redis.set(format("mediamtx:recording:patched_at:%s", session_id), Time.current.to_i, ex: 48.hours.to_i)
+    rescue Redis::BaseError
+      nil
+    end
+
     def recording_state_key(session_id)
       "mediamtx:recording:#{session_id}"
     end

backend/app/services/sessions/create.rb

@@ -37,6 +37,8 @@ module Sessions
         session.stream_node = Streams::NodeRegistry.allocate!
         session.save!
         Scoring::Engine.ensure_score_for(session)
+        Streams::CoverSlateEnsurer.ensure_for!(@match)
+        Streams::SlateDistributor.ensure_for!(session)
         Mediamtx::Client.for_session(session).create_path(session)
         log_event(
           session,

backend/app/services/sessions/pause.rb

@@ -7,11 +7,13 @@ module Sessions
     def call
       cancel_timeout_job
       @session.pause! if @session.may_pause?
-      Mediamtx::PublisherSync.forget_recording_state!(@session.id)
       begin
         mtx = Mediamtx::Client.for_session(@session)
-        mtx.set_path_recording(@session, enabled: false)
+        # Ricrea/riallinea slate prima di spegnere l'RTMP del telefono.
-        mtx.set_always_available(@session, enabled: true)
+        mtx.ensure_path_with_slate!(@session)
+        # PATCH recording solo se era attivo (evita kill muxer HLS a ogni pausa).
+        mtx.disable_recording_if_active!(@session)
+        Mediamtx::PublisherSync.remember_recording_off!(@session.id)
       rescue Mediamtx::Client::Error => e
         Rails.logger.warn("[Sessions::Pause] MediaMTX: #{e.message}")
       end

backend/app/services/streams/cover_resolver.rb

@@ -0,0 +1,77 @@
+module Streams
+  # Catena effective cover: partita → squadra → società → default Match Live TV.
+  class CoverResolver
+    Result = Struct.new(:record, :source, :cover_url, :slate_local_path, keyword_init: true)
+
+    DEFAULT_COVER_URL = "/images/copertina-canale.png".freeze
+
+    def initialize(match)
+      @match = match
+      @team = match.team
+      @club = @team.club
+      @entitlements = @team.entitlements
+    end
+
+    def effective_cover_url
+      resolve&.cover_url || default_cover_url
+    end
+
+    def cover_source
+      resolve&.source || "default"
+    end
+
+    def resolve
+      return nil unless @entitlements.can_use_custom_cover?
+
+      candidates.each do |record, source|
+        next unless record.cover_image.attached?
+        next unless record.cover_slate.attached?
+
+        path = CoverSlatePaths.local_path_for(record)
+        next if path.blank?
+
+        return Result.new(
+          record: record,
+          source: source,
+          cover_url: blob_path(record.cover_image),
+          slate_local_path: path
+        )
+      end
+
+      nil
+    end
+
+    # Restituisce il record con cover_image nella catena anche se la slate non è ancora su disco.
+    # Usato da CoverSlateEnsurer per sapere cosa generare al go-live.
+    def pending_cover_record
+      return nil unless @entitlements.can_use_custom_cover?
+
+      candidates.each do |record, _source|
+        return record if record.cover_image.attached?
+      end
+      nil
+    end
+
+    def default_cover_url
+      DEFAULT_COVER_URL
+    end
+
+    def default_slate_path
+      ENV.fetch("MEDIAMTX_SLATE_FILE", "/slates/offline.mp4")
+    end
+
+    private
+
+    def candidates
+      [
+        [@match, "match"],
+        [@team, "team"],
+        [@club, "club"]
+      ]
+    end
+
+    def blob_path(attachment)
+      Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
+    end
+  end
+end

backend/app/services/streams/cover_slate_ensurer.rb

@@ -0,0 +1,39 @@
+module Streams
+  # Garantisce che la slate MP4 esista per il record effettivo della partita (sync al go-live).
+  class CoverSlateEnsurer
+    def self.ensure_for!(match)
+      new(match).ensure!
+    end
+
+    def initialize(match)
+      @match = match
+      @resolver = CoverResolver.new(match)
+    end
+
+    def ensure!
+      record = find_pending_cover_record
+      return unless record
+      return if slate_ready?(record)
+
+      GenerateCoverSlate.call(record)
+    rescue GenerateCoverSlate::Error => e
+      Rails.logger.warn("[CoverSlateEnsurer] match=#{@match.id} #{e.message}")
+      nil
+    end
+
+    private
+
+    # Cerca il record con cover_image nella catena di ereditarietà,
+    # anche se la slate non è ancora pronta (a differenza di resolve che richiede la slate su disco).
+    def find_pending_cover_record
+      @resolver.pending_cover_record
+    end
+
+    def slate_ready?(record)
+      return false unless record.cover_slate.attached?
+
+      path = CoverSlatePaths.local_path_for(record)
+      path.present? && File.exist?(path)
+    end
+  end
+end

backend/app/services/streams/cover_slate_paths.rb

@@ -0,0 +1,35 @@
+module Streams
+  class CoverSlatePaths
+    def self.slates_custom_root
+      ENV.fetch("MEDIAMTX_SLATES_CUSTOM_DIR", "/slates/custom")
+    end
+
+    # ActiveStorage checksum is base64 e può contenere "/", "+", "=" — non usabile come path.
+    def self.safe_digest(checksum)
+      checksum.to_s.tr("+/", "-_").delete("=")
+    end
+
+    def self.filename_for(record)
+      return nil unless record.cover_slate.attached?
+
+      digest = safe_digest(record.cover_slate.blob.checksum)
+      prefix = record.class.name.underscore
+      "#{prefix}-#{record.id}-#{digest}.mp4"
+    end
+
+    def self.expected_path(record)
+      name = filename_for(record)
+      return nil if name.blank?
+
+      File.join(slates_custom_root, name)
+    end
+
+    def self.local_path_for(record)
+      path = expected_path(record)
+      return nil if path.blank?
+      return path if File.exist?(path)
+
+      nil
+    end
+  end
+end

backend/app/services/streams/generate_cover_slate.rb

@@ -0,0 +1,121 @@
+require "open3"
+
+module Streams
+  # Converte cover_image in MP4 slate (H.264 720p + AAC mono), allineato a infra/scripts/generate_slate.sh.
+  class GenerateCoverSlate
+    class Error < StandardError; end
+
+    SLATE_DURATION_SECS = 30
+    VIDEO_FILTER = "scale=1280:720:force_original_aspect_ratio=decrease,pad=1280:720:(ow-iw)/2:(oh-ih)/2:color=0x0a0a0e".freeze
+
+    def self.call(record)
+      new(record).call
+    end
+
+    def initialize(record)
+      @record = record
+    end
+
+    def call
+      return @record unless @record.cover_image.attached?
+
+      @image_temp = download_cover_image
+      @mp4_temp = encode_slate(@image_temp)
+      attach_slate(@mp4_temp)
+      write_to_slates_dir(@mp4_temp)
+      @record
+    rescue Error
+      raise
+    rescue StandardError => e
+      raise Error, e.message
+    ensure
+      cleanup_tempfiles
+    end
+
+    private
+
+    def download_cover_image
+      ext = extension_for(@record.cover_image.content_type)
+      path = temp_path("cover-in", ext)
+      @record.cover_image.blob.open(tmpdir: Dir.tmpdir) do |file|
+        FileUtils.cp(file.path, path)
+      end
+      path
+    end
+
+    def encode_slate(image_path)
+      out = temp_path("cover-slate", ".mp4")
+      cmd = ffmpeg_args(image_path, out)
+      stdout, stderr, status = Open3.capture3(*cmd)
+      unless status.success? && File.exist?(out) && File.size(out).positive?
+        detail = stderr.to_s.strip.presence || stdout.to_s.strip
+        raise Error, "ffmpeg slate failed: #{detail}"
+      end
+
+      out
+    end
+
+    def ffmpeg_args(input, output)
+      [
+        "ffmpeg", "-nostdin", "-hide_banner", "-loglevel", "error",
+        "-loop", "1", "-framerate", "30", "-i", input,
+        "-f", "lavfi", "-i", "anullsrc=r=48000:cl=mono",
+        "-filter:v", VIDEO_FILTER,
+        "-map", "0:v", "-map", "1:a",
+        "-t", SLATE_DURATION_SECS.to_s,
+        "-c:v", "libx264", "-pix_fmt", "yuv420p", "-profile:v", "baseline", "-level", "3.1",
+        "-x264-params", "keyint=30:min-keyint=30:scenecut=0:bframes=0",
+        "-g", "30", "-keyint_min", "30", "-force_key_frames", "expr:gte(t,n_forced*1)",
+        "-preset", "fast",
+        "-c:a", "aac", "-b:a", "128k", "-ac", "1", "-shortest", "-y", output
+      ]
+    end
+
+    def attach_slate(mp4_path)
+      @record.cover_slate.purge if @record.cover_slate.attached?
+      File.open(mp4_path, "rb") do |io|
+        @record.cover_slate.attach(
+          io: io,
+          filename: slate_filename,
+          content_type: "video/mp4"
+        )
+      end
+      @record.reload
+    end
+
+    def write_to_slates_dir(mp4_path)
+      dest = CoverSlatePaths.expected_path(@record)
+      return unless dest
+
+      FileUtils.mkdir_p(File.dirname(dest))
+      FileUtils.cp(mp4_path, dest)
+    rescue Errno::EACCES, Errno::EROFS => e
+      Rails.logger.info("[GenerateCoverSlate] skip disk copy #{dest}: #{e.class}")
+    end
+
+    def slate_filename
+      "#{@record.class.name.underscore}-#{@record.id}.mp4"
+    end
+
+    def extension_for(content_type)
+      case content_type
+      when "image/png" then ".png"
+      when "image/webp" then ".webp"
+      else ".jpg"
+      end
+    end
+
+    def temp_path(prefix, ext)
+      path = File.join(Dir.tmpdir, "#{prefix}-#{@record.class.name}-#{@record.id}-#{SecureRandom.hex(4)}#{ext}")
+      @tempfiles ||= []
+      @tempfiles << path
+      path
+    end
+
+    def cleanup_tempfiles
+      Array(@tempfiles).each do |path|
+        FileUtils.rm_f(path)
+      end
+    end
+  end
+end

backend/app/services/streams/slate_distributor.rb

@@ -0,0 +1,105 @@
+module Streams
+  # Assicura che la slate MP4 custom sia sul nodo assegnato (home/lab locale, CPX via agent).
+  class SlateDistributor
+    class Error < StandardError; end
+
+    def self.slate_path_for_session(session)
+      new(session).mediamtx_slate_path
+    end
+
+    def self.ensure_for!(session)
+      new(session).ensure!
+    end
+
+    def initialize(session)
+      @session = session
+      @match = session.match
+      @node = session.stream_node
+      @resolver = CoverResolver.new(@match)
+    end
+
+    def mediamtx_slate_path
+      ensure! unless defined?(@mediamtx_path)
+      @mediamtx_path
+    end
+
+    def ensure!
+      result = @resolver.resolve
+      unless result
+        @mediamtx_path = default_slate_path
+        return @mediamtx_path
+      end
+
+      host_path = result.slate_local_path
+      filename = CoverSlatePaths.filename_for(result.record)
+      raise Error, "slate filename missing" if filename.blank?
+
+      # Path completo (non File.basename): il checksum AS può contenere "/" e spezzerebbe il path.
+      mediamtx_path = CoverSlatePaths.expected_path(result.record)
+
+      if cloud_node?
+        push_to_agent!(filename, result.record, host_path)
+      else
+        verify_local_slate!(host_path)
+      end
+
+      @mediamtx_path = mediamtx_path
+    rescue StandardError => e
+      # Agent cloud down / timeout / disk missing: non bloccare il go-live, usa slate default.
+      Rails.logger.warn("[SlateDistributor] session=#{@session.id} #{e.class}: #{e.message}")
+      @mediamtx_path = default_slate_path
+    end
+
+    private
+
+    def cloud_node?
+      @node&.role == "cloud" && agent_url.present?
+    end
+
+    def agent_url
+      ENV["STREAM_NODE_RELAY_AGENT_URL"].presence || @node&.relay_agent_url
+    end
+
+    def agent_secret
+      ENV["STREAM_NODE_AGENT_SECRET"].presence || "mediamtx_webhook_dev_secret"
+    end
+
+    def push_to_agent!(filename, record, host_path)
+      bytes = read_slate_bytes(record, host_path)
+      raise Error, "slate bytes missing for #{filename}" if bytes.blank?
+
+      uri = URI.parse("#{agent_url.chomp('/')}/slates/#{CGI.escape(filename)}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = 5
+      http.read_timeout = 120
+      req = Net::HTTP::Put.new(uri)
+      req["Authorization"] = "Bearer #{agent_secret}" if agent_secret.present?
+      req["Content-Type"] = "video/mp4"
+      req.body = bytes
+      res = http.request(req)
+      return if res.is_a?(Net::HTTPSuccess)
+
+      raise Error, "agent PUT /slates/#{filename} HTTP #{res.code} #{res.body.to_s.truncate(200)}"
+    end
+
+    def read_slate_bytes(record, host_path)
+      return File.binread(host_path) if host_path.present? && File.exist?(host_path)
+
+      return unless record.cover_slate.attached?
+
+      record.cover_slate.blob.open(tmpdir: Dir.tmpdir) do |file|
+        return File.binread(file.path)
+      end
+    end
+
+    def verify_local_slate!(host_path)
+      return if host_path.present? && File.exist?(host_path)
+
+      raise Error, "slate missing on disk: #{host_path}"
+    end
+
+    def default_slate_path
+      ENV.fetch("MEDIAMTX_SLATE_FILE", "/slates/offline.mp4")
+    end
+  end
+end

backend/app/services/streams/youtube_relay.rb

@@ -35,7 +35,26 @@ module Streams
         assigned_node_slug(session) == local_node_slug
       end
 
+      # Home può avviare ffmpeg sull'agent del CPX (niente worker Docker per nodo).
+      def can_process?(session)
+        return false unless worker?
+        return true if node_matches?(session)
+
+        cloud_home_dispatch?(session)
+      end
+
+      def cloud_home_dispatch?(session)
+        local_node_slug == NodeRegistry::HOME_SLUG &&
+          session.stream_node&.role == "cloud" &&
+          session.stream_node.relay_agent_url.present?
+      end
+
       def queue_for(session)
+        node = session.stream_node
+        if node&.role == "cloud" && node.relay_agent_url.present?
+          return "#{QUEUE_PREFIX}_cloud"
+        end
+
         "#{QUEUE_PREFIX}_#{assigned_node_slug(session)}"
       end
 
@@ -50,14 +69,14 @@ module Streams
       end
 
       def start(session)
-        return enqueue_ensure!(session) unless worker? && node_matches?(session)
+        return enqueue_ensure!(session) unless can_process?(session)
 
         start_on_worker!(session)
       end
 
       # Non cancella owner/pid qui: solo il worker owner deve killare ffmpeg.
       def stop(session)
-        if worker? && owner_is_local?(session.id) && node_matches?(session)
+        if worker? && owner_is_local?(session.id) && can_process?(session)
           stop_on_worker!(session)
         else
           enqueue_stop!(session)
@@ -83,7 +102,7 @@ module Streams
         return if session.terminal?
         return if session.stream_key.blank?
 
-        if worker? && node_matches?(session)
+        if can_process?(session)
           ensure_on_worker!(session)
         else
           enqueue_ensure!(session)
@@ -92,7 +111,7 @@ module Streams
 
       def ensure_on_worker!(session)
         return :not_worker unless worker?
-        unless node_matches?(session)
+        unless can_process?(session)
           enqueue_ensure!(session, wait: 2.seconds)
           Rails.logger.info(
             "[YoutubeRelay] wrong_node local=#{local_node_slug} assigned=#{assigned_node_slug(session)} session=#{session.id}"
@@ -115,7 +134,7 @@ module Streams
           return :already_running
         end
 
-        if at_capacity?
+        if at_capacity_for?(session)
           enqueue_ensure!(session, wait: 5.seconds)
           Rails.logger.info("[YoutubeRelay] at capacity worker=#{worker_id} node=#{local_node_slug} session=#{session.id} requeue")
           return :at_capacity
@@ -129,6 +148,7 @@ module Streams
         :started
       rescue Error => e
         Rails.logger.warn("[YoutubeRelay] ensure_on_worker session=#{session.id}: #{e.message}")
+        enqueue_ensure!(session, wait: 5.seconds) unless session.terminal?
         :error
       end
 
@@ -161,6 +181,13 @@ module Streams
         local_owned_count >= max_concurrent
       end
 
+      # I relay sull'agent CPX non consumano ffmpeg locale: non applicare il cap del worker home.
+      def at_capacity_for?(session)
+        return false if cloud_home_dispatch?(session)
+
+        at_capacity?
+      end
+
       def owner_is_local?(session_id)
         owner = redis.get(format(OWNER_KEY, session_id))
         owner.blank? || owner == worker_id
@@ -188,7 +215,7 @@ module Streams
         intake_source = mediamtx_intake_source(session)
         output = "rtmps://a.rtmps.youtube.com/live2/#{session.stream_key}"
 
-        pid = if relay_agent_enabled?
+        pid = if agent_dispatch?(session)
                 start_via_agent!(session)
               else
                 spawn_ffmpeg!(youtube_ffmpeg_args(intake_source, output), log_path)
@@ -197,7 +224,7 @@ module Streams
         claim_ownership!(session.id)
         Rails.logger.info(
           "[YoutubeRelay] started pid=#{pid} session=#{session.id} intake=#{intake_source.join(':')} " \
-          "worker=#{worker_id} agent=#{relay_agent_url || '-'}"
+          "worker=#{worker_id} agent=#{agent_base_url(session) || '-'}"
         )
         schedule_youtube_activate(session)
         pid
@@ -205,16 +232,18 @@ module Streams
         raise Error, "ffmpeg non disponibile: #{e.message}"
       end
 
-      def relay_agent_url
+      def agent_base_url(session)
-        ENV["STREAM_NODE_RELAY_AGENT_URL"].presence
+        return if session.blank?
+
+        ENV["STREAM_NODE_RELAY_AGENT_URL"].presence || session.stream_node&.relay_agent_url
       end
 
-      def relay_agent_enabled?
+      def agent_dispatch?(session)
-        relay_agent_url.present?
+        agent_base_url(session).present?
       end
 
       def relay_agent_secret
-        ENV["STREAM_NODE_AGENT_SECRET"].presence || ENV["MEDIAMTX_WEBHOOK_SECRET"].presence || ""
+        ENV["STREAM_NODE_AGENT_SECRET"].presence || "mediamtx_webhook_dev_secret"
       end
 
       def spawn_ffmpeg!(args, log_path)
@@ -229,19 +258,23 @@ module Streams
           "path" => session.mediamtx_path_name,
           "rtmps" => "rtmps://a.rtmps.youtube.com/live2/#{session.stream_key}"
         }
-        res = agent_request(Net::HTTP::Post, "/relays", payload)
+        res = agent_request(Net::HTTP::Post, "/relays", payload, session: session)
         pid = res["pid"].to_i
         raise Error, "relay agent spawn failed: #{res.inspect}" if pid <= 0
 
         File.write(
           log_file(session),
-          "agent=#{relay_agent_url} pid=#{pid} path=#{session.mediamtx_path_name}\n"
+          "agent=#{agent_base_url(session)} pid=#{pid} path=#{session.mediamtx_path_name}\n"
         )
         pid
       end
 
-      def agent_request(http_class, path, payload = nil)
+      def agent_request(http_class, path, payload = nil, session: nil, session_id: nil)
-        uri = URI.parse("#{relay_agent_url.chomp('/')}#{path}")
+        session ||= StreamSession.find_by(id: session_id) if session_id.present?
+        base = agent_base_url(session)
+        raise Error, "relay agent URL mancante" if base.blank?
+
+        uri = URI.parse("#{base.chomp('/')}#{path}")
         http = Net::HTTP.new(uri.host, uri.port)
         http.open_timeout = 5
         http.read_timeout = 10
@@ -304,7 +337,7 @@ module Streams
 
       # Sul nodo assegnato ffmpeg legge MediaMTX in loopback (o hostname Docker locale).
       def intake_bases(session)
-        if relay_agent_enabled? && node_matches?(session)
+        if agent_dispatch?(session) && (node_matches?(session) || cloud_home_dispatch?(session))
           return ["rtmp://127.0.0.1:1935", "http://127.0.0.1:8888"]
         end
 
@@ -376,7 +409,8 @@ module Streams
       end
 
       def process_alive?(pid, session_id: nil)
-        return agent_session_running?(session_id) if relay_agent_enabled? && session_id.present?
+        session = session_id.present? ? StreamSession.find_by(id: session_id) : nil
+        return agent_session_running?(session) if session && agent_dispatch?(session)
 
         stat = File.read("/proc/#{pid.to_i}/stat")
         return false if stat.split[2] == "Z"
@@ -387,16 +421,17 @@ module Streams
         false
       end
 
-      def agent_session_running?(session_id)
+      def agent_session_running?(session)
-        res = agent_request(Net::HTTP::Get, "/relays/#{session_id}")
+        res = agent_request(Net::HTTP::Get, "/relays/#{session.id}", session: session)
         res["running"] == true
       rescue Error
         false
       end
 
       def terminate_pid(pid, session_id: nil)
-        if relay_agent_enabled? && session_id.present?
+        session = session_id.present? ? StreamSession.find_by(id: session_id) : nil
-          agent_request(Net::HTTP::Delete, "/relays/#{session_id}")
+        if session && agent_dispatch?(session)
+          agent_request(Net::HTTP::Delete, "/relays/#{session_id}", session: session)
           return
         end
 
@@ -405,7 +440,7 @@ module Streams
       rescue Errno::ESRCH
         nil
       else
-        return if relay_agent_enabled?
+        return if session && agent_dispatch?(session)
 
         begin
           Process.kill("KILL", -pid.to_i)

backend/app/services/teams/entitlements.rb

@@ -35,6 +35,20 @@ module Teams
       active? && plan.phone_download_enabled?
     end
 
+    def can_use_custom_cover?
+      premium_full? && plan.custom_cover_enabled?
+    end
+
+    def assert_can_upload_cover!
+      unless can_use_custom_cover?
+        raise EntitlementError.new(
+          "La copertina sponsor personalizzata richiede Premium Full",
+          code: "premium_full_required",
+          billing_url: billing_url
+        )
+      end
+    end
+
     def max_staff_transmission
       plan.max_staff_transmission
     end
@@ -225,7 +239,8 @@ module Teams
         recording_retention_days: recording_retention_days,
         phone_download_enabled: phone_download_enabled?,
         youtube_enabled: youtube_enabled?,
-        youtube_mode: plan.youtube_mode
+        youtube_mode: plan.youtube_mode,
+        custom_cover_enabled: can_use_custom_cover?
       }
     end
 

backend/app/services/teams/staff_assignment.rb

@@ -23,5 +23,12 @@ module Teams
       ut.update!(staff_kind: "transmission")
       ut
     end
+
+    def self.designate_club_owner!(team:, user:)
+      membership = user.user_teams.find_or_initialize_by(team: team)
+      membership.role = "member" if membership.new_record?
+      membership.save!
+      call(team: team, user: user, membership: membership)
+    end
   end
 end

backend/app/views/admin/billing/index.html.erb

@@ -18,6 +18,56 @@
         club: @filter_club,
         subscription: @filter_club.subscription,
         return_to: admin_billing_path(club_id: @filter_club.id) %>
+  <%= render "admin/clubs/quote_form",
+        club: @filter_club,
+        quote: @filter_club.active_billing_quote,
+        return_to: admin_billing_path(club_id: @filter_club.id) %>
+<% end %>
+
+<h2 style="margin-top:8px;font-size:1.15rem"><%= t("admin.billing.index.transfers_title") %></h2>
+<p style="color:#666;margin-bottom:16px"><%= t("admin.billing.index.transfers_description") %></p>
+
+<% if @pending_transfers.any? %>
+  <div class="billing-pending-list" style="margin-bottom:32px">
+    <% @pending_transfers.each do |order| %>
+      <article id="transfer-<%= order.id %>" class="billing-pending-card">
+        <header class="billing-pending-card__head">
+          <div>
+            <strong><%= order.club.name %></strong>
+            · <%= order.plan.name %>
+            · <%= t("admin.billing.index.kind_#{order.quoted? ? 'quote' : 'list'}") %>
+            · <strong><%= order.formatted_amount %></strong>
+            · <%= order.created_at.to_date.strftime("%d/%m/%Y") %>
+          </div>
+        </header>
+        <div class="billing-pending-card__body">
+          <p style="margin:0 0 12px">
+            <%= t("admin.billing.index.transfers_table.holder") %>:
+            <strong><%= MatchLiveTv.bank_transfer_account_holder %></strong><br>
+            <%= t("admin.billing.index.transfers_table.iban") %>:
+            <strong><%= MatchLiveTv.bank_transfer_iban %></strong><br>
+            <%= t("admin.billing.index.transfers_table.causal") %>:
+            <strong><%= order.payment_causal %></strong>
+          </p>
+          <%= form_with url: admin_billing_transfer_confirm_path(order),
+                method: :post, multipart: true, local: true, class: "billing-upload-form" do %>
+            <label class="billing-upload-form__label">
+              <%= t("admin.billing.index.pdf_optional") %>
+              <%= file_field_tag :pdf, accept: "application/pdf" %>
+            </label>
+            <%= submit_tag t("admin.billing.index.confirm_button"), class: "admin-btn admin-btn--primary" %>
+          <% end %>
+          <%= button_to t("admin.billing.index.cancel_button"),
+                admin_billing_transfer_cancel_path(order),
+                method: :post,
+                class: "admin-btn admin-btn--secondary",
+                form: { style: "margin-top:8px", data: { turbo_confirm: t("admin.billing.index.cancel_confirm") } } %>
+        </div>
+      </article>
+    <% end %>
+  </div>
+<% else %>
+  <p class="muted" style="margin-bottom:28px"><%= t("admin.billing.index.transfers_none") %></p>
 <% end %>
 
 <% if @pending_payments.any? %>

backend/app/views/admin/clubs/_quote_form.html.erb

@@ -0,0 +1,71 @@
+<%# locals: (club:, quote:, return_to: nil) %>
+<section class="admin-comped-card" style="margin-bottom:24px;padding:16px;border:1px solid #2e5a3c;border-radius:8px;background:#142018">
+  <h2 style="margin:0 0 8px;font-size:1.1rem"><%= t("admin.quote.title") %></h2>
+  <p style="color:#bbb;font-size:0.9rem;margin:0 0 14px">
+    <%= t("admin.quote.description") %>
+  </p>
+
+  <% if quote %>
+    <p style="margin:0 0 12px">
+      <%= raw t("admin.quote.active_html",
+            plan: quote.plan.name,
+            interval: t("admin.quote.interval_#{quote.billing_interval}"),
+            amount: quote.formatted_amount) %>
+      <% if quote.note.present? %>
+        <br><span style="color:#888;font-size:0.85rem"><%= t("admin.quote.note_label") %> <%= quote.note %></span>
+      <% end %>
+    </p>
+  <% else %>
+    <p style="margin:0 0 12px;color:#888"><%= t("admin.quote.none") %></p>
+  <% end %>
+
+  <%= form_with url: set_quote_admin_club_path(club), method: :post, local: true do %>
+    <%= hidden_field_tag :return_to, return_to if return_to.present? %>
+    <div style="display:flex;flex-wrap:wrap;gap:12px;align-items:flex-end">
+      <label style="display:flex;flex-direction:column;gap:4px;font-size:0.85rem">
+        <%= t("admin.quote.plan_label") %>
+        <%= select_tag :plan_slug,
+              options_for_select(
+                [["Premium Light", "premium_light"], ["Premium Full", "premium_full"]],
+                quote&.plan_slug
+              ),
+              required: true,
+              class: "admin-input" %>
+      </label>
+      <label style="display:flex;flex-direction:column;gap:4px;font-size:0.85rem">
+        <%= t("admin.quote.interval_label") %>
+        <%= select_tag :interval,
+              options_for_select(
+                [[t("admin.quote.interval_yearly"), "yearly"], [t("admin.quote.interval_monthly"), "monthly"]],
+                quote&.billing_interval || "yearly"
+              ),
+              required: true,
+              class: "admin-input" %>
+      </label>
+      <label style="display:flex;flex-direction:column;gap:4px;font-size:0.85rem">
+        <%= t("admin.quote.amount_label") %>
+        <%= text_field_tag :amount_euros,
+              quote ? format("%.2f", quote.amount_cents / 100.0) : nil,
+              placeholder: t("admin.quote.amount_placeholder"),
+              required: true,
+              class: "admin-input",
+              inputmode: "decimal" %>
+      </label>
+      <label style="display:flex;flex-direction:column;gap:4px;font-size:0.85rem;flex:1;min-width:200px">
+        <%= t("admin.quote.commercial_note_label") %>
+        <%= text_field_tag :note, quote&.note, class: "admin-input", style: "width:100%" %>
+      </label>
+      <%= submit_tag t("admin.quote.save_button"), class: "admin-btn admin-btn--primary" %>
+    </div>
+  <% end %>
+
+  <% if quote %>
+    <div style="margin-top:12px">
+      <%= button_to t("admin.quote.revoke_button"),
+            revoke_quote_admin_club_path(club, return_to: return_to),
+            method: :delete,
+            class: "admin-btn admin-btn--secondary",
+            form: { data: { turbo_confirm: t("admin.quote.revoke_confirm", club: club.name) } } %>
+    </div>
+  <% end %>
+</section>

backend/app/views/admin/clubs/index.html.erb

@@ -11,6 +11,7 @@
       <th><%= t("admin.clubs.index.table.teams") %></th>
       <th><%= t("admin.clubs.index.table.comped") %></th>
       <th><%= t("admin.clubs.index.table.stripe") %></th>
+      <th><%= t("admin.clubs.index.table.quote") %></th>
       <th></th>
     </tr>
   </thead>
@@ -30,6 +31,14 @@
           <% end %>
         </td>
         <td><%= sub&.stripe_subscription_id.present? ? t("admin.common.yes") : t("admin.common.dash") %></td>
+        <td>
+          <% quote = club.billing_quote %>
+          <% if quote %>
+            <%= quote.plan.name %> · <%= quote.formatted_amount %>
+          <% else %>
+            <%= t("admin.common.dash") %>
+          <% end %>
+        </td>
         <td>
           <%= link_to t("admin.clubs.index.manage"), admin_club_path(club) %>
           · <%= link_to t("admin.clubs.index.invoices"), admin_billing_path(club_id: club.id) %>

backend/app/views/admin/clubs/show.html.erb

@@ -9,6 +9,7 @@
 </p>
 
 <%= render "admin/clubs/comped_form", club: @club, subscription: @subscription, return_to: admin_club_path(@club) %>
+<%= render "admin/clubs/quote_form", club: @club, quote: @quote, return_to: admin_club_path(@club) %>
 
 <% cred = @club.youtube_credential %>
 <p style="margin-top:16px">

backend/app/views/billing/bank_transfer_mailer/instructions.html.erb

@@ -0,0 +1,25 @@
+<p><%= t("mailers.bank_transfer.instructions.hello") %></p>
+
+<p><%= raw t("mailers.bank_transfer.instructions.intro_html",
+      club: @club.billing_legal_name.presence || @club.name,
+      plan: @order.plan.name,
+      price: @order.price_label) %></p>
+
+<p><%= t("mailers.bank_transfer.instructions.not_active_yet") %></p>
+
+<p>
+  <strong><%= t("mailers.bank_transfer.instructions.iban_label") %></strong> <%= @iban %><br>
+  <strong><%= t("mailers.bank_transfer.instructions.holder_label") %></strong> <%= @holder %><br>
+  <% if @bank_name.present? %>
+    <strong><%= t("mailers.bank_transfer.instructions.bank_label") %></strong> <%= @bank_name %><br>
+  <% end %>
+  <% if @bic.present? %>
+    <strong><%= t("mailers.bank_transfer.instructions.bic_label") %></strong> <%= @bic %><br>
+  <% end %>
+  <strong><%= t("mailers.bank_transfer.instructions.amount_label") %></strong> <%= @order.formatted_amount %><br>
+  <strong><%= t("mailers.bank_transfer.instructions.causal_label") %></strong> <%= @order.payment_causal %>
+</p>
+
+<p><%= raw t("mailers.bank_transfer.instructions.proof_html", email: @proof_email) %></p>
+
+<p><%= t("mailers.bank_transfer.thanks") %><br><%= t("mailers.bank_transfer.signoff") %></p>

backend/app/views/billing/bank_transfer_mailer/instructions.text.erb

@@ -0,0 +1,20 @@
+<%= t("mailers.bank_transfer.instructions.hello") %>
+
+<%= t("mailers.bank_transfer.instructions.intro_text",
+      club: @club.billing_legal_name.presence || @club.name,
+      plan: @order.plan.name,
+      price: @order.price_label) %>
+
+<%= t("mailers.bank_transfer.instructions.not_active_yet") %>
+
+<%= t("mailers.bank_transfer.instructions.iban_label") %> <%= @iban %>
+<%= t("mailers.bank_transfer.instructions.holder_label") %> <%= @holder %>
+<% if @bank_name.present? %><%= t("mailers.bank_transfer.instructions.bank_label") %> <%= @bank_name %>
+<% end %><% if @bic.present? %><%= t("mailers.bank_transfer.instructions.bic_label") %> <%= @bic %>
+<% end %><%= t("mailers.bank_transfer.instructions.amount_label") %> <%= @order.formatted_amount %>
+<%= t("mailers.bank_transfer.instructions.causal_label") %> <%= @order.payment_causal %>
+
+<%= t("mailers.bank_transfer.instructions.proof_text", email: @proof_email) %>
+
+<%= t("mailers.bank_transfer.thanks") %>
+<%= t("mailers.bank_transfer.signoff") %>

backend/app/views/billing/bank_transfer_mailer/plan_activated.html.erb

@@ -0,0 +1,10 @@
+<p><%= t("mailers.bank_transfer.plan_activated.hello") %></p>
+
+<p><%= raw t("mailers.bank_transfer.plan_activated.body_html",
+      plan: @order.plan.name,
+      club: @club.billing_legal_name.presence || @club.name,
+      until_date: @subscription&.current_period_end ? l(@subscription.current_period_end.to_date, format: :long) : t("mailers.bank_transfer.plan_activated.period_fallback")) %></p>
+
+<p><%= t("mailers.bank_transfer.plan_activated.invoice_later") %></p>
+
+<p><%= t("mailers.bank_transfer.thanks") %><br><%= t("mailers.bank_transfer.signoff") %></p>

backend/app/views/billing/bank_transfer_mailer/plan_activated.text.erb

@@ -0,0 +1,11 @@
+<%= t("mailers.bank_transfer.plan_activated.hello") %>
+
+<%= t("mailers.bank_transfer.plan_activated.body_text",
+      plan: @order.plan.name,
+      club: @club.billing_legal_name.presence || @club.name,
+      until_date: @subscription&.current_period_end ? l(@subscription.current_period_end.to_date, format: :long) : t("mailers.bank_transfer.plan_activated.period_fallback")) %>
+
+<%= t("mailers.bank_transfer.plan_activated.invoice_later") %>
+
+<%= t("mailers.bank_transfer.thanks") %>
+<%= t("mailers.bank_transfer.signoff") %>

backend/app/views/billing/invoice_mailer/plan_activated_with_invoice.html.erb

@@ -0,0 +1,12 @@
+<p><%= t("mailers.invoice_activated.hello") %></p>
+
+<p><%= raw t("mailers.invoice_activated.body_html",
+      plan: @invoice.club.subscription&.plan&.name || @invoice.billing_payment&.plan_slug.to_s.humanize,
+      club: @club.billing_legal_name.presence || @club.name,
+      until_date: @invoice.club.subscription&.current_period_end ? l(@invoice.club.subscription.current_period_end.to_date, format: :long) : t("mailers.invoice_activated.period_fallback"),
+      number: @invoice.display_number,
+      amount: @invoice.formatted_amount) %></p>
+
+<p><%= raw t("mailers.invoice.also_html") %></p>
+
+<p><%= t("mailers.invoice.thanks") %><br><%= t("mailers.invoice.signoff") %></p>

backend/app/views/billing/invoice_mailer/plan_activated_with_invoice.text.erb

@@ -0,0 +1,13 @@
+<%= t("mailers.invoice_activated.hello") %>
+
+<%= t("mailers.invoice_activated.body_text",
+      plan: @invoice.club.subscription&.plan&.name || @invoice.billing_payment&.plan_slug.to_s.humanize,
+      club: @club.billing_legal_name.presence || @club.name,
+      until_date: @invoice.club.subscription&.current_period_end ? l(@invoice.club.subscription.current_period_end.to_date, format: :long) : t("mailers.invoice_activated.period_fallback"),
+      number: @invoice.display_number,
+      amount: @invoice.formatted_amount) %>
+
+<%= t("mailers.invoice.also_text") %>
+
+<%= t("mailers.invoice.thanks") %>
+<%= t("mailers.invoice.signoff") %>

backend/app/views/layouts/admin.html.erb

@@ -13,7 +13,7 @@
     <script src="/admin-dashboard.js?v=1" defer></script>
   <% end %>
   <link rel="stylesheet" href="/confirm-forms.css?v=4">
-  <script src="/confirm-forms.js?v=6" defer></script>
+  <script src="/confirm-forms.js?v=7" defer></script>
 </head>
 <body class="<%= content_for?(:body_class) ? yield(:body_class) : 'admin-body' %>">
   <header class="admin-header">

backend/app/views/layouts/marketing.html.erb

@@ -23,7 +23,7 @@
     <script src="/roster-form.js?v=1" defer></script>
     <script src="/password-toggle.js?v=2" defer></script>
     <link rel="stylesheet" href="/confirm-forms.css?v=4">
-    <script src="/confirm-forms.js?v=6" defer></script>
+    <script src="/confirm-forms.js?v=7" defer></script>
     <script src="/cookie-consent.js?v=1" defer></script>
   </body>
 </html>

backend/app/views/layouts/marketing_live.html.erb

@@ -18,7 +18,7 @@
     </main>
     <%= render "shared/marketing_footer" %>
     <link rel="stylesheet" href="/confirm-forms.css?v=4">
-    <script src="/confirm-forms.js?v=6" defer></script>
+    <script src="/confirm-forms.js?v=7" defer></script>
     <script src="/cookie-consent.js?v=1" defer></script>
   </body>
 </html>

backend/app/views/public/clubs/billing.html.erb

@@ -17,11 +17,19 @@
       </p>
     </div>
   <% else %>
-    <%= render "shared/stripe_secure_payment" %>
+    <% if @quote %>
-    <% if MatchLiveTv.stripe_enabled? %>
+      <%= render "shared/quoted_price_banner", quote: @quote, subscription: @subscription %>
+    <% elsif MatchLiveTv.stripe_enabled? %>
+      <%= render "shared/stripe_secure_payment" %>
+    <% end %>
+    <%= render "shared/pending_bank_transfer", order: @pending_transfer %>
+    <% if MatchLiveTv.stripe_enabled? && @quote.blank? %>
       <%= render "shared/plan_change_info", subscription: @subscription %>
     <% end %>
     <%= render "shared/plan_cards", show_stripe_portal: false %>
+    <% if @subscription&.bank_transfer? %>
+      <p class="muted" style="margin-top:16px"><%= raw t("billing.bank_transfer.renewal_html") %></p>
+    <% end %>
     <%= render "shared/subscription_cancel", club: @club, subscription: @subscription %>
   <% end %>
 

backend/app/views/public/clubs/edit.html.erb

@@ -10,6 +10,9 @@
       <%= label_tag "club[sport]", t("club.sport_label") %>
       <%= select_tag "club[sport]", sport_catalog_options(@club.sport) %>
       <%= render "shared/branding_fields", record: @club, legend: t("club.branding_legend") %>
+      <%= render "shared/cover_fields",
+            record: @club,
+            can_upload: @entitlements&.can_use_custom_cover? %>
       <%= render "shared/billing_profile_fields", record: @club %>
       <%= submit_tag t("club.edit.save"), class: "btn btn-primary" %>
     <% end %>

backend/app/views/public/clubs/new.html.erb

@@ -24,15 +24,8 @@
         [t("club.new.plan_free"), "free"],
         [t("club.new.plan_light"), "premium_light"],
         [t("club.new.plan_full"), "premium_full"]
-      ], params[:plan] || "free"), id: "club_plan_select" %>
+      ], params[:plan] || "free") %>
-      <div id="club_plan_interval" style="margin-top:10px">
+      <p class="muted" style="margin:8px 0 16px"><%= t("club.new.plan_hint") %></p>
-        <%= label_tag :interval, t("club.new.interval_label") %>
-        <%= select_tag :interval, options_for_select([
-          [t("club.new.interval_yearly"), "yearly"],
-          [t("club.new.interval_monthly"), "monthly"]
-        ], params[:interval] || "yearly") %>
-      </div>
-      <%= render "shared/stripe_secure_payment", compact: true %>
       <%= submit_tag t("club.new.submit"), class: "btn btn-primary" %>
     <% end %>
   </div>

backend/app/views/public/live/show.html.erb

@@ -46,7 +46,7 @@
   </div>
 <% else %>
   <div class="live-player-wrap">
-    <video id="player" controls playsinline muted autoplay poster="/images/copertina-canale.png"></video>
+    <video id="player" controls playsinline muted autoplay poster="<%= @cover_poster_url %>"></video>
     <%= render "public/live/player_overlays", match: @match, session: @session %>
     <button type="button" id="play-hint" class="live-play-hint" hidden>
       <%= t("live.show.play_hint") %>
@@ -219,7 +219,8 @@
     }
 
     function onEnterPause() {
-      nudgePlayback();
+      // Camera → slate cambia risoluzione/codec: senza reload HLS.js resta spesso bloccato.
+      hardReloadPlayer();
     }
 
     function hardReloadPlayer() {

backend/app/views/public/regia/show.html.erb

@@ -165,4 +165,4 @@
   </div>
 </div>
 
-<script src="/regia.js?v=19"></script>
+<script src="/regia.js?v=20"></script>

backend/app/views/public/teams/_streaming_staff.html.erb

@@ -1,33 +1,33 @@
 <% team = local_assigns[:team] %>
+<% club = local_assigns[:club] %>
 <% can_manage = local_assigns[:can_manage] %>
-<% owner_membership = local_assigns[:owner_membership] %>
 <% staff_memberships = local_assigns[:staff_memberships] %>
 <% pending_invitations = local_assigns[:pending_invitations] %>
 <% recordings = local_assigns[:recordings] %>
 <% entitlements = local_assigns[:entitlements] %>
+<% club_owner = club.owner %>
+<% extra_staff = staff_memberships.reject { |ut| ut.user_id == club_owner&.id } %>
 
 <section class="team-streaming-staff" id="responsabili-trasmissione">
-  <% if can_manage %>
+  <% if club_owner %>
-    <% if owner_membership&.staff_kind.blank? %>
+    <div class="card team-streaming-staff__self">
-      <div class="card team-streaming-staff__self">
+      <h2><%= t("team.streaming_staff.principal_heading") %></h2>
-        <h2><%= t("team.streaming_staff.self_account_heading", email: current_user.email) %></h2>
+      <p>
-        <p class="muted">
+        <%= raw t("team.streaming_staff.principal_body_html", email: club_owner.email) %>
-          <%= raw t("team.streaming_staff.self_account_hint") %>
+      </p>
-        </p>
+      <p class="muted">
-        <div class="team-details-actions">
+        <%= raw t("team.streaming_staff.principal_score_hint_html") %>
-          <%= button_to t("team.streaming_staff.self_assign_submit"), public_team_assign_self_staff_path(team), method: :post, params: { staff_kind: "transmission" }, class: "btn btn-primary" %>
+      </p>
-        </div>
+    </div>
-      </div>
-    <% end %>
   <% end %>
 
-  <h2><%= t("team.streaming_staff.staff_heading") %></h2>
+  <% if extra_staff.any? %>
-  <div class="card">
+    <h2><%= t("team.streaming_staff.extra_staff_heading") %></h2>
-    <% if staff_memberships.any? %>
+    <div class="card">
       <table class="data">
         <thead><tr><th><%= t("team.streaming_staff.col_name") %></th><th><%= t("team.streaming_staff.col_email") %></th><th><%= t("team.streaming_staff.col_role") %></th><% if can_manage %><th></th><% end %></tr></thead>
         <tbody>
-          <% staff_memberships.each do |ut| %>
+          <% extra_staff.each do |ut| %>
             <tr>
               <td>
                 <%= ut.user.name %>
@@ -37,9 +37,7 @@
               <td><%= t("team.streaming_staff.role_transmission") %></td>
               <% if can_manage %>
                 <td>
-                  <% if ut.user_id == current_user.id && team.club.owned_by?(current_user) %>
+                  <% if ut.role == "member" %>
-                    <%= button_to t("team.streaming_staff.clear_self_staff"), public_team_clear_self_staff_path(team), method: :delete, class: "btn btn-secondary", style: "padding:4px 10px;font-size:0.8rem", form: { data: { turbo_confirm: t("team.streaming_staff.clear_self_staff_confirm"), confirm_kind: "delete" } } %>
-                  <% elsif ut.role == "member" %>
                     <%= button_to t("team.streaming_staff.revoke"), public_team_remove_member_path(team, ut.user), method: :delete, class: "btn btn-secondary", style: "padding:4px 10px;font-size:0.8rem", form: { data: { turbo_confirm: t("team.streaming_staff.revoke_confirm", name: ut.user.name), confirm_kind: "delete" } } %>
                   <% end %>
                 </td>
@@ -48,13 +46,8 @@
           <% end %>
         </tbody>
       </table>
-    <% else %>
+    </div>
-      <p class="muted">
+  <% end %>
-        <%= t("team.streaming_staff.no_staff") %>
-        <% if can_manage %><%= link_to t("team.streaming_staff.invite_someone"), "#invita-trasmissione" %>.<% end %>
-      </p>
-    <% end %>
-  </div>
 
   <% if can_manage %>
     <div class="card team-invite-form" id="invita-trasmissione">

backend/app/views/public/teams/edit.html.erb

@@ -25,6 +25,10 @@
       </div>
 
       <%= render "shared/branding_fields", record: @team, show_inherit_hint: true, legend: t("team.edit.branding_legend") %>
+      <%= render "shared/cover_fields",
+            record: @team,
+            show_inherit_hint: true,
+            can_upload: @entitlements&.can_use_custom_cover? %>
 
       <%= label_tag "team[slug]", t("team.edit.slug_label") %>
       <p class="branding-hint" style="margin-top:0">

backend/app/views/shared/_club_subscription_status.html.erb

@@ -33,4 +33,8 @@
       <% end %>
     <% end %>
   </p>
+<% elsif subscription&.bank_transfer? %>
+  <p style="color:#888;font-size:0.9rem;margin-top:0">
+    <%= raw t("billing.subscription_status.bank_transfer_until_html", date: l_local(subscription.current_period_end.to_date)) %>
+  </p>
 <% end %>

backend/app/views/shared/_cover_fields.html.erb

@@ -0,0 +1,55 @@
+<% record = local_assigns[:record] %>
+<% show_inherit_hint = local_assigns[:show_inherit_hint] %>
+<% can_upload = local_assigns.fetch(:can_upload, false) %>
+<% cover_src = record.effective_cover_url.presence || Streams::CoverResolver::DEFAULT_COVER_URL %>
+
+<fieldset class="branding-fields cover-fields">
+  <legend><%= t("club.branding.cover_legend") %></legend>
+
+  <% if show_inherit_hint %>
+    <p class="branding-hint"><%= t("club.branding.cover_inherit_hint") %></p>
+  <% end %>
+
+  <p class="branding-hint"><%= t("club.branding.cover_hint") %></p>
+
+  <div class="branding-logo-block cover-preview-block">
+    <%= label_tag "branding[cover_image]", t("club.branding.cover_file_label") %>
+    <div class="branding-logo-preview branding-cover-preview" data-branding-cover-preview>
+      <%= image_tag cover_src,
+            alt: t("club.branding.cover_preview_alt"),
+            class: "branding-cover-preview__img",
+            data: { branding_cover_img: true } %>
+    </div>
+
+    <% if can_upload %>
+      <%= file_field_tag "branding[cover_image]",
+            accept: "image/png,image/jpeg,image/webp",
+            data: { branding_cover_file: true },
+            class: "branding-file-input" %>
+      <% if record.cover_image_attached? %>
+        <label class="checkbox-label cover-remove-label">
+          <%= check_box_tag "remove_cover", "1", false, id: "remove_cover_#{record.model_name.param_key}" %>
+          <%= t("club.branding.cover_remove_label") %>
+        </label>
+      <% end %>
+    <% else %>
+      <p class="muted"><%= t("club.branding.cover_requires_full") %></p>
+      <%= link_to t("club.branding.cover_see_plans"), public_prezzi_path, class: "btn btn-secondary btn-sm" %>
+    <% end %>
+  </div>
+</fieldset>
+
+<script>
+  (function () {
+    var input = document.querySelector("[data-branding-cover-file]");
+    var img = document.querySelector("[data-branding-cover-img]");
+    if (!input || !img) return;
+    input.addEventListener("change", function () {
+      var file = input.files && input.files[0];
+      if (!file) return;
+      var reader = new FileReader();
+      reader.onload = function (e) { img.src = e.target.result; };
+      reader.readAsDataURL(file);
+    });
+  })();
+</script>

backend/app/views/shared/_pending_bank_transfer.html.erb

@@ -0,0 +1,10 @@
+<%# locals: (order:) %>
+<% return if order.blank? %>
+<div class="card" style="margin-top:16px;border-color:#3d3520;background:#1a1810">
+  <p style="margin:0;color:#ddd">
+    <strong><%= t("billing.bank_transfer.pending_title") %></strong>
+    <%= raw t("billing.bank_transfer.pending_body_html",
+          plan: order.plan.name,
+          price: order.price_label) %>
+  </p>
+</div>

backend/app/views/shared/_plan_cards.html.erb

@@ -13,7 +13,8 @@
          target_plan: plan,
          stripe_subscription_active: stripe_subscription_active?(subscription),
          current_interval: current_interval,
-         subscription: subscription
+         subscription: subscription,
+         club: club
        ) : nil %>
     <% featured = plan.slug == "premium_full" %>
     <div class="plan-card<%= " plan-card--featured" if featured %>">
@@ -23,6 +24,13 @@
       <%= render "shared/plan_title", plan: plan %>
       <% if plan.slug == "free" %>
         <div class="plan-price">€0</div>
+      <% elsif billing_mode && club&.active_billing_quote&.plan_slug == plan.slug %>
+        <% quote = club.active_billing_quote %>
+        <div class="plan-price-block">
+          <div class="plan-price<%= " plan-price--featured" if featured %>"><%= quote.formatted_amount %></div>
+          <span class="plan-price-badge"><%= t("billing.bank_transfer.quoted_badge") %></span>
+          <p class="plan-price-equiv"><%= t("billing.bank_transfer.quoted_interval.#{quote.billing_interval}") %></p>
+        </div>
       <% else %>
         <% yearly = Billing::Stripe::PriceCatalog.label(plan_slug: plan.slug, interval: "yearly") %>
         <% monthly = Billing::Stripe::PriceCatalog.label(plan_slug: plan.slug, interval: "monthly") %>
@@ -63,12 +71,14 @@
       <% end %>
       <% if billing_mode %>
         <% action_kind = action[:kind] %>
+        <% quote = club&.active_billing_quote %>
+        <% pending_transfer = club&.pending_transfer_order %>
         <% if action_kind == :current %>
           <span class="btn btn-secondary" style="opacity:0.7"><%= action[:label] %></span>
         <% elsif action_kind == :none %>
-        <% elsif action_kind.in?(%i[contact disabled]) %>
+        <% elsif action_kind.in?(%i[contact disabled quoted_other]) %>
           <p class="plan-action-hint"><%= action[:label] %></p>
-        <% elsif action_kind == :checkout_options || action_kind == :change_options || action_kind == :interval_switch %>
+        <% elsif action_kind.in?(%i[checkout_options change_options interval_switch quoted bank_only]) %>
           <% if billing_profile_blocks_premium?(club) %>
             <p class="plan-action-hint" style="color:#e53935;margin-bottom:10px">
               <%= billing_profile_incomplete_message(club) %>
@@ -77,14 +87,33 @@
                   public_club_billing_profile_path(club, plan: plan.slug),
                   class: "btn btn-primary" %>
           <% else %>
-            <div class="plan-interval-actions">
+            <% unless action_kind.in?(%i[quoted bank_only]) %>
-              <% plan_intervals_for_display(action[:intervals]).each do |interval| %>
+              <div class="plan-interval-actions">
-                <% btn_kind = action_kind == :checkout_options ? :checkout_options : action_kind %>
+                <% plan_intervals_for_display(action[:intervals]).each do |interval| %>
-                <%= link_to plan_interval_button_label(plan, interval, kind: btn_kind),
+                  <% btn_kind = action_kind == :checkout_options ? :checkout_options : action_kind %>
-                      plan_interval_checkout_path(club, plan, interval),
+                  <%= link_to plan_interval_button_label(plan, interval, kind: btn_kind),
-                      class: plan_interval_button_class(interval) %>
+                        plan_interval_checkout_path(club, plan, interval),
+                        class: plan_interval_button_class(interval) %>
+                <% end %>
+              </div>
+            <% end %>
+            <% transfer_intervals = action_kind == :quoted ? action[:intervals] : (action[:intervals].presence || bank_transfer_intervals_for(plan)) %>
+            <% if MatchLiveTv.bank_transfer_configured? && transfer_intervals.any? %>
+              <% unless action_kind.in?(%i[quoted bank_only]) %>
+                <p class="plan-action-hint" style="margin:10px 0 6px"><%= t("billing.bank_transfer.or_label") %></p>
               <% end %>
-            </div>
+              <div class="plan-interval-actions">
+                <% plan_intervals_for_display(transfer_intervals).each do |interval| %>
+                  <% next unless show_bank_transfer_for?(club: club, plan: plan, interval: interval, quote: quote, pending_transfer: pending_transfer) %>
+                  <%= button_to t("billing.bank_transfer.pay_button_with_price", price: bank_transfer_price_label(plan, interval, quote: quote)),
+                        public_club_billing_bank_transfer_path(club, plan: plan.slug, interval: interval),
+                        method: :post,
+                        class: "btn btn-outline plan-interval-btn",
+                        form: { data: { turbo_confirm: t("billing.bank_transfer.confirm") } } %>
+                <% end %>
+              </div>
+              <p class="plan-action-hint" style="margin-top:8px"><%= t("billing.bank_transfer.hint") %></p>
+            <% end %>
           <% end %>
         <% end %>
       <% elsif plan.slug == "free" %>

backend/app/views/shared/_quoted_price_banner.html.erb

@@ -0,0 +1,19 @@
+<%# locals: (quote:, subscription: nil) %>
+<% return if quote.blank? %>
+<% quoted_plan_active = current_paid_plan?(subscription, quote.plan) %>
+<div class="card" style="margin-top:16px;border-color:#2e5a3c;background:#142018">
+  <p style="margin:0;color:#ddd">
+    <% if quoted_plan_active %>
+      <strong><%= t("billing.bank_transfer.quote_banner_active_title") %></strong>
+      <%= raw t(
+            "billing.bank_transfer.quote_banner_active_body_html",
+            plan: quote.plan.name,
+            price: quote.price_label,
+            date: subscription&.current_period_end.present? ? l_local(subscription.current_period_end.to_date) : t("billing.subscription_status.end_of_period")
+          ) %>
+    <% else %>
+      <strong><%= t("billing.bank_transfer.quote_banner_title") %></strong>
+      <%= raw t("billing.bank_transfer.quote_banner_body_html", plan: quote.plan.name, price: quote.price_label) %>
+    <% end %>
+  </p>
+</div>

backend/app/views/shared/_subscription_cancel.html.erb

@@ -1,5 +1,5 @@
 <%# locals: (club:, subscription:) %>
-<% return unless subscription&.premium? && subscription.stripe_subscription_id.present? && MatchLiveTv.stripe_enabled? %>
+<% return unless subscription&.premium? && MatchLiveTv.stripe_enabled? && subscription.stripe_subscription_id.present? %>
 
 <section id="subscription-cancel" class="subscription-cancel" style="margin-top:24px;padding:16px;border:1px solid #333;border-radius:8px">
   <% if subscription.cancel_at_period_end? %>

backend/config/initializers/match_live_tv.rb

@@ -21,7 +21,7 @@ module MatchLiveTv
     end
 
     def hls_public_url
-      ENV.fetch("HLS_PUBLIC_URL", "http://localhost:8888")
+      ENV.fetch("HLS_PUBLIC_URL") { "#{app_public_url.chomp('/')}/hls" }
     end
 
     def mediamtx_hls_url
@@ -73,6 +73,45 @@ module MatchLiveTv
       stripe_secret_key.present?
     end
 
+    def bank_transfer_iban
+      ENV["BANK_TRANSFER_IBAN"].to_s.gsub(/\s+/, "").presence
+    end
+
+    def bank_transfer_account_holder
+      ENV["BANK_TRANSFER_ACCOUNT_HOLDER"].to_s.strip.presence
+    end
+
+    def bank_transfer_bank_name
+      ENV["BANK_TRANSFER_BANK_NAME"].to_s.strip.presence
+    end
+
+    def bank_transfer_bic
+      ENV["BANK_TRANSFER_BIC"].to_s.strip.presence
+    end
+
+    def bank_transfer_proof_email
+      ENV["BANK_TRANSFER_PROOF_EMAIL"].presence || support_email
+    end
+
+    def bank_transfer_configured?
+      bank_transfer_iban.present? && bank_transfer_account_holder.present?
+    end
+
+    def smtp_configured?
+      ENV["SMTP_ADDRESS"].present?
+    end
+
+    # In produzione senza SMTP non blocca il flusso (es. collaudo): la mail si può inviare a mano.
+    def deliver_mail(mail)
+      if Rails.env.production? && !smtp_configured?
+        Rails.logger.info("[mail] skip (SMTP assente): #{mail.subject}")
+        return false
+      end
+
+      mail.deliver_now
+      true
+    end
+
     def privacy_controller_name
       ENV.fetch("PRIVACY_CONTROLLER_NAME", "Emiliano Frascaro")
     end

backend/config/locales/admin.de.yml

@@ -57,7 +57,7 @@ de:
         username_label: Benutzername
         password_label: Passwort
         submit: Anmelden
-        initial_credentials_html: "Anfangs-Zugangsdaten: <code>admin</code> / <code>admin</code>. Ändere das Passwort nach der ersten Anmeldung."
+        initial_credentials_html: "Anfangs-Zugangsdaten: <code>admin</code> / <code>AdminPass123</code>. Ändere das Passwort nach der ersten Anmeldung."
     passwords:
       edit:
         title: Passwort ändern

backend/config/locales/admin.en.yml

@@ -57,7 +57,7 @@ en:
         username_label: Username
         password_label: Password
         submit: Log in
-        initial_credentials_html: "Initial credentials: <code>admin</code> / <code>admin</code>. Change the password after the first login."
+        initial_credentials_html: "Initial credentials: <code>admin</code> / <code>AdminPass123</code>. Change the password after the first login."
     passwords:
       edit:
         title: Change password

backend/config/locales/admin.es.yml

@@ -57,7 +57,7 @@ es:
         username_label: Usuario
         password_label: Contraseña
         submit: Acceder
-        initial_credentials_html: "Credenciales iniciales: <code>admin</code> / <code>admin</code>. Cambia la contraseña después del primer acceso."
+        initial_credentials_html: "Credenciales iniciales: <code>admin</code> / <code>AdminPass123</code>. Cambia la contraseña después del primer acceso."
     passwords:
       edit:
         title: Cambiar contraseña

backend/config/locales/admin.fr.yml

@@ -57,7 +57,7 @@ fr:
         username_label: Nom d'utilisateur
         password_label: Mot de passe
         submit: Se connecter
-        initial_credentials_html: "Identifiants initiaux : <code>admin</code> / <code>admin</code>. Changez le mot de passe après la première connexion."
+        initial_credentials_html: "Identifiants initiaux : <code>admin</code> / <code>AdminPass123</code>. Changez le mot de passe après la première connexion."
     passwords:
       edit:
         title: Changer le mot de passe

backend/config/locales/admin.it.yml

@@ -44,6 +44,10 @@ it:
       invoice_issued: "Fattura %{number} emessa e inviata a %{email}."
       invoice_updated: "Fattura %{number} aggiornata."
       invoice_uploaded: "Fattura caricata e inviata a %{email}."
+      quote_saved: "Prezzo concordato salvato per %{club}: %{plan} a %{amount}."
+      quote_revoked: "Prezzo concordato revocato per %{club}."
+      transfer_confirmed: "Bonifico confermato: piano %{plan} attivo per %{club}."
+      transfer_cancelled: Bonifico in attesa annullato.
       youtube_not_configured: Configura YOUTUBE_CLIENT_ID e YOUTUBE_CLIENT_SECRET in .env
     common:
       free_plan: Free
@@ -57,7 +61,7 @@ it:
         username_label: Username
         password_label: Password
         submit: Accedi
-        initial_credentials_html: "Credenziali iniziali: <code>admin</code> / <code>admin</code>. Cambia la password dopo il primo accesso."
+        initial_credentials_html: "Credenziali iniziali: <code>admin</code> / <code>AdminPass123</code>. Cambia la password dopo il primo accesso."
     passwords:
       edit:
         title: Cambia password
@@ -193,6 +197,7 @@ it:
           teams: Squadre
           comped: Omaggio
           stripe: Stripe
+          quote: Concordato
         manage: Gestisci
         invoices: Fatture
       show:
@@ -228,6 +233,22 @@ it:
       reason_label: "Motivo (es. sponsor 2026)"
       reason_placeholder: "Sponsor, promozione…"
       grant_button: Concedi omaggio
+    quote:
+      title: Prezzo concordato (bonifico)
+      description: "Importo commerciale per questa società: piano, cadenza e cifra in euro. In billing la società vede solo questo prezzo e può pagare solo con bonifico. L'omaggio (0 €) resta nella card sopra."
+      none: Nessun prezzo concordato. La società paga a listino (carta o bonifico).
+      active_html: "<strong>%{plan}</strong> · %{interval} · <strong>%{amount}</strong>"
+      note_label: "Nota:"
+      plan_label: Piano
+      interval_label: Cadenza
+      interval_yearly: Annuale
+      interval_monthly: Mensile
+      amount_label: "Importo (€)"
+      amount_placeholder: "es. 150 oppure 150,00"
+      commercial_note_label: Nota commerciale (opzionale)
+      save_button: Salva prezzo concordato
+      revoke_button: Revoca prezzo concordato
+      revoke_confirm: "Revocare il prezzo concordato per %{club}? Tornerà il listino (carta + bonifico)."
     teams:
       show:
         back: "← %{club}"
@@ -281,6 +302,23 @@ it:
       index:
         title: Pagamenti da fatturare
         description: "Pagamenti Stripe pagati senza PDF fattura. Genera il PDF nei tuoi sistemi, poi caricalo qui: viene associato al pagamento e inviato via email al cliente."
+        transfers_title: Bonifici in attesa
+        transfers_description: "La società ha chiesto di pagare con bonifico: il piano non è ancora attivo. Conferma dopo l'accredito (puoi allegare subito il PDF fattura)."
+        transfers_none: Nessun bonifico in attesa.
+        transfers_table:
+          club: Società
+          plan: Piano
+          amount: Importo
+          holder: Intestatario
+          iban: IBAN
+          causal: Causale
+          requested: Richiesto
+        confirm_button: Conferma pagamento e attiva
+        cancel_button: Annulla richiesta
+        cancel_confirm: Annullare questa richiesta di bonifico?
+        pdf_optional: PDF fattura (opzionale)
+        kind_quote: prezzo concordato
+        kind_list: listino
         filter_label: "Filtra società:"
         filter_all: Tutte
         incomplete_profile_warning: Dati fatturazione incompleti

backend/config/locales/app.de.yml

@@ -83,11 +83,9 @@ de:
       first_team_name_placeholder: "z. B. Under 15"
       plan_label: "Starttarif (für den gesamten Verein)"
       plan_free: "Free — 1 Streaming-Konto pro Team, 1 Livestream"
-      plan_light: Premium Light
+      plan_light: "Premium Light — 59 €/Jahr"
-      plan_full: Premium Full
+      plan_full: "Premium Full — 199 €/Jahr"
-      interval_label: Premium-Abrechnung
+      plan_hint: "Karte, Überweisung oder monatliche Abrechnung wählst du danach auf der Abo-Seite. Ein kostenpflichtiger Tarif wird erst nach der Zahlung aktiv."
-      interval_yearly: "Jährlich — 59 €/Jahr (Light) oder 199 €/Jahr (Full)"
-      interval_monthly: "Monatlich — 7,90 €/Monat (Light) oder 24,90 €/Monat (Full)"
       submit: Verein erstellen
     billing:
       title: "Abonnement — %{name}"
@@ -193,6 +191,10 @@ de:
       contact_trailer: für ein maßgeschneidertes Angebot.
       club_payments_link: Zahlungen und Rechnungen des Vereins
     streaming_staff:
+      principal_heading: Hauptkonto
+      principal_body_html: "Das Konto, mit dem der Verein registriert wurde (<strong>%{email}</strong>), ist <strong>für dieses Team vorgesehen</strong>: damit meldest du dich in der App an und startest den Livestream."
+      principal_score_hint_html: "Für den Punktestand von einem anderen Telefon teile während des Streams den <strong>Regie-Link</strong> (kein zweites Konto nötig)."
+      extra_staff_heading: Weitere Konten, die übertragen können
       self_account_heading: "Dein Konto (%{email})"
       self_account_hint: "Du kannst die Übertragung aus der App verwalten. Für den Punktestand von einem anderen Telefon teile den <strong>Regie-Link</strong> während des Streams (kein zweites Konto nötig)."
       self_assign_submit: Das mache ich — Übertragungsverantwortlicher
@@ -489,6 +491,7 @@ de:
     modal:
       set_won_title: Satz gewonnen
       confirm: Satz beenden
+      confirm_action: Bestätigen
       cancel: Abbrechen
     board:
       next_period: Nächstes Viertel
@@ -528,6 +531,17 @@ de:
       mute_error: Fehler beim Stummschalten
       close_error: Fehler beim Beenden
       close_confirm: Übertragung endgültig beenden?
+      pause_confirm_title: Livestream pausieren?
+      pause_confirm_body: Das Cover bleibt on air, bis du fortsetzt.
+      resume_confirm_title: Livestream fortsetzen?
+      resume_confirm_body: Die Kamera geht wieder on air statt des Covers.
+      mute_confirm_title: Audio stummschalten?
+      mute_confirm_body: Das Mikrofon wird nicht mehr an den Stream gesendet, bis du es wieder aktivierst.
+      unmute_confirm_title: Audio wieder aktivieren?
+      unmute_confirm_body: Das Mikrofon ist wieder aktiv im Stream.
+      advance_period_title: Zum nächsten Abschnitt wechseln?
+      advance_period_body: Die Anzeigetafel wechselt zum nächsten Abschnitt und der aktuelle Stand wird gespeichert.
+      stop_confirm_title: Livestream beenden?
       link_unavailable: Link nicht verfügbar
       link_copied: Link kopiert
       copy_prompt: "Link kopieren:"
@@ -613,6 +627,7 @@ de:
     clubs:
       already_registered: Du hast bereits einen Verein registriert
       created: Verein und erstes Team erstellt.
+      created_complete_subscription: Verein erstellt. Schließe das Abo auf dieser Seite ab.
       updated: Verein aktualisiert.
       complete_billing_first: Vervollständige deine Rechnungsdaten, bevor du einen Premium-Tarif aktivierst.
       comped_change_denied: "Dieser Tarif ist ein von Match Live TV verwaltetes kostenloses Abonnement. Um zu einem kostenpflichtigen Abonnement zu wechseln, kontaktiere den Support."

backend/config/locales/app.en.yml

@@ -33,6 +33,14 @@ en:
       quick_colors: Quick colors
       header_preview_label: Header preview
       name_placeholder: Club / team name
+      cover_legend: Live cover (sponsors)
+      cover_inherit_hint: Leave blank to use the club cover, otherwise the default Match Live TV cover.
+      cover_hint: "16:9 image recommended (PNG, JPEG or WebP, max 5 MB). Shown to viewers and YouTube when paused or offline."
+      cover_file_label: Cover image
+      cover_preview_alt: Live cover preview
+      cover_remove_label: Remove custom cover
+      cover_requires_full: Custom sponsor covers are available on the Premium Full plan.
+      cover_see_plans: See plans
     dashboard:
       title: "%{name} — Club"
       plan_label: "Plan:"
@@ -78,11 +86,9 @@ en:
       first_team_name_placeholder: "e.g. Under 15"
       plan_label: "Starting plan (for the whole club)"
       plan_free: "Free — 1 transmitter account per team, 1 live stream"
-      plan_light: Premium Light
+      plan_light: "Premium Light — €59/year"
-      plan_full: Premium Full
+      plan_full: "Premium Full — €199/year"
-      interval_label: Premium billing
+      plan_hint: "Card, bank transfer or monthly billing are chosen later on the Subscription page. A paid plan activates only after payment."
-      interval_yearly: "Yearly — €59/year (Light) or €199/year (Full)"
-      interval_monthly: "Monthly — €7.90/month (Light) or €24.90/month (Full)"
       submit: Create club
     billing:
       title: "Subscription — %{name}"
@@ -188,6 +194,10 @@ en:
       contact_trailer: for a custom offer.
       club_payments_link: Club payments and invoices
     streaming_staff:
+      principal_heading: Main account
+      principal_body_html: "The account used to register the club (<strong>%{email}</strong>) is the one <strong>designated for this team</strong>: use it in the app to start the live stream."
+      principal_score_hint_html: "For scoring from another phone, share the <strong>control-room link</strong> during the stream (no second account needed)."
+      extra_staff_heading: Other accounts that can broadcast
       self_account_heading: "Your account (%{email})"
       self_account_hint: "You can manage streaming from the app. For scoring from another phone, share the <strong>control-room link</strong> during the stream (no second account needed)."
       self_assign_submit: I'll do it — broadcast manager
@@ -484,6 +494,7 @@ en:
     modal:
       set_won_title: Set won
       confirm: Close set
+      confirm_action: Confirm
       cancel: Cancel
     board:
       next_period: Next quarter
@@ -523,6 +534,17 @@ en:
       mute_error: Error muting audio
       close_error: Error closing
       close_confirm: Permanently close the live stream?
+      pause_confirm_title: Pause the live stream?
+      pause_confirm_body: The cover slate will stay on air until you resume.
+      resume_confirm_title: Resume the live stream?
+      resume_confirm_body: The camera will go back on air instead of the cover slate.
+      mute_confirm_title: Mute audio?
+      mute_confirm_body: The microphone will not be sent to the stream until you unmute.
+      unmute_confirm_title: Unmute audio?
+      unmute_confirm_body: The microphone will be active on the stream again.
+      advance_period_title: Advance to the next period?
+      advance_period_body: The scoreboard will move to the next period and the current period score will be saved.
+      stop_confirm_title: End the live stream?
       link_unavailable: Link not available
       link_copied: Link copied
       copy_prompt: "Copy the link:"
@@ -608,6 +630,7 @@ en:
     clubs:
       already_registered: You've already registered a club
       created: Club and first team created.
+      created_complete_subscription: Club created. Complete your subscription on this page.
       updated: Club updated.
       complete_billing_first: Complete your billing details before activating a premium plan.
       comped_change_denied: "This plan is a complimentary subscription managed by Match Live TV. To switch to a paid subscription, contact support."

backend/config/locales/app.es.yml

@@ -83,11 +83,9 @@ es:
       first_team_name_placeholder: "ej. Sub-15"
       plan_label: "Plan inicial (para todo el club)"
       plan_free: "Free — 1 cuenta de emisión por equipo, 1 directo"
-      plan_light: Premium Light
+      plan_light: "Premium Light — 59 €/año"
-      plan_full: Premium Full
+      plan_full: "Premium Full — 199 €/año"
-      interval_label: Facturación premium
+      plan_hint: "La tarjeta, la transferencia o la facturación mensual se eligen después, en Abono. El plan de pago se activa solo tras el pago."
-      interval_yearly: "Anual — 59 €/año (Light) o 199 €/año (Full)"
-      interval_monthly: "Mensual — 7,90 €/mes (Light) o 24,90 €/mes (Full)"
       submit: Crear club
     billing:
       title: "Suscripción — %{name}"
@@ -193,6 +191,10 @@ es:
       contact_trailer: para una oferta a medida.
       club_payments_link: Pagos y facturas del club
     streaming_staff:
+      principal_heading: Cuenta principal
+      principal_body_html: "La cuenta con la que se registró el club (<strong>%{email}</strong>) es la <strong>designada para este equipo</strong>: con ella entras en la app y arrancas el directo."
+      principal_score_hint_html: "Para el marcador desde otro teléfono, durante el directo comparte el <strong>enlace de control</strong> (no hace falta una segunda cuenta)."
+      extra_staff_heading: Otras cuentas que pueden transmitir
       self_account_heading: "Tu cuenta (%{email})"
       self_account_hint: "Puedes gestionar la transmisión desde la app. Para el marcador desde otro teléfono, comparte el <strong>enlace de control</strong> durante el directo (no hace falta una segunda cuenta)."
       self_assign_submit: Yo me encargo — responsable de transmisión
@@ -489,6 +491,7 @@ es:
     modal:
       set_won_title: Set ganado
       confirm: Cerrar set
+      confirm_action: Confirmar
       cancel: Cancelar
     board:
       next_period: Siguiente cuarto
@@ -528,6 +531,17 @@ es:
       mute_error: Error al silenciar el audio
       close_error: Error al cerrar
       close_confirm: "¿Cerrar definitivamente la retransmisión?"
+      pause_confirm_title: "¿Pausar el directo?"
+      pause_confirm_body: La portada seguirá en antena hasta que lo reanudes.
+      resume_confirm_title: "¿Reanudar el directo?"
+      resume_confirm_body: La cámara volverá a antena en lugar de la portada.
+      mute_confirm_title: "¿Silenciar el audio?"
+      mute_confirm_body: El micrófono no se enviará al stream hasta que lo reactives.
+      unmute_confirm_title: "¿Reactivar el audio?"
+      unmute_confirm_body: El micrófono volverá a estar activo en el stream.
+      advance_period_title: "¿Pasar al periodo siguiente?"
+      advance_period_body: El marcador pasará al siguiente periodo y se guardará el marcador del periodo actual.
+      stop_confirm_title: "¿Terminar el directo?"
       link_unavailable: Enlace no disponible
       link_copied: Enlace copiado
       copy_prompt: "Copia el enlace:"
@@ -613,6 +627,7 @@ es:
     clubs:
       already_registered: Ya has registrado un club
       created: Club y primer equipo creados.
+      created_complete_subscription: Club creado. Completa la suscripción en esta página.
       updated: Club actualizado.
       complete_billing_first: Completa tus datos de facturación antes de activar un plan premium.
       comped_change_denied: "Este plan es una suscripción de cortesía gestionada por Match Live TV. Para pasar a una suscripción de pago, contacta con soporte."

backend/config/locales/app.fr.yml

@@ -83,11 +83,9 @@ fr:
       first_team_name_placeholder: "ex. Under 15"
       plan_label: "Forfait de départ (pour tout le club)"
       plan_free: "Gratuit — 1 compte diffuseur par équipe, 1 direct"
-      plan_light: Premium Light
+      plan_light: "Premium Light — 59 €/an"
-      plan_full: Premium Full
+      plan_full: "Premium Full — 199 €/an"
-      interval_label: Facturation premium
+      plan_hint: "Carte, virement ou mensualité se choisissent ensuite, sur la page Abonnement. Le forfait payant ne s'active qu'après le paiement."
-      interval_yearly: "Annuel — 59 €/an (Light) ou 199 €/an (Full)"
-      interval_monthly: "Mensuel — 7,90 €/mois (Light) ou 24,90 €/mois (Full)"
       submit: Créer le club
     billing:
       title: "Abonnement — %{name}"
@@ -193,6 +191,10 @@ fr:
       contact_trailer: pour une offre sur mesure.
       club_payments_link: Paiements et factures du club
     streaming_staff:
+      principal_heading: Compte principal
+      principal_body_html: "Le compte utilisé pour enregistrer le club (<strong>%{email}</strong>) est celui <strong>désigné pour cette équipe</strong> : c’est avec lui que tu te connectes à l’app et que tu lances le direct."
+      principal_score_hint_html: "Pour le score depuis un autre téléphone, pendant le direct partage le <strong>lien régie</strong> (pas besoin d’un second compte)."
+      extra_staff_heading: Autres comptes autorisés à diffuser
       self_account_heading: "Ton compte (%{email})"
       self_account_hint: "Tu peux gérer la diffusion depuis l'application. Pour le score depuis un autre téléphone, partage le <strong>lien régie</strong> pendant le direct (pas besoin d'un second compte)."
       self_assign_submit: C'est moi — responsable diffusion
@@ -489,6 +491,7 @@ fr:
     modal:
       set_won_title: Set gagné
       confirm: Terminer le set
+      confirm_action: Confirmer
       cancel: Annuler
     board:
       next_period: Quart-temps suivant
@@ -528,6 +531,17 @@ fr:
       mute_error: Erreur lors de la coupure audio
       close_error: Erreur de clôture
       close_confirm: Clôturer définitivement le direct ?
+      pause_confirm_title: Mettre le direct en pause ?
+      pause_confirm_body: La couverture restera à l'antenne jusqu'à la reprise.
+      resume_confirm_title: Reprendre le direct ?
+      resume_confirm_body: La caméra reviendra à l'antenne à la place de la couverture.
+      mute_confirm_title: Couper l'audio ?
+      mute_confirm_body: Le micro ne sera plus envoyé au flux tant que vous ne le réactivez pas.
+      unmute_confirm_title: Réactiver l'audio ?
+      unmute_confirm_body: Le micro sera à nouveau actif sur le flux.
+      advance_period_title: Passer à la période suivante ?
+      advance_period_body: Le tableau passera à la période suivante et le score de la période en cours sera enregistré.
+      stop_confirm_title: Terminer le direct ?
       link_unavailable: Lien non disponible
       link_copied: Lien copié
       copy_prompt: "Copiez le lien :"
@@ -613,6 +627,7 @@ fr:
     clubs:
       already_registered: Tu as déjà inscrit un club
       created: Club et première équipe créés.
+      created_complete_subscription: Club créé. Termine l'abonnement sur cette page.
       updated: Club mis à jour.
       complete_billing_first: Complète tes données de facturation avant d'activer un forfait premium.
       comped_change_denied: "Ce forfait est un abonnement offert géré par Match Live TV. Pour passer à un abonnement payant, contacte le support."

backend/config/locales/app.it.yml

@@ -33,6 +33,14 @@ it:
       quick_colors: Colori rapidi
       header_preview_label: Anteprima intestazione
       name_placeholder: Nome società / squadra
+      cover_legend: Copertina diretta (sponsor)
+      cover_inherit_hint: Lascia vuoto per usare la copertina della società, altrimenti quella standard Match Live TV.
+      cover_hint: "Immagine 16:9 consigliata (PNG, JPEG o WebP, max 5 MB). In pausa o senza segnale la vedranno spettatori e YouTube."
+      cover_file_label: Immagine copertina
+      cover_preview_alt: Anteprima copertina diretta
+      cover_remove_label: Rimuovi copertina personalizzata
+      cover_requires_full: La copertina sponsor personalizzata è disponibile con il piano Premium Full.
+      cover_see_plans: Vedi piani
     dashboard:
       title: "%{name} — Società"
       plan_label: "Piano:"
@@ -78,11 +86,9 @@ it:
       first_team_name_placeholder: "es. Under 15"
       plan_label: "Piano iniziale (per tutta la società)"
       plan_free: "Free — 1 account trasmettitore per squadra, 1 live"
-      plan_light: Premium Light
+      plan_light: "Premium Light — €59/anno"
-      plan_full: Premium Full
+      plan_full: "Premium Full — €199/anno"
-      interval_label: Fatturazione premium
+      plan_hint: "Carta, bonifico o cadenza mensile li scegli dopo, nella pagina Abbonamento. Il piano a pagamento si attiva solo dopo il pagamento."
-      interval_yearly: "Annuale — €59/anno (Light) o €199/anno (Full)"
-      interval_monthly: "Mensile — €7,90/mese (Light) o €24,90/mese (Full)"
       submit: Crea società
     billing:
       title: "Abbonamento — %{name}"
@@ -188,6 +194,10 @@ it:
       contact_trailer: per un'offerta su misura.
       club_payments_link: Pagamenti e fatture della società
     streaming_staff:
+      principal_heading: Account principale
+      principal_body_html: "L'account con cui è stata registrata la società (<strong>%{email}</strong>) è quello <strong>designato per questa squadra</strong>: con quello accedi all'app e avvii la diretta."
+      principal_score_hint_html: "Per il punteggio da un altro telefono, durante la diretta condividi il <strong>link regia</strong> (non serve un secondo account)."
+      extra_staff_heading: Altri account che possono trasmettere
       self_account_heading: "Il tuo account (%{email})"
       self_account_hint: "Puoi gestire la trasmissione dall'app. Per il punteggio da un altro telefono, condividi il <strong>link regia</strong> durante la diretta (non serve un secondo account)."
       self_assign_submit: Sono io — responsabile trasmissione
@@ -330,10 +340,11 @@ it:
       sdi_or_pec: "Codice destinatario SDI (7 caratteri) o PEC"
       sdi_invalid: "Codice destinatario SDI (7 caratteri)"
     actions:
-      current_plan: Piano attuale
+      current_plan: Piano attivo
       contact_for_free: "Per passare al piano Free, contatta il supporto."
       stripe_not_configured: Stripe non configurato
       stripe_prices_not_configured: Prezzi Stripe non configurati
+      bank_transfer_not_configured: Bonifico non ancora configurato
       complete_billing_prefix: Completa i dati di fatturazione prima di attivare un piano premium.
       profile_incomplete_default: Completa i dati di fatturazione prima di attivare un piano premium.
       profile_missing: "Mancano: %{fields}."
@@ -396,6 +407,7 @@ it:
       end_of_period: fine periodo
       next_renewal: prossimo rinnovo
       next_renewal_label: "Prossimo rinnovo: %{date}"
+      bank_transfer_until_html: "Pagato con bonifico, valido fino al <strong>%{date}</strong> (nessun rinnovo automatico)."
     plan_change_info:
       trigger_label: Info cambio piano e fatturazione
       title: Cambio piano e fatturazione
@@ -425,6 +437,25 @@ it:
     prices:
       yearly: "%{amount}/anno"
       monthly: "%{amount}/mese"
+    bank_transfer:
+      quoted_badge: Prezzo concordato
+      quoted_interval:
+        yearly: fatturazione annuale, solo bonifico
+        monthly: fatturazione mensile, solo bonifico
+      quoted_other: "Per questa società è attivo un prezzo concordato su un altro piano."
+      pay_button: Paga con bonifico
+      pay_button_with_price: "Paga con bonifico — %{price}"
+      or_label: oppure
+      pending_title: Ordine in corso
+      pending_body_html: "Hai richiesto <strong>%{plan}</strong> (%{price}). Resta in attesa: il piano si attiverà quando Match Live TV confermerà il pagamento."
+      quote_banner_title: Prezzo concordato
+      quote_banner_body_html: "Per questa società vale <strong>%{plan}</strong> a <strong>%{price}</strong>. Il pagamento avviene solo con bonifico (non con carta)."
+      quote_banner_active_title: Piano attivo
+      quote_banner_active_body_html: "In questo momento vale <strong>%{plan}</strong> a <strong>%{price}</strong>, fino al <strong>%{date}</strong>. Il rinnovo non è automatico."
+      quote_note: "Nota commerciale: %{note}"
+      hint: "Il piano resta quello attuale finché Match Live TV non conferma l'accredito."
+      confirm: "Confermi la richiesta di bonifico? Il piano resta quello attuale finché Match Live TV non conferma l'accredito."
+      renewal_html: "Con il bonifico l'abbonamento non si rinnova da solo: alla scadenza torna Free, salvo nuovo bonifico o rinnovo da parte nostra."
   regia:
     meta_title_fallback: "Regia — Match Live TV"
     title: "Regia — %{home} vs %{away}"
@@ -484,6 +515,7 @@ it:
     modal:
       set_won_title: Set vinto
       confirm: Chiudi set
+      confirm_action: Conferma
       cancel: Annulla
     board:
       next_period: Prossimo quarto
@@ -523,6 +555,17 @@ it:
       mute_error: Errore silenziamento audio
       close_error: Errore chiusura
       close_confirm: Chiudere definitivamente la diretta?
+      pause_confirm_title: Mettere in pausa?
+      pause_confirm_body: La diretta passerà alla copertina finché non la riprendi.
+      resume_confirm_title: Riprendere la diretta?
+      resume_confirm_body: La telecamera tornerà in onda al posto della copertina.
+      mute_confirm_title: Silenziare l'audio?
+      mute_confirm_body: Il microfono non verrà inviato allo stream finché non lo riattivi.
+      unmute_confirm_title: Riattivare l'audio?
+      unmute_confirm_body: Il microfono tornerà attivo sullo stream.
+      advance_period_title: Passare al periodo successivo?
+      advance_period_body: Il tabellone passerà al periodo successivo e il punteggio del periodo corrente sarà salvato.
+      stop_confirm_title: Terminare la diretta?
       link_unavailable: Link non disponibile
       link_copied: Link copiato
       copy_prompt: "Copia il link:"
@@ -608,6 +651,7 @@ it:
     clubs:
       already_registered: Hai già registrato una società
       created: Società e prima squadra create.
+      created_complete_subscription: Società creata. Completa l'abbonamento in questa pagina.
       updated: Società aggiornata.
       complete_billing_first: Completa i dati di fatturazione prima di attivare un piano premium.
       comped_change_denied: "Il piano è un abbonamento omaggio gestito da Match Live TV. Per passare a un abbonamento a pagamento contatta il supporto."
@@ -627,6 +671,8 @@ it:
       subscription_canceled: "Abbonamento disdetto. Resta attivo fino al %{date}; da quel giorno passerai al piano Free."
       stripe_error: "Errore Stripe: %{message}"
       invoice_pdf_unavailable: PDF fattura non disponibile.
+      bank_transfer_requested: Richiesta registrata. Il piano si attiverà dopo la conferma del pagamento.
+      quote_checkout_denied: "Per questa società è attivo un prezzo concordato: usa il pagamento con bonifico."
     club_recordings:
       not_authorized: Non autorizzato
     teams:

backend/config/locales/coverable.en.yml

@@ -0,0 +1,5 @@
+en:
+  coverable:
+    errors:
+      invalid_type: "must be PNG, JPEG or WebP"
+      too_large: "exceeds the maximum size of 5 MB"

backend/config/locales/coverable.it.yml

@@ -0,0 +1,5 @@
+it:
+  coverable:
+    errors:
+      invalid_type: "deve essere PNG, JPEG o WebP"
+      too_large: "supera la dimensione massima di 5 MB"

backend/config/locales/mailers.en.yml

@@ -54,3 +54,34 @@ en:
       also_text: It is also available under Subscription on the Match Live TV site.
       thanks: Thanks,
       signoff: Match Live TV
+    invoice_activated:
+      subject: "Plan %{plan} is active — invoice %{number}"
+      hello: Hello,
+      period_fallback: the end of the period
+      body_html: "we received your bank transfer: the <strong>%{plan}</strong> plan is now active for <strong>%{club}</strong> until <strong>%{until_date}</strong>. Invoice <strong>%{number}</strong> for <strong>%{amount}</strong> is attached."
+      body_text: "we received your bank transfer: the %{plan} plan is now active for %{club} until %{until_date}. Invoice %{number} for %{amount} is attached."
+    bank_transfer:
+      thanks: Thanks,
+      signoff: Match Live TV
+      instructions:
+        subject: "Bank transfer instructions — %{plan}"
+        hello: Hello,
+        intro_html: "you requested the <strong>%{plan}</strong> plan (%{price}) for <strong>%{club}</strong> with a bank transfer."
+        intro_text: "you requested the %{plan} plan (%{price}) for %{club} with a bank transfer."
+        not_active_yet: The plan will be activated only after Match Live TV confirms the payment. Until then your current plan stays active.
+        iban_label: "IBAN:"
+        holder_label: "Account holder:"
+        bank_label: "Bank:"
+        bic_label: "BIC/SWIFT:"
+        amount_label: "Amount:"
+        causal_label: "Payment reference:"
+        proof_html: "After paying, send the receipt to <strong>%{email}</strong>."
+        proof_text: "After paying, send the receipt to %{email}."
+      plan_activated:
+        subject: "Plan %{plan} is active — Match Live TV"
+        hello: Hello,
+        period_fallback: the end of the period
+        body_html: "we received your bank transfer: the <strong>%{plan}</strong> plan is now active for <strong>%{club}</strong> until <strong>%{until_date}</strong>. The invoice will follow by email shortly."
+        body_text: "we received your bank transfer: the %{plan} plan is now active for %{club} until %{until_date}. The invoice will follow by email shortly."
+        invoice_later: You can already use the plan from the Subscription section of your account.
+

backend/config/locales/mailers.it.yml

@@ -54,3 +54,34 @@ it:
       also_text: È disponibile anche in Abbonamento sul sito Match Live TV.
       thanks: Grazie,
       signoff: Match Live TV
+    invoice_activated:
+      subject: "Piano %{plan} attivo — fattura %{number}"
+      hello: Buongiorno,
+      period_fallback: fine periodo
+      body_html: "abbiamo ricevuto il bonifico: il piano <strong>%{plan}</strong> è attivo per <strong>%{club}</strong> fino al <strong>%{until_date}</strong>. In allegato la fattura <strong>%{number}</strong> di <strong>%{amount}</strong>."
+      body_text: "abbiamo ricevuto il bonifico: il piano %{plan} è attivo per %{club} fino al %{until_date}. In allegato la fattura %{number} di %{amount}."
+    bank_transfer:
+      thanks: Grazie,
+      signoff: Match Live TV
+      instructions:
+        subject: "Istruzioni per il bonifico — %{plan}"
+        hello: Buongiorno,
+        intro_html: "hai richiesto l'abbonamento <strong>%{plan}</strong> (%{price}) per <strong>%{club}</strong> con pagamento tramite bonifico."
+        intro_text: "hai richiesto l'abbonamento %{plan} (%{price}) per %{club} con pagamento tramite bonifico."
+        not_active_yet: Il piano verrà attivato solo dopo la conferma del pagamento da parte di Match Live TV. Fino ad allora resta attivo il piano attuale.
+        iban_label: "IBAN:"
+        holder_label: "Intestatario:"
+        bank_label: "Banca:"
+        bic_label: "BIC/SWIFT:"
+        amount_label: "Importo:"
+        causal_label: "Causale:"
+        proof_html: "Dopo il pagamento invia la distinta o la ricevuta a <strong>%{email}</strong>."
+        proof_text: "Dopo il pagamento invia la distinta o la ricevuta a %{email}."
+      plan_activated:
+        subject: "Piano %{plan} attivo — Match Live TV"
+        hello: Buongiorno,
+        period_fallback: fine periodo
+        body_html: "abbiamo ricevuto il bonifico: il piano <strong>%{plan}</strong> è attivo per <strong>%{club}</strong> fino al <strong>%{until_date}</strong>. La fattura ti arriverà a breve via email."
+        body_text: "abbiamo ricevuto il bonifico: il piano %{plan} è attivo per %{club} fino al %{until_date}. La fattura ti arriverà a breve via email."
+        invoice_later: Puoi già usare le funzioni del piano dalla sezione Abbonamento del tuo account.
+

backend/config/routes.rb

@@ -93,11 +93,15 @@ Rails.application.routes.draw do
     end
     get "billing", to: "billing#index", as: :billing
     post "billing/payments/:payment_id/attach_pdf", to: "billing#attach_pdf", as: :billing_payment_attach_pdf
+    post "billing/transfers/:id/confirm", to: "billing#confirm_transfer", as: :billing_transfer_confirm
+    post "billing/transfers/:id/cancel", to: "billing#cancel_transfer", as: :billing_transfer_cancel
     resources :teams, only: %i[show]
     resources :clubs, only: %i[index show] do
       member do
         post :grant_comped
         delete :revoke_comped
+        post :set_quote
+        delete :revoke_quote
       end
       resources :billing_invoices, only: %i[index new create edit update], controller: "billing_invoices"
       resources :club_recordings, only: %i[index update destroy], path: "replays", as: :recordings do
@@ -198,6 +202,7 @@ Rails.application.routes.draw do
     get "clubs/:id/billing/profile", to: "club_billing#profile", as: :club_billing_profile
     patch "clubs/:id/billing/profile", to: "club_billing#update_profile"
     post "clubs/:id/billing/cancel_subscription", to: "club_billing#cancel_subscription", as: :club_billing_cancel_subscription
+    post "clubs/:id/billing/bank_transfer", to: "club_billing#request_bank_transfer", as: :club_billing_bank_transfer
     get "clubs/:id/billing/invoices/:invoice_id", to: "club_billing#download_invoice", as: :club_billing_invoice
     get "clubs/:id/checkout", to: "clubs#checkout", as: :club_checkout
     post "clubs/:id/portal", to: "clubs#portal", as: :club_portal

backend/config/sidekiq.yml

@@ -2,5 +2,6 @@
 :queues:
   - critical
   - youtube_relay_home
+  - youtube_relay_cloud
   - youtube_relay
   - default

backend/db/migrate/20260818220000_add_bank_transfer_billing.rb

@@ -0,0 +1,42 @@
+class AddBankTransferBilling < ActiveRecord::Migration[7.2]
+  def change
+    create_table :billing_club_quotes, id: :uuid do |t|
+      t.references :club, null: false, foreign_key: true, type: :uuid, index: false
+      t.string :plan_slug, null: false
+      t.string :billing_interval, null: false
+      t.integer :amount_cents, null: false
+      t.string :currency, null: false, default: "eur"
+      t.string :note
+      t.boolean :active, null: false, default: true
+      t.references :created_by_admin, foreign_key: { to_table: :admin_accounts }, type: :uuid
+      t.timestamps
+    end
+    add_index :billing_club_quotes, :club_id, unique: true, where: "active = TRUE",
+              name: "index_billing_club_quotes_active_club"
+
+    create_table :billing_transfer_orders, id: :uuid do |t|
+      t.references :club, null: false, foreign_key: true, type: :uuid
+      t.references :billing_club_quote, foreign_key: true, type: :uuid
+      t.references :billing_payment, foreign_key: true, type: :uuid
+      t.string :plan_slug, null: false
+      t.string :billing_interval, null: false
+      t.integer :amount_cents, null: false
+      t.string :currency, null: false, default: "eur"
+      t.string :kind, null: false
+      t.string :status, null: false, default: "awaiting_payment"
+      t.string :reference_code, null: false
+      t.references :requested_by_user, foreign_key: { to_table: :users }, type: :uuid
+      t.references :confirmed_by_admin, foreign_key: { to_table: :admin_accounts }, type: :uuid
+      t.datetime :confirmed_at
+      t.datetime :cancelled_at
+      t.timestamps
+    end
+    add_index :billing_transfer_orders, :reference_code, unique: true
+    add_index :billing_transfer_orders, :status
+    add_index :billing_transfer_orders, :club_id, unique: true, where: "status = 'awaiting_payment'",
+              name: "index_billing_transfer_orders_awaiting_club"
+
+    add_column :billing_payments, :provider, :string, null: false, default: "stripe"
+    add_index :billing_payments, :provider
+  end
+end

backend/db/schema.rb

@@ -10,7 +10,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema[7.2].define(version: 2026_08_13_184100) do
+ActiveRecord::Schema[7.2].define(version: 2026_08_18_220000) do
   # These are extensions that must be enabled in order to support this database
   enable_extension "pgcrypto"
   enable_extension "plpgsql"
@@ -51,6 +51,21 @@ ActiveRecord::Schema[7.2].define(version: 2026_08_13_184100) do
     t.index ["username"], name: "index_admin_accounts_on_username", unique: true
   end
 
+  create_table "billing_club_quotes", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
+    t.uuid "club_id", null: false
+    t.string "plan_slug", null: false
+    t.string "billing_interval", null: false
+    t.integer "amount_cents", null: false
+    t.string "currency", default: "eur", null: false
+    t.string "note"
+    t.boolean "active", default: true, null: false
+    t.uuid "created_by_admin_id"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["club_id"], name: "index_billing_club_quotes_active_club", unique: true, where: "(active = true)"
+    t.index ["created_by_admin_id"], name: "index_billing_club_quotes_on_created_by_admin_id"
+  end
+
   create_table "billing_invoices", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
     t.uuid "club_id", null: false
     t.uuid "billing_payment_id"
@@ -87,11 +102,40 @@ ActiveRecord::Schema[7.2].define(version: 2026_08_13_184100) do
     t.string "receipt_url"
     t.datetime "created_at", null: false
     t.datetime "updated_at", null: false
+    t.string "provider", default: "stripe", null: false
     t.index ["club_id", "paid_at"], name: "index_billing_payments_on_club_id_and_paid_at"
     t.index ["club_id"], name: "index_billing_payments_on_club_id"
+    t.index ["provider"], name: "index_billing_payments_on_provider"
     t.index ["stripe_invoice_id"], name: "index_billing_payments_on_stripe_invoice_id", unique: true, where: "(stripe_invoice_id IS NOT NULL)"
   end
 
+  create_table "billing_transfer_orders", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
+    t.uuid "club_id", null: false
+    t.uuid "billing_club_quote_id"
+    t.uuid "billing_payment_id"
+    t.string "plan_slug", null: false
+    t.string "billing_interval", null: false
+    t.integer "amount_cents", null: false
+    t.string "currency", default: "eur", null: false
+    t.string "kind", null: false
+    t.string "status", default: "awaiting_payment", null: false
+    t.string "reference_code", null: false
+    t.uuid "requested_by_user_id"
+    t.uuid "confirmed_by_admin_id"
+    t.datetime "confirmed_at"
+    t.datetime "cancelled_at"
+    t.datetime "created_at", null: false
+    t.datetime "updated_at", null: false
+    t.index ["billing_club_quote_id"], name: "index_billing_transfer_orders_on_billing_club_quote_id"
+    t.index ["billing_payment_id"], name: "index_billing_transfer_orders_on_billing_payment_id"
+    t.index ["club_id"], name: "index_billing_transfer_orders_awaiting_club", unique: true, where: "((status)::text = 'awaiting_payment'::text)"
+    t.index ["club_id"], name: "index_billing_transfer_orders_on_club_id"
+    t.index ["confirmed_by_admin_id"], name: "index_billing_transfer_orders_on_confirmed_by_admin_id"
+    t.index ["reference_code"], name: "index_billing_transfer_orders_on_reference_code", unique: true
+    t.index ["requested_by_user_id"], name: "index_billing_transfer_orders_on_requested_by_user_id"
+    t.index ["status"], name: "index_billing_transfer_orders_on_status"
+  end
+
   create_table "club_memberships", id: :uuid, default: -> { "gen_random_uuid()" }, force: :cascade do |t|
     t.uuid "user_id", null: false
     t.uuid "club_id", null: false
@@ -427,9 +471,16 @@ ActiveRecord::Schema[7.2].define(version: 2026_08_13_184100) do
 
   add_foreign_key "active_storage_attachments", "active_storage_blobs", column: "blob_id"
   add_foreign_key "active_storage_variant_records", "active_storage_blobs", column: "blob_id"
+  add_foreign_key "billing_club_quotes", "admin_accounts", column: "created_by_admin_id"
+  add_foreign_key "billing_club_quotes", "clubs"
   add_foreign_key "billing_invoices", "billing_payments"
   add_foreign_key "billing_invoices", "clubs"
   add_foreign_key "billing_payments", "clubs"
+  add_foreign_key "billing_transfer_orders", "admin_accounts", column: "confirmed_by_admin_id"
+  add_foreign_key "billing_transfer_orders", "billing_club_quotes"
+  add_foreign_key "billing_transfer_orders", "billing_payments"
+  add_foreign_key "billing_transfer_orders", "clubs"
+  add_foreign_key "billing_transfer_orders", "users", column: "requested_by_user_id"
   add_foreign_key "club_memberships", "clubs"
   add_foreign_key "club_memberships", "users"
   add_foreign_key "device_states", "stream_sessions"

backend/db/seeds/plans.rb

@@ -44,7 +44,8 @@ seed_plan!("premium_full", "Premium Full", {
   "recording_days" => 90,
   "phone_download_enabled" => true,
   "youtube_enabled" => true,
-  "youtube_mode" => "team"
+  "youtube_mode" => "team",
+  "custom_cover" => true
 }, stripe_price_id: ENV["STRIPE_PREMIUM_FULL_PRICE_ID"].presence || ENV["STRIPE_PREMIUM_PRICE_ID"].presence)
 
 Subscription.joins(:plan).where(plans: { slug: "premium_full" }).find_each do |sub|

backend/public/confirm-forms.js

@@ -147,12 +147,13 @@
     var hasSite = options.hasSite !== false;
     var hasYoutube = !!options.hasYoutube;
     var isDelete = !!options.isDelete;
+    var isReplayDelete = !!options.isReplayDelete;
     var canSite = hasSite;
     var canYoutube = hasYoutube;
     var canBoth = hasSite && hasYoutube;
     var choiceCount = (canSite ? 1 : 0) + (canYoutube ? 1 : 0) + (canBoth ? 1 : 0);
     // Una sola destinazione disponibile → conferma semplice, senza elenco
-    var multi = !!options.multi && choiceCount > 1;
+    var multi = isReplayDelete && choiceCount > 1;
 
     if (canBoth) pendingScope = "both";
     else if (canSite) pendingScope = "site";
@@ -175,9 +176,9 @@
     if (titleEl) {
       if (multi) {
         titleEl.textContent = I18N.multiDeleteTitle;
-      } else if (pendingScope === "youtube") {
+      } else if (isReplayDelete && pendingScope === "youtube") {
         titleEl.textContent = I18N.deleteYoutubeTitle;
-      } else if (pendingScope === "site") {
+      } else if (isReplayDelete && pendingScope === "site") {
         titleEl.textContent = I18N.deleteSiteTitle;
       } else {
         titleEl.textContent = isDelete ? I18N.deleteTitle : I18N.title;
@@ -187,9 +188,9 @@
     if (messageEl) {
       if (multi) {
         messageEl.textContent = I18N.multiDeleteMessage;
-      } else if (pendingScope === "youtube") {
+      } else if (isReplayDelete && pendingScope === "youtube") {
         messageEl.textContent = I18N.deleteYoutubeMessage;
-      } else if (pendingScope === "site") {
+      } else if (isReplayDelete && pendingScope === "site") {
         messageEl.textContent = hasYoutube
           ? I18N.deleteSiteMessageWithYoutube
           : I18N.deleteSiteMessageOnly;
@@ -203,8 +204,8 @@
 
     if (okBtn instanceof HTMLElement) {
       okBtn.hidden = multi;
-      if (pendingScope === "youtube") okBtn.textContent = I18N.deleteYoutubeOk;
+      if (isReplayDelete && pendingScope === "youtube") okBtn.textContent = I18N.deleteYoutubeOk;
-      else if (pendingScope === "site") okBtn.textContent = I18N.deleteSiteOk;
+      else if (isReplayDelete && pendingScope === "site") okBtn.textContent = I18N.deleteSiteOk;
       else okBtn.textContent = isDelete ? I18N.deleteOk : I18N.confirmOk;
     }
 
@@ -302,12 +303,14 @@
         form.getAttribute("data-has-youtube") === "1" ||
         mode === "delete-replay-youtube";
       var hasSiteAttr = form.getAttribute("data-has-site");
-      var hasSite = hasSiteAttr == null ? true : hasSiteAttr === "1";
+      var hasSite = isReplayDelete
+        ? hasSiteAttr == null || hasSiteAttr === "1"
+        : hasSiteAttr === "1";
       var isDelete =
         form.getAttribute("data-confirm-kind") === "delete" || isReplayDelete;
 
       openDialog(message, {
-        multi: isReplayDelete,
+        isReplayDelete: isReplayDelete,
         hasYoutube: hasYoutube,
         hasSite: hasSite,
         isDelete: isDelete

backend/public/marketing.css

@@ -449,7 +449,25 @@ body.nav-menu-open { overflow: hidden; }
   border-radius: 10px;
   object-fit: contain;
 }
-.branding-logo-preview__placeholder { color: #777; font-size: 0.88rem; text-align: center; }
+.branding-cover-preview {
+  min-height: 140px;
+}
+.branding-cover-preview__img {
+  max-width: 100%;
+  max-height: 180px;
+  width: auto;
+  height: auto;
+  border-radius: 8px;
+  object-fit: contain;
+}
+.cover-remove-label {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-top: 10px;
+  font-size: 0.9rem;
+  color: #aaa;
+}
 .branding-file-input { margin-bottom: 0 !important; }
 .branding-url-input { margin-bottom: 14px; }
 .branding-color-row {

backend/public/regia.js

@@ -33,6 +33,18 @@
     muteError: "Errore silenziamento audio",
     closeError: "Errore chiusura",
     closeConfirm: "Chiudere definitivamente la diretta?",
+    pauseConfirmTitle: "Mettere in pausa?",
+    pauseConfirmBody: "La diretta passerà alla copertina finché non la riprendi.",
+    resumeConfirmTitle: "Riprendere la diretta?",
+    resumeConfirmBody: "La telecamera tornerà in onda al posto della copertina.",
+    muteConfirmTitle: "Silenziare l'audio?",
+    muteConfirmBody: "Il microfono non verrà inviato allo stream finché non lo riattivi.",
+    unmuteConfirmTitle: "Riattivare l'audio?",
+    unmuteConfirmBody: "Il microfono tornerà attivo sullo stream.",
+    advancePeriodTitle: "Passare al periodo successivo?",
+    advancePeriodBody: "Il tabellone passerà al periodo successivo e il punteggio del periodo corrente sarà salvato.",
+    confirmAction: "Conferma",
+    stopConfirmTitle: "Terminare la diretta?",
     linkUnavailable: "Link non disponibile",
     linkCopied: "Link copiato",
     copyPrompt: "Copia il link:",
@@ -389,13 +401,18 @@
       if (cfg.board === "volley" || cfg.board === "racket") {
         if (data.set_won && action !== "close_set") {
           const winner = data.winner === "home" ? cfg.homeName : cfg.awayName;
-          openModal(I18N.setWonTitle, fillTemplate(I18N.setWonBodyTemplate, { winner }), () => postScore("close_set"));
+          openModal(I18N.setWonTitle, fillTemplate(I18N.setWonBodyTemplate, { winner }), () => postScore("close_set"), I18N.closeSetTitle);
         }
       }
-      if (data.match_won) {
+        if (data.match_won) {
-        const winner = data.winner === "home" ? cfg.homeName : cfg.awayName;
+          const winner = data.winner === "home" ? cfg.homeName : cfg.awayName;
-        openModal(I18N.matchWonTitle, fillTemplate(I18N.matchWonBodyTemplate, { winner }), () => stopStream());
+          openModal(
-      }
+            I18N.matchWonTitle,
+            fillTemplate(I18N.matchWonBodyTemplate, { winner }),
+            () => performStopStream(),
+            I18N.confirmAction
+          );
+        }
     } catch (e) {
       if (prevHome != null && els.homePoints) els.homePoints.textContent = prevHome;
       const awayEl = document.getElementById("away-points");
@@ -406,9 +423,12 @@
     }
   }
 
-  function openModal(title, body, onConfirm) {
+  function openModal(title, body, onConfirm, confirmLabel) {
     els.modalTitle.textContent = title;
     els.modalBody.textContent = body;
+    if (els.modalConfirm) {
+      els.modalConfirm.textContent = confirmLabel || I18N.confirmAction;
+    }
     els.modal.classList.add("open");
     pendingAction = onConfirm;
   }
@@ -440,7 +460,9 @@
     btn.addEventListener("click", () => {
       const action = btn.dataset.action;
       if (action === "close_set") {
-        openModal(I18N.closeSetTitle, I18N.closeSetConfirm, () => postScore("close_set"));
+        openModal(I18N.closeSetTitle, I18N.closeSetConfirm, () => postScore("close_set"), I18N.closeSetTitle);
+      } else if (action === "advance_period") {
+        openModal(I18N.advancePeriodTitle, I18N.advancePeriodBody, () => handleAction("advance_period"));
       } else {
         handleAction(action);
       }
@@ -689,9 +711,8 @@
     toast(audioMuted ? I18N.muted : I18N.unmuted);
   }
 
-  async function stopStream() {
+  async function performStopStream() {
-    const ok = confirm(I18N.closeConfirm);
+    if (!cfg.stopUrl) return null;
-    if (!ok) return null;
     const res = await fetch(cfg.stopUrl, { method: "POST", headers: { Accept: "application/json" } });
     if (!res.ok) throw new Error(I18N.closeError);
     const data = await res.json();
@@ -701,9 +722,47 @@
     return data;
   }
 
-  els.btnPause?.addEventListener("click", () => togglePauseStream().catch((e) => toast(e.message)));
+  function requestStopStream() {
-  els.btnAudioMute?.addEventListener("click", () => toggleMuteAudio().catch((e) => toast(e.message)));
+    openModal(I18N.stopConfirmTitle, I18N.closeConfirm, () => performStopStream(), I18N.confirmAction);
-  document.getElementById("btn-stop")?.addEventListener("click", () => stopStream().catch((e) => toast(e.message)));
+  }
+
+  function requestPauseToggle() {
+    if (streamPaused) {
+      openModal(I18N.resumeConfirmTitle, I18N.resumeConfirmBody, async () => {
+        await togglePauseStream();
+        return null;
+      });
+    } else {
+      openModal(I18N.pauseConfirmTitle, I18N.pauseConfirmBody, async () => {
+        await togglePauseStream();
+        return null;
+      });
+    }
+  }
+
+  function requestMuteToggle() {
+    if (audioMuted) {
+      openModal(I18N.unmuteConfirmTitle, I18N.unmuteConfirmBody, async () => {
+        await toggleMuteAudio();
+        return null;
+      });
+    } else {
+      openModal(I18N.muteConfirmTitle, I18N.muteConfirmBody, async () => {
+        await toggleMuteAudio();
+        return null;
+      });
+    }
+  }
+
+  async function stopStream() {
+    // Compatibilità: conferma via modal (non window.confirm).
+    requestStopStream();
+    return null;
+  }
+
+  els.btnPause?.addEventListener("click", () => requestPauseToggle());
+  els.btnAudioMute?.addEventListener("click", () => requestMuteToggle());
+  document.getElementById("btn-stop")?.addEventListener("click", () => requestStopStream());
 
   let minQualityBusy = false;
 

backend/spec/helpers/public/billing_helper_spec.rb

@@ -76,4 +76,72 @@ RSpec.describe Public::BillingHelper, type: :helper do
     )
     expect(action[:kind]).to eq(:none)
   end
+
+  it "con prezzo concordato non pagato resta sul bonifico" do
+    quote = instance_double(Billing::ClubQuote, plan_slug: "premium_full", price_label: "€99/anno", billing_interval: "yearly")
+    club = instance_double(Club, active_billing_quote: quote)
+    subscription = instance_double(
+      Subscription,
+      active?: true,
+      premium?: false,
+      plan_change_pending?: false,
+      plan: Plan["free"]
+    )
+
+    action = helper.plan_billing_action(
+      current_slug: "free",
+      target_plan: premium_full,
+      stripe_subscription_active: false,
+      subscription: subscription,
+      club: club
+    )
+    expect(action[:kind]).to eq(:quoted)
+    expect(action[:quote]).to eq(quote)
+  end
+
+  it "con prezzo concordato già pagato mostra il piano attivo" do
+    quote = instance_double(Billing::ClubQuote, plan_slug: "premium_full", price_label: "€99/anno")
+    club = instance_double(Club, active_billing_quote: quote)
+    subscription = instance_double(
+      Subscription,
+      active?: true,
+      premium?: true,
+      plan_change_pending?: false,
+      plan: premium_full,
+      billing_interval: "yearly"
+    )
+
+    action = helper.plan_billing_action(
+      current_slug: "premium_full",
+      target_plan: premium_full,
+      stripe_subscription_active: false,
+      current_interval: "yearly",
+      subscription: subscription,
+      club: club
+    )
+    expect(action[:kind]).to eq(:current)
+    expect(action[:label]).to include("Piano attivo")
+    expect(action[:label]).to include("€99/anno")
+  end
+
+  it "con bonifico già attivo senza Stripe mostra il piano corrente" do
+    subscription = instance_double(
+      Subscription,
+      active?: true,
+      premium?: true,
+      plan_change_pending?: false,
+      plan: premium_full,
+      billing_interval: "yearly"
+    )
+
+    action = helper.plan_billing_action(
+      current_slug: "premium_full",
+      target_plan: premium_full,
+      stripe_subscription_active: false,
+      current_interval: "yearly",
+      subscription: subscription
+    )
+    expect(action[:kind]).to eq(:current)
+    expect(action[:label]).to include("Piano attivo")
+  end
 end

backend/spec/jobs/expire_ended_subscriptions_job_spec.rb

@@ -0,0 +1,27 @@
+require "rails_helper"
+
+RSpec.describe ExpireEndedSubscriptionsJob do
+  let(:club) do
+    c = Club.create!(name: "Expire BT", sport: "volleyball", primary_color: "#e53935", secondary_color: "#ffffff")
+    load Rails.root.join("db/seeds/plans.rb")
+    c
+  end
+
+  it "passa a Free un piano pagato con bonifico scaduto" do
+    Billing::AssignPlan.call(
+      club: club,
+      plan_slug: "premium_light",
+      status: "active",
+      stripe_attrs: {
+        billing_interval: "monthly",
+        current_period_start: 2.months.ago,
+        current_period_end: 1.day.ago,
+        cancel_at_period_end: true
+      }
+    )
+
+    described_class.new.perform
+
+    expect(club.reload.subscription.plan.slug).to eq("free")
+  end
+end

backend/spec/jobs/generate_cover_slate_job_spec.rb

@@ -0,0 +1,34 @@
+require "rails_helper"
+
+RSpec.describe GenerateCoverSlateJob do
+  let!(:club) { Club.create!(name: "Club", sport: "volleyball", primary_color: "#e53935", secondary_color: "#ffffff") }
+  let!(:team) { club.teams.create!(name: "Team", sport: "volleyball") }
+  let!(:match) { team.matches.create!(opponent_name: "Opp", sport: "volleyball") }
+
+  before do
+    load Rails.root.join("db/seeds/plans.rb")
+    match.cover_image.attach(
+      io: StringIO.new("img"),
+      filename: "c.png",
+      content_type: "image/png"
+    )
+  end
+
+  it "usa coda critical per Match" do
+    expect(described_class).to receive(:set).with(queue: :critical).and_return(described_class)
+    expect(described_class).to receive(:perform_later).with("Match", match.id)
+    described_class.enqueue_for(match)
+  end
+
+  it "usa coda default per Club" do
+    club.cover_image.attach(io: StringIO.new("img"), filename: "c.png", content_type: "image/png")
+    expect(described_class).to receive(:set).with(queue: :default).and_return(described_class)
+    expect(described_class).to receive(:perform_later).with("Club", club.id)
+    described_class.enqueue_for(club)
+  end
+
+  it "invoca GenerateCoverSlate al perform" do
+    expect(Streams::GenerateCoverSlate).to receive(:call).with(match)
+    described_class.perform_now("Match", match.id)
+  end
+end

backend/spec/models/match_scheduling_spec.rb

@@ -5,7 +5,7 @@ RSpec.describe Match, "scheduling scopes" do
     Club.create!(name: "Sched Club", sport: "volleyball", primary_color: "#e53935", secondary_color: "#ffffff")
   end
   let!(:team) { club.teams.create!(name: "U16", sport: "volleyball") }
-  let!(:user) { User.create!(email: "coach@test.com", name: "Coach", password: "password123", role: "coach") }
+  let!(:user) { User.create!(email: "coach@test.com", name: "Coach", password: "Password123", role: "coach") }
 
   it "scheduled_for_live esclude partite già passate oggi" do
     past = team.matches.create!(opponent_name: "Past", scheduled_at: 2.hours.ago, sets_to_win: 3)