E2608. Hierarchical list display

.gitignore

@@ -32,3 +32,8 @@
 coverage/
 rsa_keys.yml
 pg_data/
+
+# Ignore ruby version
+.ruby-version
+Gemfile
+Gemfile.lock

.ruby-version

@@ -1 +1 @@
-ruby-3.4.5
+3.4.5

Dockerfile

@@ -21,4 +21,4 @@ RUN bundle install
 EXPOSE 3002 
 
 # Set the entry point
-ENTRYPOINT ["/app/setup.sh"]
+ENTRYPOINT ["/app/setup.sh"]

Gemfile

@@ -58,7 +58,6 @@ gem 'find_with_order'
 # For handling zip file uploads and extraction
 gem 'rubyzip'
 
-
 group :development, :test do
   gem 'debug', platforms: %i[mri mingw x64_mingw]
   gem 'factory_bot_rails'

app/controllers/courses_controller.rb

@@ -10,8 +10,8 @@ def action_allowed?
   # GET /courses
   # List all the courses
   def index
-    courses = Course.all
-    render json: courses, status: :ok
+    courses = Course.includes(:assignments).all
+    render json: courses.as_json(include: :assignments), status: :ok
   end
 
   # GET /courses/1

app/controllers/questionnaires_controller.rb

@@ -1,11 +1,64 @@
 class QuestionnairesController < ApplicationController
+  DISPLAY_TYPES = [
+    'Review',
+    'Metareview',
+    'Author feedback',
+    'Teammate Review',
+    'Survey',
+    'Assignment survey',
+    'Global survey',
+    'Course survey',
+    'Bookmark rating',
+    'Quiz'
+  ].freeze
+
+  TYPE_DISPLAY_MAP = {
+    'ReviewQuestionnaire' => 'Review',
+    'MetareviewQuestionnaire' => 'Metareview',
+    'Author FeedbackQuestionnaire' => 'Author feedback',
+    'AuthorFeedbackQuestionnaire' => 'Author feedback',
+    'Teammate ReviewQuestionnaire' => 'Teammate Review',
+    'TeammateReviewQuestionnaire' => 'Teammate Review',
+    'SurveyQuestionnaire' => 'Survey',
+    'AssignmentSurveyQuestionnaire' => 'Assignment survey',
+    'Assignment SurveyQuestionnaire' => 'Assignment survey',
+    'Global SurveyQuestionnaire' => 'Global survey',
+    'GlobalSurveyQuestionnaire' => 'Global survey',
+    'Course SurveyQuestionnaire' => 'Course survey',
+    'CourseSurveyQuestionnaire' => 'Course survey',
+    'Bookmark RatingQuestionnaire' => 'Bookmark rating',
+    'BookmarkRatingQuestionnaire' => 'Bookmark rating',
+    'QuizQuestionnaire' => 'Quiz'
+  }.freeze
 
   # Index method returns the list of JSON objects of the questionnaire
   # GET on /questionnaires
   def index
     @questionnaires = Questionnaire.order(:id)
     render json: @questionnaires, status: :ok and return
   end
+
+  # Hierarchical list of questionnaire types and questionnaires available to the current user.
+  # GET on /questionnaires/hierarchical
+  def hierarchical
+    questionnaires = Questionnaire
+                     .includes(:instructor)
+                     .where(private: false)
+                     .or(Questionnaire.where(instructor_id: current_user.id))
+                     .order(:name)
+                     .distinct
+
+    grouped_questionnaires = questionnaires.group_by do |questionnaire|
+      display_type_for(questionnaire.questionnaire_type)
+    end
+
+    render json: DISPLAY_TYPES.map { |display_type|
+      {
+        type: display_type,
+        questionnaires: (grouped_questionnaires[display_type] || []).map(&:as_json)
+      }
+    }, status: :ok and return
+  end
 
   # Show method returns the JSON object of questionnaire with id = {:id}
   # GET on /questionnaires/:id
@@ -17,18 +70,30 @@ def show
       render json: $ERROR_INFO.to_s, status: :not_found and return
     end
   end
+
+  # GET /questionnaires/:id/items
+  def items
+    questionnaire = Questionnaire.find(params[:id])
+    render json: questionnaire.items.order(:seq), status: :ok and return
+  rescue ActiveRecord::RecordNotFound
+    render json: { error: "Questionnaire not found" }, status: :not_found and return
+  end
 
   # Create method creates a questionnaire and returns the JSON object of the created questionnaire
   # POST on /questionnaires
   # Instructor Id statically defined since implementation of Instructor model is out of scope of E2345.
   def create
     begin
-      @questionnaire = Questionnaire.new(questionnaire_params)
+      questionnaire_attributes, item_attributes = split_questionnaire_params
+      @questionnaire = Questionnaire.new(questionnaire_attributes)
       @questionnaire.display_type = sanitize_display_type(@questionnaire.questionnaire_type)
-      @questionnaire.save!
+      Questionnaire.transaction do
+        @questionnaire.save!
+        sync_items!(@questionnaire, item_attributes)
+      end
       render json: @questionnaire, status: :created and return
     rescue ActiveRecord::RecordInvalid
-      render json: $ERROR_INFO.to_s, status: :unprocessable_entity
+      render json: { errors: $ERROR_INFO.record.errors.full_messages }, status: :unprocessable_entity
     end
   end
 
@@ -37,9 +102,12 @@ def create
   def destroy
     begin
       @questionnaire = Questionnaire.find(params[:id])
-      @questionnaire.delete
+      @questionnaire.destroy!
+      render json: { message: 'Questionnaire deleted successfully' }, status: :ok and return
     rescue ActiveRecord::RecordNotFound
       render json: $ERROR_INFO.to_s, status: :not_found and return
+    rescue ActiveRecord::RecordNotDestroyed, ActiveRecord::InvalidForeignKey
+      render json: { error: $ERROR_INFO.message }, status: :unprocessable_entity and return
     end
   end
 
@@ -48,11 +116,16 @@ def destroy
 
   def update
     @questionnaire = Questionnaire.find(params[:id])
-    if @questionnaire.update(questionnaire_params)
-      render json: @questionnaire, status: :ok
-    else
-      render json: @questionnaire.errors.full_messages, status: :unprocessable_entity
+    questionnaire_attributes, item_attributes = split_questionnaire_params
+
+    Questionnaire.transaction do
+      @questionnaire.update!(questionnaire_attributes)
+      sync_items!(@questionnaire, item_attributes)
     end
+
+    render json: @questionnaire, status: :ok
+  rescue ActiveRecord::RecordInvalid
+    render json: { errors: $ERROR_INFO.record.errors.full_messages }, status: :unprocessable_entity
   end
   # Copy method creates a copy of questionnaire with id - {:id} and return its JSON object
   # POST on /questionnaires/copy/:id
@@ -87,7 +160,31 @@ def toggle_access
   private
 
   def questionnaire_params
-    params.require(:questionnaire).permit(:name, :questionnaire_type, :private, :min_question_score, :max_question_score, :instructor_id)
+    params.require(:questionnaire).permit(
+      :name,
+      :questionnaire_type,
+      :private,
+      :min_question_score,
+      :max_question_score,
+      :instructor_id,
+      items_attributes: [
+        :id,
+        :txt,
+        :question_type,
+        :weight,
+        :alternatives,
+        :min_label,
+        :max_label,
+        :seq,
+        :break_before,
+        :textarea_width,
+        :textarea_height,
+        :textbox_width,
+        :row_names,
+        :col_names,
+        :_destroy
+      ]
+    )
   end
 
   def sanitize_display_type(type)
@@ -98,4 +195,78 @@ def sanitize_display_type(type)
     display_type
   end
 
-end
+  def display_type_for(questionnaire_type)
+    TYPE_DISPLAY_MAP.fetch(questionnaire_type, questionnaire_type.to_s.delete_suffix('Questionnaire'))
+  end
+
+  def split_questionnaire_params
+    permitted_params = questionnaire_params.to_h.deep_symbolize_keys
+    items_attributes = permitted_params.delete(:items_attributes) || []
+    [permitted_params, items_attributes]
+  end
+
+  def sync_items!(questionnaire, item_attributes)
+    item_attributes.each_with_index do |item_data, index|
+      destroy_item = ActiveModel::Type::Boolean.new.cast(item_data[:_destroy])
+
+      if destroy_item && item_data[:id].present?
+        questionnaire.items.find(item_data[:id]).destroy!
+        next
+      end
+
+      next if destroy_item
+
+      if item_data[:id].present?
+        existing_item = questionnaire.items.find(item_data[:id])
+        attributes = build_item_attributes(item_data, index, existing_item)
+        existing_item.update!(attributes)
+      else
+        attributes = build_item_attributes(item_data, index)
+        questionnaire.items.create!(attributes)
+      end
+    end
+  end
+
+  def build_item_attributes(item_data, index, existing_item = nil)
+    question_type = canonical_question_type(item_data[:question_type])
+    {
+      txt: item_data[:txt].presence || existing_item&.txt,
+      question_type: question_type,
+      weight: item_data[:weight].presence || existing_item&.weight,
+      seq: item_data[:seq].presence || index + 1,
+      alternatives: normalize_alternatives(item_data[:alternatives]) || existing_item&.alternatives,
+      min_label: item_data[:min_label].presence || existing_item&.min_label,
+      max_label: item_data[:max_label].presence || existing_item&.max_label,
+      break_before: item_data.key?(:break_before) ? ActiveModel::Type::Boolean.new.cast(item_data[:break_before]) : true,
+      size: build_item_size(question_type, item_data, existing_item)
+    }.compact
+  end
+
+  def canonical_question_type(question_type)
+    {
+      'Text area' => 'TextArea',
+      'Text field' => 'TextField',
+      'Multiple choice' => 'MultipleChoiceRadio'
+    }.fetch(question_type, question_type)
+  end
+
+  def normalize_alternatives(alternatives)
+    return nil if alternatives.blank?
+
+    alternatives.to_s.split(',').map(&:strip).reject(&:empty?).join('|')
+  end
+
+  def build_item_size(question_type, item_data, existing_item = nil)
+    case question_type
+    when 'Criterion', 'TextArea'
+      width = item_data[:textarea_width].presence
+      height = item_data[:textarea_height].presence
+      return "#{width},#{height}" if width && height
+    when 'TextField'
+      return item_data[:textbox_width].to_s if item_data[:textbox_width].present?
+    end
+
+    existing_item&.size
+  end
+
+end

app/controllers/questions_controller.rb

@@ -103,7 +103,11 @@ def delete_all
   end
 
   def types
-    types = Item.pluck(:question_type).uniq
+    types = if QuestionType.exists?
+              QuestionType.order(:name).pluck(:name)
+            else
+              %w[Criterion Scale Dropdown TextArea TextField MultipleChoiceRadio]
+            end
     render json: types, status: :ok
   end
 

app/controllers/teams_controller.rb

@@ -6,9 +6,21 @@ class TeamsController < ApplicationController
   before_action :validate_team_type, only: [:create]
 
   # GET /teams
-  # Fetches all teams and renders them using TeamSerializer
+  # Fetches teams for a hierarchy context (assignment/course) and renders them using TeamSerializer
   def index
-    @teams = Team.all
+    @teams = Team.includes(:users, { teams_participants: :participant })
+
+    if params[:parent_id].present?
+      @teams = @teams.where(parent_id: params[:parent_id])
+    end
+
+    if params[:types].present?
+      requested_types = params[:types].is_a?(Array) ? params[:types] : params[:types].to_s.split(',')
+      normalized_types = requested_types.map(&:strip).reject(&:blank?)
+      @teams = @teams.where(type: normalized_types) if normalized_types.any?
+    end
+
+    @teams = @teams.order(:name, :id)
     render json: @teams, each_serializer: TeamSerializer
   end
 
@@ -94,7 +106,11 @@ def set_team
 
   # Whitelists the parameters allowed for team creation/updation
   def team_params
-    params.require(:team).permit(:name, :type, :assignment_id)
+    permitted = params.require(:team).permit(:name, :type, :parent_id, :assignment_id)
+
+    # Backward compatibility for clients still sending assignment_id.
+    permitted[:parent_id] = permitted[:assignment_id] if permitted[:parent_id].blank? && permitted[:assignment_id].present?
+    permitted.except(:assignment_id)
   end
 
   # Whitelists parameters required to add a team member

app/models/Item.rb

@@ -25,7 +25,7 @@ def set_seq
 
   def as_json(options = {})
       super(options.merge({
-                            only: %i[txt weight seq question_type size alternatives break_before min_label max_label created_at updated_at],
+                            only: %i[id txt weight seq question_type size alternatives break_before min_label max_label created_at updated_at],
                             include: {
                               questionnaire: { only: %i[name id] }
                             }
@@ -91,4 +91,4 @@ def self.for(record)
     # Cast the existing record to the desired subclass
     klass.new(record.attributes)
   end
-end
+end

app/models/question_type.rb

@@ -0,0 +1,2 @@
+class QuestionType < ApplicationRecord
+end

app/models/questionnaire.rb

@@ -3,7 +3,6 @@
 class Questionnaire < ApplicationRecord
   belongs_to :instructor
   has_many :items, class_name: "Item", foreign_key: "questionnaire_id", dependent: :destroy # the collection of items associated with this Questionnaire
-  before_destroy :check_for_question_associations
 
   validate :validate_questionnaire
   validates :name, presence: true
@@ -64,13 +63,6 @@ def self.copy_questionnaire_details(params)
     questionnaire
   end
 
-    # Check_for_question_associations checks if questionnaire has associated items or not
-    def check_for_question_associations
-      if items.any?
-        raise ActiveRecord::DeleteRestrictionError.new( "Cannot delete record because dependent items exist")
-      end
-    end
-
     def as_json(options = {})
         super(options.merge({
                               only: %i[id name private min_question_score max_question_score created_at updated_at questionnaire_type instructor_id],

app/serializers/team_serializer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class TeamSerializer < ActiveModel::Serializer
-  attributes :id, :name, :type, :team_size
+  attributes :id, :name, :type, :parent_id, :team_size
   has_many :members, serializer: ParticipantSerializer
   has_many :users, serializer: UserSerializer