Add Bootcamp

app/commands/bootcamp/select_next_exercise.rb

@@ -0,0 +1,28 @@
+class Bootcamp::SelectNextExercise
+  include Mandate
+
+  initialize_with :user, project: nil
+
+  def call
+    return next_user_project_exercise if next_user_project_exercise
+
+    Bootcamp::Exercise.unlocked.where.not(project: user.bootcamp_projects).
+      where.not(id: completed_exercise_ids).first
+  end
+
+  def user_project
+    if project
+      user_project = Bootcamp::UserProject.for!(user, project)
+      return user_project if user_project.available?
+    end
+
+    user.bootcamp_user_projects.where(status: :available).first
+  end
+
+  memoize
+  def next_user_project_exercise = user_project&.next_exercise
+
+  def completed_exercise_ids
+    user.bootcamp_solutions.where.not(completed_at: nil).select(:exercise_id)
+  end
+end

app/commands/bootcamp/solution/complete.rb

@@ -0,0 +1,23 @@
+class Bootcamp::Solution::Complete
+  include Mandate
+
+  initialize_with :solution
+
+  def call
+    # It's essential that both of these lines are called
+    # inline to ensure next exercise selection is correct
+    solution.update!(completed_at: Time.current)
+    Bootcamp::UserProject::UpdateStatus.(user_project)
+
+    schedule_deferred_jobs!
+  end
+
+  private
+  def schedule_deferred_jobs!
+    Bootcamp::UpdateUserLevel.defer(user)
+  end
+
+  def user_project = Bootcamp::UserProject.for!(user, project)
+
+  delegate :user, :project, to: :solution
+end

app/commands/bootcamp/solution/create.rb

@@ -0,0 +1,43 @@
+class Bootcamp::Solution::Create
+  include Mandate
+
+  initialize_with :user, :exercise
+
+  def call
+    guard!
+
+    begin
+      Bootcamp::Solution.create!(
+        user:,
+        exercise:,
+        code:
+      )
+    rescue ActiveRecord::RecordNotUnique
+      Bootcamp::Solution.find_by!(
+        user:,
+        exercise:
+      )
+    end
+  end
+
+  private
+  def guard!
+    raise ExerciseLockedError unless user_project.exercise_available?(exercise)
+  end
+
+  def code
+    exercise.stub.gsub(Regexp.new("{{EXERCISE_([-a-z0-9]+)}}")) do
+      previous_solutions[::Regexp.last_match(1)].code
+    end
+  end
+
+  # This is used for the code interpolation, only if actually required.
+  memoize
+  def previous_solutions
+    user_project.solutions.index_by { |s| s.exercise.slug }
+  end
+
+  def user_project
+    Bootcamp::UserProject.find_by!(user:, project: exercise.project)
+  end
+end

app/commands/bootcamp/submission/create.rb

@@ -0,0 +1,27 @@
+class Bootcamp::Submission::Create
+  include Mandate
+
+  initialize_with :solution, :code, :test_results, :readonly_ranges
+
+  def call
+    create_submission.tap do |submission|
+      fire_events!(submission)
+    end
+  end
+
+  private
+  def create_submission
+    Bootcamp::Submission.create!(
+      solution:,
+      code:,
+      test_results: test_results.to_h,
+      readonly_ranges: readonly_ranges || []
+    )
+  end
+
+  def fire_events!(_submission)
+    nil # TODO: Implement this
+    # if submission.passed?
+    # end
+  end
+end

app/commands/bootcamp/update_user_level.rb

@@ -0,0 +1,30 @@
+class Bootcamp::UpdateUserLevel
+  include Mandate
+
+  initialize_with :user
+
+  def call
+    max = 0
+    exercise_ids_by_level_idx.each do |level_idx, exercise_ids|
+      next if level_idx < max
+      break unless solved_exercise_ids_by_level_idx[level_idx] == exercise_ids
+
+      max = level_idx
+    end
+    user.bootcamp_data.update!(level_idx: max)
+  end
+
+  memoize
+  def exercise_ids_by_level_idx
+    Bootcamp::Exercise.pluck(:level_idx, :id).
+      group_by(&:first).
+      transform_values { |v| v.map(&:last) }.
+      sort.to_h
+  end
+
+  def solved_exercise_ids_by_level_idx
+    user.bootcamp_solutions.completed.joins(:exercise).pluck(:level_idx, :exercise_id).
+      group_by(&:first).
+      transform_values { |v| v.map(&:last) }
+  end
+end

app/commands/bootcamp/user_project/create.rb

@@ -0,0 +1,19 @@
+class Bootcamp::UserProject::Create
+  include Mandate
+
+  initialize_with :user, :project
+
+  def call
+    Bootcamp::Project.find_each do |_project|
+      find_or_create.tap do |up|
+        Bootcamp::UserProject::UpdateStatus.(up)
+      end
+    end
+  end
+
+  def find_or_create
+    Bootcamp::UserProject.create!(user:, project:)
+  rescue StandardError
+    Bootcamp::UserProject.find_by!(user:, project:)
+  end
+end

app/commands/bootcamp/user_project/create_all.rb

@@ -0,0 +1,11 @@
+class Bootcamp::UserProject::CreateAll
+  include Mandate
+
+  initialize_with :user
+
+  def call
+    Bootcamp::Project.find_each do |project|
+      Bootcamp::UserProject::Create.defer(user, project)
+    end
+  end
+end

app/commands/bootcamp/user_project/update_status.rb

@@ -0,0 +1,29 @@
+class Bootcamp::UserProject::UpdateStatus
+  include Mandate
+
+  initialize_with :user_project
+
+  def call
+    user_project.update!(status:)
+  end
+
+  def status
+    return :available if user_project.solutions.any?(&:in_progress?)
+
+    num_unlocked_exercises = user_project.unlocked_exercises.count
+    num_solutions = user_project.solutions.count
+
+    # If there are no unlocked exercises, the project is locked
+    return :locked if num_unlocked_exercises.zero?
+
+    # If all solutions have an exercise and they're all complete, the project is complete
+    return :completed if num_solutions == num_unlocked_exercises &&
+                         user_project.solutions.all?(&:completed?)
+
+    # If we have more exercises than solutions, then there's a new solution
+    # that can be created if the user wants to.
+    return :available if num_unlocked_exercises > num_solutions
+
+    :locked
+  end
+end

app/commands/document/sync_all_to_search_index.rb

@@ -19,6 +19,7 @@ def call
       end
 
       Exercism.opensearch_client.bulk(body:)
+      Exercism::TOUCHED_OPENSEARCH_INDEXES << Document::OPENSEARCH_INDEX if Rails.env.test?
     end
   end
 

app/commands/document/sync_to_search_index.rb

@@ -11,5 +11,6 @@ def call
       id: doc.id,
       body: Document::CreateSearchIndexDocument.(doc)
     )
+    Exercism::TOUCHED_OPENSEARCH_INDEXES << Document::OPENSEARCH_INDEX if Rails.env.test?
   end
 end

app/commands/exercise/representation/sync_to_search_index.rb

@@ -27,6 +27,7 @@ def create_document!
       id: representation.id,
       body: Exercise::Representation::CreateSearchIndexDocument.(representation)
     )
+    Exercism::TOUCHED_OPENSEARCH_INDEXES << Exercise::Representation::OPENSEARCH_INDEX if Rails.env.test?
   end
 
   def delete_document!

app/commands/solution/sync_all_to_search_index.rb

@@ -25,6 +25,7 @@ def call
       end
 
       Exercism.opensearch_client.bulk(body:)
+      Exercism::TOUCHED_OPENSEARCH_INDEXES << Solution::OPENSEARCH_INDEX if Rails.env.test?
     end
   end
 

app/commands/solution/sync_to_search_index.rb

@@ -20,6 +20,7 @@ def create_document!
       id: solution.id,
       body: Solution::CreateSearchIndexDocument.(solution)
     )
+    Exercism::TOUCHED_OPENSEARCH_INDEXES << Solution::OPENSEARCH_INDEX if Rails.env.test?
   end
 
   def delete_document!

app/commands/user/bootstrap.rb

@@ -1,7 +1,7 @@
 class User::Bootstrap
   include Mandate
 
-  initialize_with :user
+  initialize_with :user, bootcamp_access_code: nil
 
   def call
     user.auth_tokens.create!
@@ -14,14 +14,10 @@ def call
 
   private
   def link_bootcamp_user!
-    ubd = User::BootcampData.find_by(email: user.email)
+    ubd = User::BootcampData.find_by(access_code: bootcamp_access_code) if bootcamp_access_code.present?
+    ubd ||= User::BootcampData.find_by(email: user.email)
     return unless ubd
 
-    ubd.update!(user:)
-    User::Bootcamp::SubscribeToOnboardingEmails.defer(ubd)
-
-    return unless ubd.paid?
-
-    user.update!(bootcamp_attendee: true)
+    User::LinkWithBootcampData.(user, ubd)
   end
 end

app/commands/user/link_with_bootcamp_data.rb

@@ -0,0 +1,33 @@
+class User::LinkWithBootcampData
+  include Mandate
+
+  initialize_with :user, :bootcamp_data
+
+  def call
+    return unless bootcamp_data
+
+    reset_current_user!
+    reset_old_user!
+    bootcamp_data.update!(user:)
+    User::Bootcamp::SubscribeToOnboardingEmails.defer(bootcamp_data)
+
+    return unless bootcamp_data.paid?
+
+    user.update!(bootcamp_attendee: true)
+  end
+
+  memoize
+
+  def reset_current_user!
+    existing_data = User::BootcampData.find_by(user:)
+    return unless existing_data
+
+    existing_data.update!(user: nil)
+  end
+
+  def reset_old_user!
+    return unless bootcamp_data.user
+
+    bootcamp_data.user.update!(bootcamp_attendee: false)
+  end
+end

app/controllers/api/bootcamp/base_controller.rb

@@ -0,0 +1,24 @@
+class API::Bootcamp::BaseController < API::BaseController
+  # TODO: Move this to a middleware that explodes this out
+  #  during the actual parameter parsing.
+  def params
+    raw = request.parameters
+    return raw unless request.content_type == "application/json"
+    return raw unless raw[:_json].present?
+
+    raw.merge!(JSON.parse(raw.delete(:_json)))
+    raw
+  end
+
+  def use_project
+    @project = Bootcamp::Project.find_by!(slug: params[:project_slug])
+  end
+
+  def use_exercise
+    @exercise = @project.exercises.find_by!(slug: params[:exercise_slug])
+  end
+
+  def use_solution
+    @solution = current_user.bootcamp_solutions.find_by!(uuid: params[:solution_uuid])
+  end
+end

app/controllers/api/bootcamp/solutions_controller.rb

@@ -0,0 +1,22 @@
+class API::Bootcamp::SolutionsController < API::Bootcamp::BaseController
+  before_action :use_solution
+
+  def complete
+    Bootcamp::Solution::Complete.(@solution)
+
+    next_exercise = Bootcamp::SelectNextExercise.(current_user, project: @solution.project)
+
+    render json: {
+      next_exercise: SerializeBootcampExercise.(next_exercise)
+    }, status: :ok
+  end
+
+  private
+  def use_solution
+    @solution = current_user.bootcamp_solutions.find_by!(uuid: params[:uuid])
+  end
+
+  def user_project
+    Bootcamp::UserProject.find_by!(user: solution.user, project: solution.exercise.project)
+  end
+end

app/controllers/api/bootcamp/submissions_controller.rb

@@ -0,0 +1,17 @@
+class API::Bootcamp::SubmissionsController < API::Bootcamp::BaseController
+  before_action :use_solution
+
+  def create
+    submission = Bootcamp::Submission::Create.(
+      @solution,
+      params[:submission][:code],
+      params[:submission][:test_results].to_h,
+      params[:submission][:readonly_ranges]
+    )
+    render json: {
+      submission: {
+        uuid: submission.uuid
+      }
+    }, status: :created
+  end
+end