Add bulk lesson creation via lesson_projects

Expand the LessonsController#create to accept a lesson_projects array in the request body and create multiple lessons in one request.

Add bulk_create_params to the LessonsController, permitting origin_identifier on each entry so the caller can correlate responses with the original projects.

Add Lesson::CreateBulk to create individual Lessons and echo origin_identifier on each result.

Author: PetarSimonovic

app/controllers/api/lessons_controller.rb

@@ -30,13 +30,20 @@ def show
     end
 
     def create
-      result = Lesson::Create.call(lesson_params: create_params)
-
-      if result.success?
-        @lesson_with_user = result[:lesson].with_user
-        render :show, formats: [:json], status: :created
+      if params[:lesson_projects].present?
+        @results = Lesson::CreateBulk.call(
+          lessons_params: params[:lesson_projects].map { |entry| bulk_create_params(entry) }
+        )
+        @user = current_user
+        render :create_bulk, formats: [:json], status: :created
       else
-        render json: { error: result[:error] }, status: :unprocessable_content
+        result = Lesson::Create.call(lesson_params: create_params)
+        if result.success?
+          @lesson_with_user = result[:lesson].with_user
+          render :show, formats: [:json], status: :created
+        else
+          render json: { error: result[:error] }, status: :unprocessable_content
+        end
       end
     end
 
@@ -78,14 +85,39 @@ def filtered_lessons_scope
     end
 
     def verify_school_class_belongs_to_school
-      return if create_params[:school_class_id].blank?
-      return if school&.classes&.pluck(:id)&.include?(create_params[:school_class_id])
+      if params[:lesson_projects].present?
+        params[:lesson_projects].each { |lesson_params| verify_lesson_school_class!(lesson_params) }
+      else
+        verify_lesson_school_class!(create_params)
+      end
+    end
+
+    def verify_lesson_school_class!(lesson_params)
+      school_class_id = lesson_params[:school_class_id]
+      return if school_class_id.blank?
+
+      school = School.find_by(id: lesson_params[:school_id])
+      return if school&.classes&.exists?(id: school_class_id)
 
       raise ParameterError, 'school_class_id does not correspond to school_id'
     end
 
     def verify_can_create_scratch_projects
-      return unless scratch_project? && !school.scratch_enabled?
+      if params[:lesson_projects].present?
+        scratch_project_params = params[:lesson_projects].find { |lesson_params| scratch_project?(lesson_params) }
+        return unless scratch_project_params
+
+        verify_lesson_scratch!(scratch_project_params)
+      else
+        verify_lesson_scratch!(create_params)
+      end
+    end
+
+    def verify_lesson_scratch!(lesson_params)
+      return unless scratch_project?(lesson_params)
+
+      school = School.find_by(id: lesson_params[:school_id])
+      return if school&.scratch_enabled?
 
       render json: { error: 'Forbidden' }, status: :forbidden
     end
@@ -104,8 +136,8 @@ def user_remix(lesson)
       )
     end
 
-    def scratch_project?
-      create_params.dig(:project_attributes, :project_type) == Project::Types::CODE_EDITOR_SCRATCH
+    def scratch_project?(lesson_params)
+      lesson_params.dig(:project_attributes, :project_type) == Project::Types::CODE_EDITOR_SCRATCH
     end
 
     def update_params
@@ -118,6 +150,27 @@ def update_params
       )
     end
 
+    def bulk_create_params(lesson_project)
+      lesson_project.permit(
+        :school_id,
+        :school_class_id,
+        :name,
+        :description,
+        :visibility,
+        :due_date,
+        :origin_identifier,
+        {
+          project_attributes: [
+            :name,
+            :project_type,
+            :locale,
+            { components: %i[id name extension content index default] },
+            { scratch_component: {} }
+          ]
+        }
+      ).merge(user_id: current_user.id)
+    end
+
     def create_params
       params.fetch(:lesson, {}).permit(
         :school_id,

app/views/api/lessons/create_bulk.json.jbuilder

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+json.array!(@results) do |result|
+  if result.success?
+    json.partial! 'lesson', lesson: result[:lesson], user: @user
+  else
+    json.error result[:error]
+  end
+
+  json.origin_identifier result[:origin_identifier] if result[:origin_identifier].present?
+end

lib/concepts/lesson/operations/create_bulk.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Lesson
+  class CreateBulk
+    class << self
+      def call(lessons_params:)
+        lessons_params.map { |lesson| create_one(lesson) }
+      end
+
+      private
+
+      def create_one(lesson_params)
+        origin_identifier = lesson_params[:origin_identifier]
+        Lesson::Create.call(lesson_params: lesson_params.except(:origin_identifier)).tap do |result|
+          result[:origin_identifier] = origin_identifier if origin_identifier.present?
+        end
+      end
+    end
+  end
+end

spec/concepts/lesson/create_bulk_spec.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Lesson::CreateBulk, type: :unit do
+  let(:school) { create(:school) }
+  let(:teacher) { create(:teacher, school:) }
+
+  let(:lessons_params) do
+    [
+      {
+        name: 'Test Lesson',
+        user_id: teacher.id,
+        school_id: school.id,
+        origin_identifier: 'test-lesson-identifier-one',
+        project_attributes: {
+          name: 'Hello world project',
+          project_type: Project::Types::PYTHON,
+          components: [
+            { name: 'main.py', extension: 'py', content: 'print("Hello, world!")' }
+          ]
+        }
+      },
+      {
+        name: 'Test Lesson 2',
+        user_id: teacher.id,
+        school_id: school.id,
+        origin_identifier: 'test-lesson-identifier-two',
+        project_attributes: {
+          name: 'Hello world project',
+          project_type: Project::Types::PYTHON,
+          components: [
+            { name: 'main.py', extension: 'py', content: 'print("Hello, world!")' }
+          ]
+        }
+      }
+    ]
+  end
+
+  context 'with a teacher' do
+    let(:result) { described_class.call(lessons_params:) }
+
+    before do
+      allow(User).to receive(:from_userinfo).with(ids: teacher.id).and_return([teacher])
+    end
+
+    it 'returns a successful operation response for the first lesson' do
+      expect(result.first.success?).to be(true)
+    end
+
+    it 'returns a successful operation response for the second lesson' do
+      expect(result.second.success?).to be(true)
+    end
+
+    it 'creates multiple lessons' do
+      expect { described_class.call(lessons_params:) }.to change(Lesson, :count).by(2)
+    end
+
+    it 'does not pass origin_identifier to lesson creation' do
+      received_params = []
+      allow(Lesson::Create).to receive(:call).and_wrap_original do |method, lesson_params:|
+        received_params << lesson_params
+        method.call(lesson_params:)
+      end
+
+      described_class.call(lessons_params:)
+
+      expect(received_params).to all(satisfy { |params| !params.key?(:origin_identifier) })
+    end
+
+    it 'appends the origin_identifier to the first created lesson' do
+      expect(result.first[:origin_identifier]).to eq('test-lesson-identifier-one')
+    end
+
+    it 'appends the origin_identifier to the second created lesson' do
+      expect(result.second[:origin_identifier]).to eq('test-lesson-identifier-two')
+    end
+  end
+end

spec/features/lesson/creating_a_lesson_spec.rb

@@ -118,6 +118,170 @@
     end
   end
 
+  context 'when bulk creating lessons via lesson_projects' do
+    before { school.update!(scratch_enabled: true) }
+
+    let(:lesson_project_params) do
+      [
+        {
+          name: 'Lesson 1',
+          school_id: school.id,
+          project_attributes: { name: 'Project 1', project_type: Project::Types::CODE_EDITOR_SCRATCH }
+        },
+        {
+          name: 'Lesson 2',
+          school_id: school.id,
+          project_attributes: { name: 'Project 2', project_type: Project::Types::CODE_EDITOR_SCRATCH }
+        }
+      ]
+    end
+
+    it 'responds 201 Created' do
+      post('/api/lessons', headers:, params: { lesson_projects: lesson_project_params })
+      expect(response).to have_http_status(:created)
+    end
+
+    it 'creates one lesson per entry' do
+      expect do
+        post('/api/lessons', headers:, params: { lesson_projects: lesson_project_params })
+      end.to change(Lesson, :count).by(2)
+    end
+
+    it 'responds with the same lesson JSON shape as a single create' do
+      post('/api/lessons', headers:, params: { lesson_projects: lesson_project_params })
+      data = JSON.parse(response.body, symbolize_names: true)
+
+      expect(data).to all(include(:id, :name, :user_name))
+      expect(data.pluck(:name)).to contain_exactly('Lesson 1', 'Lesson 2')
+    end
+
+    it 'omits origin_identifier when not supplied' do
+      post('/api/lessons', headers:, params: { lesson_projects: lesson_project_params })
+      data = JSON.parse(response.body, symbolize_names: true)
+
+      expect(data).to all(satisfy { |entry| !entry.key?(:origin_identifier) })
+    end
+
+    context 'when origin_identifier is supplied' do
+      let(:lesson_project_params) do
+        [
+          {
+            name: 'Lesson 1',
+            school_id: school.id,
+            origin_identifier: 'curriculum-project-one',
+            project_attributes: { name: 'Project 1', project_type: Project::Types::CODE_EDITOR_SCRATCH }
+          },
+          {
+            name: 'Lesson 2',
+            school_id: school.id,
+            origin_identifier: 'curriculum-project-two',
+            project_attributes: { name: 'Project 2', project_type: Project::Types::CODE_EDITOR_SCRATCH }
+          }
+        ]
+      end
+
+      it 'echoes origin_identifier on each successful entry' do
+        post('/api/lessons', headers:, params: { lesson_projects: lesson_project_params })
+        data = JSON.parse(response.body, symbolize_names: true)
+        expect(data.pluck(:origin_identifier)).to contain_exactly('curriculum-project-one', 'curriculum-project-two')
+      end
+    end
+
+    context 'when some entries are invalid' do
+      let(:invalid_lesson_project_params) do
+        lesson_project_params + [{
+          name: ' ',
+          school_id: school.id,
+          origin_identifier: 'curriculum-project-three',
+          project_attributes: { name: 'Project 3', project_type: Project::Types::CODE_EDITOR_SCRATCH }
+        }]
+      end
+
+      it 'responds 201 Created' do
+        post('/api/lessons', headers:, params: { lesson_projects: invalid_lesson_project_params })
+        expect(response).to have_http_status(:created)
+      end
+
+      it 'includes an error entry for the failed lesson' do
+        post('/api/lessons', headers:, params: { lesson_projects: invalid_lesson_project_params })
+        expect(response.parsed_body.any? { |entry| entry['error'].present? }).to be true
+      end
+
+      it 'still creates the valid lessons' do
+        expect do
+          post('/api/lessons', headers:, params: { lesson_projects: invalid_lesson_project_params })
+        end.to change(Lesson, :count).by(2)
+      end
+
+      it 'echoes origin_identifier on failed entries' do
+        post('/api/lessons', headers:, params: { lesson_projects: invalid_lesson_project_params })
+        error_entry = response.parsed_body.find { |entry| entry['error'].present? }
+
+        expect(error_entry['origin_identifier']).to eq('curriculum-project-three')
+      end
+    end
+
+    context 'when entries are associated with a school class' do
+      let(:school_class) { create(:school_class, teacher_ids: [teacher.id], school:) }
+      let(:lesson_project_params) do
+        [
+          {
+            name: 'Lesson 1',
+            school_id: school.id,
+            school_class_id: school_class.id,
+            project_attributes: { name: 'Project 1', project_type: Project::Types::CODE_EDITOR_SCRATCH }
+          },
+          {
+            name: 'Lesson 2',
+            school_id: school.id,
+            school_class_id: school_class.id,
+            project_attributes: { name: 'Project 2', project_type: Project::Types::CODE_EDITOR_SCRATCH }
+          }
+        ]
+      end
+
+      before do
+        authenticated_in_hydra_as(teacher)
+        school_class.update!(teachers: [ClassTeacher.new({ teacher_id: teacher.id })])
+      end
+
+      it 'responds 201 Created' do
+        post('/api/lessons', headers:, params: { lesson_projects: lesson_project_params })
+
+        expect(response).to have_http_status(:created)
+      end
+
+      it 'responds 422 Unprocessable if school_class_id does not correspond to school_id' do
+        mismatched_params = lesson_project_params.map { |entry| entry.merge(school_id: SecureRandom.uuid) }
+
+        post('/api/lessons', headers:, params: { lesson_projects: mismatched_params })
+
+        expect(response).to have_http_status(:unprocessable_content)
+      end
+
+      it 'does not create any lessons when school_class_id does not correspond to school_id' do
+        mismatched_params = lesson_project_params.map { |entry| entry.merge(school_id: SecureRandom.uuid) }
+
+        expect do
+          post('/api/lessons', headers:, params: { lesson_projects: mismatched_params })
+        end.not_to change(Lesson, :count)
+      end
+
+      it 'rejects the request when only one entry has a mismatched school_id' do
+        mismatched_params = [
+          lesson_project_params.first,
+          lesson_project_params.last.merge(school_id: SecureRandom.uuid)
+        ]
+
+        expect do
+          post('/api/lessons', headers:, params: { lesson_projects: mismatched_params })
+        end.not_to change(Lesson, :count)
+
+        expect(response).to have_http_status(:unprocessable_content)
+      end
+    end
+  end
+
   context 'when the lesson is associated with a school class' do
     let(:school_class) { create(:school_class, teacher_ids: [teacher.id], school:) }
     let(:school) { create(:school) }