Add School::ImportBatch operation to import a CSV of schools.

This operation parses and validates the CSV and reports on errors or
enqueues the job.

Author: fspeirs

lib/concepts/school/operations/import_batch.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+class School
+  class ImportBatch
+    class << self
+      def call(csv_file:, current_user:)
+        response = OperationResponse.new
+
+        parsed_schools = parse_csv(csv_file)
+
+        if parsed_schools[:error]
+          response[:error] = parsed_schools[:error]
+          return response
+        end
+
+        # Check for duplicate owner emails in the CSV
+        duplicate_check = check_duplicate_owners(parsed_schools[:schools])
+        if duplicate_check[:error]
+          response[:error] = duplicate_check[:error]
+          return response
+        end
+
+        job = enqueue_import_job(
+          schools_data: parsed_schools[:schools],
+          user_id: current_user.id
+        )
+
+        response[:job_id] = job.job_id
+        response[:total_schools] = parsed_schools[:schools].length
+        response
+      rescue StandardError => e
+        Sentry.capture_exception(e)
+        response ||= OperationResponse.new
+        response[:error] = SchoolImportError.format_error(:unknown_error, e.message)
+        response
+      end
+
+      private
+
+      def check_duplicate_owners(schools)
+        owner_emails = schools.filter_map { |s| s[:owner_email]&.strip&.downcase }
+        duplicates = owner_emails.select { |e| owner_emails.count(e) > 1 }.uniq
+
+        if duplicates.any?
+          error = SchoolImportError.format_error(
+            :duplicate_owner_email,
+            'Duplicate owner emails found in CSV',
+            { duplicate_emails: duplicates }
+          )
+          return { error: error }
+        end
+
+        {}
+      end
+
+      def parse_csv(csv_file)
+        require 'csv'
+
+        csv_content = csv_file.read
+        return { error: SchoolImportError.format_error(:csv_invalid_format, 'CSV file is empty') } if csv_content.blank?
+
+        csv_data = CSV.parse(csv_content, headers: true, header_converters: :symbol)
+
+        if csv_data.headers.nil? || !valid_headers?(csv_data.headers)
+          return {
+            error: SchoolImportError.format_error(
+              :csv_invalid_format,
+              'Invalid CSV format. Required headers: name, website, address_line_1, municipality, country_code, owner_email'
+            )
+          }
+        end
+
+        process_csv_rows(csv_data)
+      rescue CSV::MalformedCSVError => e
+        { error: SchoolImportError.format_error(:csv_malformed, "Invalid CSV file format: #{e.message}") }
+      rescue StandardError => e
+        Sentry.capture_exception(e)
+        { error: SchoolImportError.format_error(:unknown_error, "Failed to parse CSV: #{e.message}") }
+      end
+
+      def process_csv_rows(csv_data)
+        schools = []
+        errors = []
+
+        csv_data.each_with_index do |row, index|
+          row_number = index + 2 # +2 because index starts at 0 and we skip header row
+          school_data = row.to_h
+
+          validation_errors = validate_school_data(school_data, row_number)
+          if validation_errors
+            errors << validation_errors
+            next
+          end
+
+          schools << school_data
+        end
+
+        if errors.any?
+          { error: SchoolImportError.format_row_errors(errors) }
+        else
+          { schools: schools }
+        end
+      end
+
+      def valid_headers?(headers)
+        required = %i[name website address_line_1 municipality country_code owner_email]
+        required.all? { |h| headers.include?(h) }
+      end
+
+      def validate_school_data(data, row_number)
+        errors = []
+
+        # Strip whitespace from all string fields
+        data.each do |key, value|
+          data[key] = value.strip if value.is_a?(String)
+        end
+
+        # Validate required fields
+        required_fields = %i[name website address_line_1 municipality country_code owner_email]
+        required_fields.each do |field|
+          errors << { field: field.to_s, message: 'is required' } if data[field].blank?
+        end
+
+        # Validate field formats
+        validate_country_code(data, errors)
+        validate_website_format(data, errors)
+        validate_email_format(data, errors)
+
+        return nil if errors.empty?
+
+        { row: row_number, errors: errors }
+      end
+
+      def validate_country_code(data, errors)
+        return if data[:country_code].blank?
+        return if ISO3166::Country.codes.include?(data[:country_code].upcase)
+
+        errors << { field: 'country_code', message: "invalid code: #{data[:country_code]}" }
+      end
+
+      def validate_website_format(data, errors)
+        return if data[:website].blank?
+        return if data[:website].match?(School::VALID_URL_REGEX)
+
+        errors << { field: 'website', message: 'invalid format' }
+      end
+
+      def validate_email_format(data, errors)
+        return if data[:owner_email].blank?
+        return if data[:owner_email].match?(URI::MailTo::EMAIL_REGEXP)
+
+        errors << { field: 'owner_email', message: 'invalid email format' }
+      end
+
+      def enqueue_import_job(schools_data:, user_id:)
+        SchoolImportJob.perform_later(
+          schools_data: schools_data,
+          user_id: user_id
+        )
+      end
+    end
+  end
+end

spec/concepts/school/import_batch_spec.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe School::ImportBatch do
+  describe '.call' do
+    let(:current_user) { instance_double(User, id: SecureRandom.uuid, token: 'test-token') }
+    let(:csv_content) do
+      <<~CSV
+        name,website,address_line_1,municipality,country_code,owner_email
+        Test School 1,https://test1.example.com,123 Main St,Springfield,US,[email protected]
+        Test School 2,https://test2.example.com,456 Oak Ave,Boston,US,[email protected]
+      CSV
+    end
+    let(:csv_file) { StringIO.new(csv_content) }
+
+    before do
+      allow(SchoolImportJob).to receive(:perform_later).and_return(
+        instance_double(SchoolImportJob, job_id: 'test-job-id')
+      )
+    end
+
+    context 'with valid CSV' do
+      it 'returns success response with job_id' do
+        result = described_class.call(csv_file: csv_file, current_user: current_user)
+
+        expect(result.success?).to be true
+        expect(result[:job_id]).to eq('test-job-id')
+        expect(result[:total_schools]).to eq(2)
+      end
+
+      it 'enqueues SchoolImportJob' do
+        described_class.call(csv_file: csv_file, current_user: current_user)
+
+        expect(SchoolImportJob).to have_received(:perform_later).with(
+          hash_including(
+            schools_data: array_including(
+              hash_including(name: 'Test School 1'),
+              hash_including(name: 'Test School 2')
+            ),
+            user_id: current_user.id,
+            token: 'test-token'
+          )
+        )
+      end
+    end
+
+    context 'with missing required headers' do
+      let(:csv_content) do
+        <<~CSV
+          name,website
+          Test School,https://test.example.com
+        CSV
+      end
+
+      it 'returns error response' do
+        result = described_class.call(csv_file: csv_file, current_user: current_user)
+
+        expect(result.failure?).to be true
+        expect(result[:error][:error_code]).to eq('CSV_INVALID_FORMAT')
+        expect(result[:error][:message]).to include('Invalid CSV format')
+      end
+    end
+
+    context 'with invalid country code' do
+      let(:csv_content) do
+        <<~CSV
+          name,website,address_line_1,municipality,country_code,owner_email
+          Test School,https://test.example.com,123 Main St,Springfield,INVALID,[email protected]
+        CSV
+      end
+
+      it 'returns validation error' do
+        result = described_class.call(csv_file: csv_file, current_user: current_user)
+
+        expect(result.failure?).to be true
+        expect(result[:error][:error_code]).to eq('CSV_VALIDATION_FAILED')
+        expect(result[:error][:details][:row_errors]).to be_present
+      end
+    end
+
+    context 'with invalid website format' do
+      let(:csv_content) do
+        <<~CSV
+          name,website,address_line_1,municipality,country_code,owner_email
+          Test School,not-a-url,123 Main St,Springfield,US,[email protected]
+        CSV
+      end
+
+      it 'returns validation error' do
+        result = described_class.call(csv_file: csv_file, current_user: current_user)
+
+        expect(result.failure?).to be true
+        expect(result[:error][:error_code]).to eq('CSV_VALIDATION_FAILED')
+        expect(result[:error][:details][:row_errors]).to be_present
+      end
+    end
+
+    context 'with missing required fields' do
+      let(:csv_content) do
+        <<~CSV
+          name,website,address_line_1,municipality,country_code,owner_email
+          ,https://test.example.com,123 Main St,Springfield,US,[email protected]
+        CSV
+      end
+
+      it 'returns validation error' do
+        result = described_class.call(csv_file: csv_file, current_user: current_user)
+
+        expect(result.failure?).to be true
+        expect(result[:error][:error_code]).to eq('CSV_VALIDATION_FAILED')
+        expect(result[:error][:details][:row_errors]).to be_present
+      end
+    end
+
+    context 'with malformed CSV' do
+      let(:csv_file) { StringIO.new('this is not csv,,"') }
+
+      it 'returns error response' do
+        result = described_class.call(csv_file: csv_file, current_user: current_user)
+
+        expect(result.failure?).to be true
+        expect(result[:error][:error_code]).to eq('CSV_MALFORMED')
+      end
+    end
+  end
+end