E2606 - Finish ImportExport Module - backend implementation

app/controllers/export_controller.rb

@@ -0,0 +1,77 @@
+# This controller handles exporting data from the application to various formats.
+class ExportController < ApplicationController
+  before_action :export_params
+
+  def resolve_export_class(name)
+  # Try top-level first
+    return name.constantize
+  rescue NameError
+    # Try Pseudo namespace
+    begin
+      "Pseudo::#{name}".constantize
+    rescue NameError
+      nil
+    end
+  end
+
+  def index
+    klass = resolve_export_class(params[:class])
+
+    render json: export_metadata_for(klass), status: :ok
+  rescue StandardError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  def export
+    # Parse ordered fields from JSON, if provided
+    ordered_fields =
+      begin
+        JSON.parse(params[:ordered_fields]) if params[:ordered_fields]
+      rescue JSON::ParserError
+        render json: { error: "Invalid JSON for ordered_fields" }, status: :unprocessable_entity
+        return
+      end
+
+    klass = resolve_export_class(params[:class])
+
+    csv_file = if klass == Team
+                 Team.with_assignment_context(params[:assignment_id]) do
+                   Export.perform(klass, ordered_fields)
+                 end
+               else
+                 Export.perform(klass, ordered_fields)
+               end
+
+    render json: {
+      message: "#{params[:class]} has been exported!",
+      file: csv_file
+    }, status: :ok
+
+  rescue StandardError => e
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  private
+
+  def export_params
+    params.permit(:class, :ordered_fields, :assignment_id)
+  end
+
+  def export_metadata_for(klass)
+    if klass == Team
+      Team.with_assignment_context(params[:assignment_id]) do
+        return {
+          mandatory_fields: klass.mandatory_fields,
+          optional_fields: klass.optional_fields,
+          external_fields: klass.external_fields
+        }
+      end
+    end
+
+    {
+      mandatory_fields: klass.mandatory_fields,
+      optional_fields: klass.optional_fields,
+      external_fields: klass.external_fields
+    }
+  end
+end

app/controllers/import_controller.rb

@@ -0,0 +1,116 @@
+# This controller handles importing CSV data into any supported model.
+# It exposes two endpoints:
+#   • GET  /import        -> returns field requirements for the selected class
+#   • POST /import        -> processes the uploaded CSV file
+#
+# The controller delegates actual import logic to:
+#   klass.try_import_records(...)
+#
+# Each model that supports importing must implement:
+#   mandatory_fields
+#   optional_fields
+#   external_fields
+#   try_import_records(file, ordered_fields, use_header:)
+#
+
+class ImportController < ApplicationController
+  # Ensure strong parameters are processed before each action
+  before_action :import_params
+
+  ##
+  # GET /import
+  #
+  # Returns metadata about which fields a given class requires or accepts.
+  # The frontend uses this to build the mapping UI (drag/drop field matching).
+  #
+  def index
+    imported_class = params[:class].constantize
+
+    render json: import_metadata_for(imported_class), status: :ok
+  end
+
+  ##
+  # POST /import
+  #
+  # This action performs the actual import process. It:
+  #   1. Reads the uploaded CSV file
+  #   2. Determines whether the CSV includes headers
+  #   3. Applies user-chosen field ordering (if provided)
+  #   4. Hands off import logic to the model via `try_import_records`
+  #
+  def import
+    uploaded_file  = params[:csv_file]
+
+    # Convert use_headers ("true"/"false") into actual boolean
+    use_headers    = ActiveRecord::Type::Boolean.new.deserialize(params[:use_headers])
+
+    # If the user provided a custom field ordering, load it from JSON
+    ordered_fields = JSON.parse(params[:ordered_fields]) if params[:ordered_fields]
+
+    # Dynamically load the model class (e.g., "User", "Team", etc.)
+    klass = params[:class].constantize
+    defaults = import_defaults_for(klass)
+
+    # Load the chosen duplicate action (Skip, Update, Change)
+    dup_action = params[:dup_action]&.constantize
+
+    pp dup_action
+
+    importService = Import.new(klass: klass, file: uploaded_file, headers: ordered_fields, dup_action: dup_action&.new, defaults: defaults)
+    result = importService.perform(use_headers)
+
+    # If no exceptions occur, return success
+    render json: { message: "#{klass.name} has been imported!", **result }, status: :created
+
+  rescue StandardError => e
+    # Catch any unexpected runtime errors
+    puts "An unexpected error occurred during import: #{e.message}"
+
+    render json: { error: e.message }, status: :unprocessable_entity
+  end
+
+  private
+
+  ##
+  # Strong parameters for import operations
+  #
+  def import_params
+    params.permit(:csv_file, :use_headers, :class, :ordered_fields, :dup_action, :assignment_id)
+  end
+
+  def import_defaults_for(klass)
+    return team_import_defaults if klass == Team
+    return {} unless klass == User && current_user.present?
+
+    {
+      parent_id: current_user.id,
+      institution_id: current_user.institution_id
+    }
+  end
+
+  def import_metadata_for(imported_class)
+    if imported_class == Team
+      Team.with_assignment_context(params[:assignment_id]) do
+        return {
+          mandatory_fields: imported_class.mandatory_fields,
+          optional_fields: imported_class.optional_fields,
+          external_fields: imported_class.external_fields,
+          available_actions_on_dup: imported_class.available_actions_on_duplicate.map { |klass| klass.class.name }
+        }
+      end
+    end
+
+    {
+      mandatory_fields: imported_class.mandatory_fields,
+      optional_fields: imported_class.optional_fields,
+      external_fields: imported_class.external_fields,
+      available_actions_on_dup: imported_class.available_actions_on_duplicate.map { |klass| klass.class.name }
+    }
+  end
+
+  def team_import_defaults
+    return {} if params[:assignment_id].blank?
+
+    { assignment_id: params[:assignment_id].to_i }
+  end
+end

app/controllers/project_topics_controller.rb

@@ -8,9 +8,11 @@ def index
       render json: { message: 'Assignment ID is required!' }, status: :unprocessable_entity
     elsif params[:topic_ids].nil?
       @project_topics = ProjectTopic.where(assignment_id: params[:assignment_id])
+                                   .includes(signed_up_teams: { team: :users })
       render json: @project_topics, status: :ok
     else
       @project_topics = ProjectTopic.where(assignment_id: params[:assignment_id], topic_identifier: params[:topic_ids])
+                                   .includes(signed_up_teams: { team: :users })
       render json: @project_topics, status: :ok
     end
     # render json: {message: 'All selected topics have been loaded successfully.', project_topics: @stopics}, status: 200
@@ -85,11 +87,11 @@ def destroy
 
   # Use callbacks to share common setup or constraints between actions.
   def set_project_topic
-    @project_topic = ProjectTopic.find(params[:id])
+    @project_topic = ProjectTopic.includes(signed_up_teams: { team: :users }).find(params[:id])
   end
 
   # Only allow a list of trusted parameters through.
   def project_topic_params
-    params.require(:project_topic).permit(:topic_identifier, :category, :topic_name, :max_choosers, :assignment_id)
+    params.require(:project_topic).permit(:topic_identifier, :category, :topic_name, :max_choosers, :assignment_id, :description, :link)
   end
 end

app/controllers/teams_controller.rb

@@ -23,14 +23,34 @@ def show
   # POST /teams
   # Creates a new team associated with the current user
   def create
-    @team = Team.new(team_params)
+    @team = Team.new(normalized_team_params)
     if @team.save
       render json: @team, serializer: TeamSerializer, status: :created
     else
       render json: { errors: @team.errors.full_messages }, status: :unprocessable_entity
     end
   end
 
+  # PATCH/PUT /teams/:id
+  # Updates a specific team based on ID
+  def update
+    if @team.update(normalized_team_params)
+      render json: @team, serializer: TeamSerializer, status: :ok
+    else
+      render json: { errors: @team.errors.full_messages }, status: :unprocessable_entity
+    end
+  end
+
+  # DELETE /teams/:id
+  # Removes a specific team based on ID
+  def destroy
+    if @team.destroy
+      head :no_content
+    else
+      render json: { errors: @team.errors.full_messages }, status: :unprocessable_entity
+    end
+  end
+
   # GET /teams/:id/members
   # Lists all members of a specific team
   def members
@@ -94,7 +114,13 @@ def set_team
 
   # Whitelists the parameters allowed for team creation/updation
   def team_params
-    params.require(:team).permit(:name, :type, :assignment_id)
+    params.require(:team).permit(:name, :type, :assignment_id, :parent_id)
+  end
+
+  def normalized_team_params
+    permitted = team_params.to_h
+    permitted[:parent_id] ||= permitted.delete('assignment_id') || permitted.delete(:assignment_id)
+    permitted
   end
 
   # Whitelists parameters required to add a team member