Merge remote-tracking branch 'origin/main' into feature/court-street-in-picker

# Conflicts:
#	db/schema.rb

Author: denis1011101

app/controllers/games_controller.rb

@@ -5,6 +5,7 @@ class GamesController < ApplicationController
   before_action :set_game, only: %i[show edit update destroy toggle_urgent_player_search accept_coach_invitation decline_coach_invitation]
   before_action :authorize_manage_game!, only: %i[edit update destroy toggle_urgent_player_search]
   before_action :prepare_coaches, only: %i[new create edit update]
+  before_action :prepare_training_blocks, only: %i[new create edit update]
   skip_before_action :authenticate_user!, only: %i[index show]
 
   helper_method :display_date, :display_time, :game_badges
@@ -73,12 +74,16 @@ def new
   def create
     gp = sanitized_game_params
     @game = Game.new(gp.merge(user: current_user))
+    @new_training_blocks = build_inline_training_blocks
 
-    if @game.save
+    if inline_training_blocks_valid? && @game.save
+      save_inline_training_blocks
       @game.ensure_prebookings_for_next_weeks if @game.prebooking_enabled?
+      apply_training_plan
       coaches_awaiting_invitation.each { |coach| deliver_coach_invitation(coach) }
       redirect_to @game, notice: "Game was successfully created."
     else
+      @game.validate
       Rails.logger.warn "Game save failed: #{ @game.errors.full_messages.join('; ') }"
       render :new, status: :unprocessable_entity
     end
@@ -88,14 +93,19 @@ def edit
   end
 
   def update
-    gp = sanitized_game_params
-    if @game.update(gp)
+    @game.assign_attributes(sanitized_game_params)
+    @new_training_blocks = build_inline_training_blocks
+
+    if inline_training_blocks_valid? && @game.save
+      save_inline_training_blocks
       @game.ensure_prebookings_for_next_weeks if @game.prebooking_enabled?
+      apply_training_plan
       coaches_awaiting_invitation.each { |coach| deliver_coach_invitation(coach) }
       # The web form saves every field at once, so one message covers the whole edit.
       GameChangeNotifier.notify(game: @game, actor: current_user, changes: @game.saved_changes)
       redirect_to @game, notice: "Game was successfully updated."
     else
+      @game.validate
       Rails.logger.warn "Game update failed: #{ @game.errors.full_messages.join('; ') }"
       render :edit, status: :unprocessable_entity
     end
@@ -128,6 +138,18 @@ def toggle_urgent_player_search
     redirect_to @game, notice: "Players search #{state}."
   end
 
+  # GET /games/training_plan_fragment
+  # Библиотека зависит от выбранных тренеров, а выбирают их прямо в форме,
+  # поэтому список блоков перезагружаем без перезагрузки страницы.
+  def training_plan_fragment
+    owner_ids = ([ current_user.id ] + Array(params[:coach_ids]).map(&:to_i)).reject(&:zero?).uniq
+
+    render partial: "games/training_plan_library", locals: {
+      blocks: TrainingBlock.where(user_id: owner_ids).ordered,
+      selected_ids: Array(params[:training_block_ids]).map(&:to_i)
+    }
+  end
+
   # GET /games/prebooking_fragment
   def prebooking_fragment
     if params[:game_id].present?
@@ -153,6 +175,66 @@ def prepare_coaches
     @coaches = User.not_merged.where(coach: true).order(:name)
   end
 
+  # В форме показываем свою библиотеку и библиотеки тренеров этой тренировки:
+  # чужие блоки организатору ни к чему.
+  def prepare_training_blocks
+    @training_blocks = TrainingBlock.where(user_id: training_library_owner_ids).ordered
+  end
+
+  # Тренеров берём и из формы: на создании игры @game ещё нет, а библиотека
+  # выбранного тренера нужна уже там.
+  def training_library_owner_ids
+    submitted = [ params.dig(:game, :coach_id), params.dig(:game, :second_coach_id) ]
+
+    ([ current_user&.id ] + Array(@game&.assigned_coach_ids) + submitted).map(&:to_i).reject(&:zero?).uniq
+  end
+
+  def apply_training_plan
+    # План приходит только из формы игры, поэтому пустой запрос его не стирает.
+    return unless params[:game].respond_to?(:key?) && params[:game].key?(:training_block_ids)
+    return unless @game.training?
+
+    ids = training_plan_params[:ids] + @new_training_blocks.map(&:id)
+    # Блок из чужой библиотеки в план не попадает, даже если его id прислали в форме.
+    allowed_ids = TrainingBlock.where(id: ids, user_id: training_plan_owner_ids).pluck(:id)
+
+    @game.replace_training_plan!(ids.uniq.select { |id| allowed_ids.include?(id) })
+  end
+
+  def training_plan_params
+    raw = params.fetch(:game, ActionController::Parameters.new)
+    submitted = raw[:new_training_blocks]
+    submitted = submitted.values if submitted.respond_to?(:values)
+
+    @training_plan_params ||= {
+      ids: Array(raw[:training_block_ids]).map(&:to_i),
+      new_blocks: Array(submitted).filter_map { |block| block.permit(:title, :description, :duration_minutes) if block.respond_to?(:permit) }
+    }
+  end
+
+  # Блоки собираем до сохранения игры: иначе игра сохранится, а блок с опечаткой
+  # молча потеряется вместе со своим местом в плане.
+  def build_inline_training_blocks
+    return [] unless @game.training? || @game.with_coach?
+
+    training_plan_params[:new_blocks]
+      .reject { |attrs| attrs.values.all?(&:blank?) }
+      .uniq { |attrs| attrs[:title].to_s.strip.downcase }
+      .map { |attrs| TrainingBlock.build_for(current_user, attrs) }
+  end
+
+  def inline_training_blocks_valid?
+    @new_training_blocks.map(&:valid?).all?
+  end
+
+  def save_inline_training_blocks
+    @new_training_blocks.each(&:save!)
+  end
+
+  def training_plan_owner_ids
+    ([ current_user.id ] + @game.assigned_coach_ids).uniq
+  end
+
   # Приглашение уходит на смену слота, а не набора тренеров: если тренеров
   # поменять местами, модель сбросит оба статуса в pending, и по одному только
   # набору id никто бы приглашения не получил.

app/controllers/player_statistics_controller.rb

@@ -66,7 +66,8 @@ def create_for_game
         saved_any = true
       end
 
-      matches_input = matches_params
+      # На тренировке счёт не ведут, поэтому матчи из формы туда не попадают.
+      matches_input = game.training? ? [] : matches_params
       unbalanced_matches = 0
       matches_input.each do |m|
         team_a_ids = sanitize_team_ids(m[:team_a_user_ids], game)

app/controllers/training_blocks_controller.rb

@@ -0,0 +1,43 @@
+class TrainingBlocksController < ApplicationController
+  before_action :set_training_block, only: %i[update destroy]
+
+  def index
+    @training_block = TrainingBlock.new
+    @training_blocks = current_user.training_blocks.ordered
+  end
+
+  def create
+    @training_block = current_user.training_blocks.new(training_block_params)
+
+    if @training_block.save
+      redirect_to training_blocks_path, notice: t("training_blocks.created")
+    else
+      @training_blocks = current_user.training_blocks.ordered
+      render :index, status: :unprocessable_entity
+    end
+  end
+
+  def update
+    if @training_block.update(training_block_params)
+      redirect_to training_blocks_path, notice: t("training_blocks.updated")
+    else
+      redirect_to training_blocks_path, alert: @training_block.errors.full_messages.to_sentence
+    end
+  end
+
+  def destroy
+    @training_block.destroy
+    redirect_to training_blocks_path, notice: t("training_blocks.destroyed")
+  end
+
+  private
+
+  # Правку и удаление пускаем только по своей библиотеке.
+  def set_training_block
+    @training_block = current_user.training_blocks.find(params[:id])
+  end
+
+  def training_block_params
+    params.require(:training_block).permit(:title, :description, :duration_minutes)
+  end
+end

app/javascript/controllers/training_plan_controller.js

@@ -0,0 +1,111 @@
+import { Controller } from "@hotwired/stimulus"
+
+// Конструктор тренировки: отмеченные блоки держим сверху в порядке занятия —
+// именно этот порядок форма и отправляет. Новые блоки дозаписываются здесь же
+// и попадают в библиотеку вместе с сохранением игры.
+export default class extends Controller {
+  static targets = ["container", "template", "library", "row", "checkbox", "position", "moveControls", "coachSelect"]
+  static values = { nextIndex: Number, libraryUrl: String }
+
+  connect() {
+    this.renumber()
+  }
+
+  add(event) {
+    event.preventDefault()
+    const html = this.templateTarget.innerHTML.replaceAll("__INDEX__", this.nextIndexValue)
+    this.containerTarget.insertAdjacentHTML("beforeend", html)
+    this.nextIndexValue++
+  }
+
+  remove(event) {
+    event.preventDefault()
+    const row = event.target.closest("[data-training-plan-row]")
+    if (row) row.remove()
+  }
+
+  reorder(event) {
+    const row = event.target.closest("[data-training-plan-block-row]")
+    if (row) this.moveToPlanEdge(row, event.target.checked)
+    this.renumber()
+  }
+
+  moveUp(event) {
+    event.preventDefault()
+    this.swap(event.target.closest("[data-training-plan-block-row]"), -1)
+  }
+
+  moveDown(event) {
+    event.preventDefault()
+    this.swap(event.target.closest("[data-training-plan-block-row]"), 1)
+  }
+
+  async reloadLibrary() {
+    if (!this.hasLibraryTarget || !this.libraryUrlValue) return
+
+    const params = new URLSearchParams()
+    this.coachSelectTargets.forEach((select) => { if (select.value) params.append("coach_ids[]", select.value) })
+    this.checkedRows().forEach((row) => params.append("training_block_ids[]", this.checkboxIn(row).value))
+
+    const response = await fetch(`${this.libraryUrlValue}?${params}`, {
+      headers: { Accept: "text/html" },
+      credentials: "same-origin"
+    })
+    if (!response.ok) return
+
+    this.libraryTarget.innerHTML = await response.text()
+    this.renumber()
+  }
+
+  // Отмеченный блок встаёт в конец плана, снятый — сразу под ним.
+  moveToPlanEdge(row, checked) {
+    const chosen = this.checkedRows().filter((candidate) => candidate !== row)
+    const last = chosen[chosen.length - 1]
+
+    if (checked && last) {
+      last.after(row)
+    } else if (checked) {
+      row.parentNode.prepend(row)
+    } else if (last) {
+      last.after(row)
+    }
+  }
+
+  swap(row, direction) {
+    if (!row) return
+
+    const chosen = this.checkedRows()
+    const index = chosen.indexOf(row)
+    const neighbour = chosen[index + direction]
+    if (index < 0 || !neighbour) return
+
+    if (direction < 0) {
+      neighbour.before(row)
+    } else {
+      neighbour.after(row)
+    }
+
+    this.renumber()
+  }
+
+  renumber() {
+    const chosen = this.checkedRows()
+
+    this.rowTargets.forEach((row) => {
+      const position = row.querySelector("[data-training-plan-target='position']")
+      const controls = row.querySelector("[data-training-plan-target='moveControls']")
+      const index = chosen.indexOf(row)
+
+      if (position) position.textContent = index < 0 ? "" : `${index + 1}.`
+      if (controls) controls.classList.toggle("invisible", index < 0)
+    })
+  }
+
+  checkedRows() {
+    return this.rowTargets.filter((row) => this.checkboxIn(row)?.checked)
+  }
+
+  checkboxIn(row) {
+    return row.querySelector("input[type=checkbox]")
+  }
+}

app/models/game.rb

@@ -1,6 +1,7 @@
 class Game < ApplicationRecord
   after_commit :schedule_post_game_stats_reminder, on: %i[create update]
   after_commit :enqueue_urgent_player_search_notification, on: %i[create update]
+  after_update :drop_training_plan_from_plain_game, if: -> { saved_change_to_kind? && !training? }
   after_update :remove_stale_coach_prebookings,
                if: -> { saved_change_to_coach_id? || saved_change_to_second_coach_id? || saved_change_to_date? || saved_change_to_recurring? }
 
@@ -19,6 +20,9 @@ class Game < ApplicationRecord
   has_many :featured_matches, dependent: :nullify
   has_many :player_statistic_entries, dependent: :nullify
   has_many :game_media, class_name: "GameMedium", dependent: :destroy
+  # План тренировки — блоки из библиотеки тренера в выбранном порядке.
+  has_many :game_training_blocks, -> { ordered }, dependent: :destroy, inverse_of: :game
+  has_many :training_blocks, through: :game_training_blocks
 
   SURFACES = Court::SURFACES
   KINDS = %w[game training].freeze
@@ -41,6 +45,7 @@ class Game < ApplicationRecord
   validates :coach_invitation_status, inclusion: { in: COACH_INVITATION_STATUSES }, allow_nil: true
   validates :second_coach_invitation_status, inclusion: { in: COACH_INVITATION_STATUSES }, allow_nil: true
   validate :selected_coaches_are_coaches
+  validate :training_cannot_hide_recorded_scores, if: -> { persisted? && training? && kind_changed? }
   validate :prebooking_requires_recurring
   validate :surface_available_at_court
   validate :environment_available_at_court
@@ -54,6 +59,23 @@ def coaches
     [ coach, second_coach ].compact
   end
 
+  # Порядок блоков задаёт сам список: он и есть план занятия.
+  def replace_training_plan!(block_ids)
+    block_ids = Array(block_ids).map(&:to_i).uniq.reject(&:zero?)
+
+    transaction do
+      game_training_blocks.where.not(training_block_id: block_ids).destroy_all
+      block_ids.each_with_index do |block_id, index|
+        entry = game_training_blocks.find_or_initialize_by(training_block_id: block_id)
+        entry.position = index
+        entry.save!
+      end
+    end
+
+    game_training_blocks.reset
+    training_blocks.reset
+  end
+
   def assigned_coach_ids
     [ coach_id, second_coach_id ].compact
   end
@@ -523,6 +545,17 @@ def normalize_invitation_status(slot)
     end
   end
 
+  def drop_training_plan_from_plain_game
+    # У обычной игры плана занятия не бывает, поэтому он уходит вместе с типом.
+    game_training_blocks.destroy_all
+  end
+
+  # Счёт у тренировки не показать и не исправить, поэтому игру с уже записанными
+  # матчами в тренировку не превращаем — иначе счёт остался бы висеть в статистике.
+  def training_cannot_hide_recorded_scores
+    errors.add(:kind, "cannot switch to training while the game has recorded scores") if matches.exists?
+  end
+
   def selected_coaches_are_coaches
     coaches.each do |candidate|
       errors.add(:coach, "must be a coach") unless candidate.coach?

app/models/game_training_block.rb

@@ -0,0 +1,8 @@
+class GameTrainingBlock < ApplicationRecord
+  belongs_to :game
+  belongs_to :training_block
+
+  validates :training_block_id, uniqueness: { scope: :game_id }
+
+  scope :ordered, -> { order(:position, :id) }
+end