Added validations

Created by: Radheshhathwar

assessment-api/assessment-actors/src/main/scala/org/sunbird/actors/QuestionActor.scala

 package org.sunbird.actors
 
 import com.fasterxml.jackson.databind.ObjectMapper
-import com.fasterxml.jackson.databind.node.{ArrayNode, ObjectNode}
 import org.apache.commons.lang3.StringUtils
 import org.sunbird.`object`.importer.{ImportConfig, ImportManager}
 import org.sunbird.actor.core.BaseActor
@@ -18,7 +17,6 @@ import javax.inject.Inject
 import scala.collection.JavaConverters
 import scala.collection.JavaConverters._
 import scala.concurrent.{ExecutionContext, Future}
-import com.fasterxml.jackson.databind.JsonNode
 
 class QuestionActor @Inject()(implicit oec: OntologyEngineContext) extends BaseActor {
 
@@ -145,7 +143,7 @@ class QuestionActor @Inject()(implicit oec: OntologyEngineContext) extends BaseA
 			updateRequest.getContext.put("identifier", request.getContext.get("identifier"))
 			if(request.getRequest.containsKey("rejectComment"))
 				updateRequest.put("rejectComment", request.get("rejectComment").asInstanceOf[String])
-			updateRequest.putAll(Map("versionKey" -> node.getMetadata.get("versionKey"), "status" -> "Rejected", "prevStatus" -> node.getMetadata.get("status"), "lastStatusChangedOn" -> date, "lastUpdatedOn" -> date).asJava)
+			updateRequest.putAll(Map("versionKey" -> node.getMetadata.get("versionKey"), "status" -> "Rejected", "prevStatus" -> node.getMetadata.get("status"), "lastStatusChangedOn" -> date, "lastUpdatedOn" -> date, "reviewerId" -> node.getMetadata.get("reviewerId")).asJava)
 			AssessmentManager.updateNode(updateRequest)
 			})
 		}

assessment-api/assessment-actors/src/main/scala/org/sunbird/actors/QuestionSetActor.scala

 package org.sunbird.actors
 
-import java.util
-
-import javax.inject.Inject
-import org.slf4j.{Logger, LoggerFactory}
 import org.apache.commons.collections4.CollectionUtils
 import org.apache.commons.lang3.StringUtils
+import org.slf4j.{Logger, LoggerFactory}
 import org.sunbird.`object`.importer.{ImportConfig, ImportManager}
 import org.sunbird.actor.core.BaseActor
 import org.sunbird.cache.impl.RedisCache
-import org.sunbird.common.{DateUtils, Platform}
 import org.sunbird.common.dto.{Request, Response, ResponseHandler}
+import org.sunbird.common.{DateUtils, Platform}
 import org.sunbird.graph.OntologyEngineContext
-import org.sunbird.graph.nodes.DataNode
 import org.sunbird.graph.dac.model.Node
+import org.sunbird.graph.nodes.DataNode
 import org.sunbird.managers.HierarchyManager.hierarchyPrefix
 import org.sunbird.managers.{AssessmentManager, CopyManager, HierarchyManager, UpdateHierarchyManager}
 import org.sunbird.utils.RequestUtil
 
+import java.util
+import javax.inject.Inject
 import scala.collection.JavaConverters._
 import scala.concurrent.{ExecutionContext, Future}
 
@@ -107,7 +106,7 @@ class QuestionSetActor @Inject()(implicit oec: OntologyEngineContext) extends Ba
 				val (updatedHierarchy, nodeIds) = AssessmentManager.updateHierarchy(hierarchyString.asInstanceOf[String], "Draft", node.getMetadata.getOrDefault("createdBy", "").asInstanceOf[String])
 				val updateReq = new Request(request)
 				val date = DateUtils.formatCurrentDate
-				updateReq.putAll(Map("identifiers" -> nodeIds, "metadata" -> Map("status" -> "Rejected", "prevStatus" -> node.getMetadata.get("status"), "lastStatusChangedOn" -> date, "lastUpdatedOn" -> date).asJava).asJava)
+				updateReq.putAll(Map("identifiers" -> nodeIds, "metadata" -> Map("status" -> "Rejected", "prevStatus" -> node.getMetadata.get("status"), "lastStatusChangedOn" -> date, "lastUpdatedOn" -> date, "reviewerId" -> node.getMetadata.get("reviewerId")).asJava).asJava)
 				val metadata: Map[String, AnyRef] = Map("status" -> "Draft", "hierarchy" -> updatedHierarchy)
 				val updatedMetadata = if(request.getRequest.containsKey("rejectComment")) (metadata ++ Map("rejectComment" -> request.get("rejectComment").asInstanceOf[String])) else metadata
 				updateHierarchyNodes(updateReq, node, updatedMetadata, nodeIds)

assessment-api/assessment-actors/src/main/scala/org/sunbird/utils/AssessmentContants.scala

@@ -69,6 +69,7 @@ object AssessmentConstants {
   val MAX_SCORE = "maxScore"
   val MULTIPLE = "multiple"
   val QUESTION_LIST_EDITOR_URL = "question.list.search.editor.url"
+  val FRAMEWORK_READ_URL = "framework.read.url"
   val EDITOR_STATE = "editorState"
   val PARAMS = "params"
   val OPTIONS = "options"

assessment-api/assessment-service/app/controllers/v4/QuestionController.scala

@@ -8,14 +8,15 @@ import org.sunbird.cache.impl.RedisCache
 import org.sunbird.common.dto.Response
 import org.sunbird.utils.AssessmentConstants
 import play.api.libs.json.Json
-import play.api.mvc.ControllerComponents
-import utils.{ActorNames, ApiId, JavaJsonUtils, QuestionOperations}
+import play.api.mvc.{ControllerComponents, Result}
+import utils.{ActorNames, ApiId, Constants, JavaJsonUtils, QuestionOperations}
 
 import javax.inject.{Inject, Named}
 import scala.collection.JavaConverters._
 import scala.concurrent.duration.Duration
 import scala.concurrent.{Await, ExecutionContext, Future}
 
+
 class QuestionController @Inject()(@Named(ActorNames.QUESTION_ACTOR) questionActor: ActorRef, cc: ControllerComponents, actorSystem: ActorSystem)(implicit exec: ExecutionContext) extends BaseController(cc) {
 
   val objectType = "Question"
@@ -34,10 +35,6 @@ class QuestionController @Inject()(@Named(ActorNames.QUESTION_ACTOR) questionAct
     getResult(ApiId.CREATE_QUESTION, questionActor, questionRequest)
   }
 
-  def read(identifier: String, mode: Option[String], fields: Option[String]) = {
-    readQuestion(identifier, mode, fields, false)
-  }
-
   def privateRead(identifier: String, mode: Option[String], fields: Option[String]) = Action.async { implicit request =>
     val headers = commonHeaders()
     val question = new java.util.HashMap().asInstanceOf[java.util.Map[String, Object]]
@@ -111,9 +108,6 @@ class QuestionController @Inject()(@Named(ActorNames.QUESTION_ACTOR) questionAct
     getResult(ApiId.SYSTEM_UPDATE_QUESTION, questionActor, questionRequest)
   }
 
-  def list(fields: Option[String]) = {
-    fetchQuestions(fields, false)
-  }
 
   def reject(identifier: String) = Action.async { implicit request =>
     val headers = commonHeaders()
@@ -139,37 +133,53 @@ class QuestionController @Inject()(@Named(ActorNames.QUESTION_ACTOR) questionAct
 
   //Create question by uploading excel file
   def uploadExcel() = Action(parse.multipartFormData) { implicit request =>
-    logger.info("Inside upload excel")
-    val questions = request.body
-      .file("file")
-      .map { filePart =>
-        val absolutePath = filePart.ref.path.toAbsolutePath
-        val fileName: String = filePart.filename
-        QuestionExcelParser.getQuestions(fileName, absolutePath.toFile)
+    val result: Option[Result] = request.body.file("file").map { filePart =>
+      val absolutePath = filePart.ref.path.toAbsolutePath
+      val fileName: String = filePart.filename
+      val questions: Option[IndexedSeq[Map[String, AnyRef]]] = QuestionExcelParser.getQuestions(fileName, absolutePath.toFile)
+
+      // Step 2: Validate questions based on competency and competency levels
+      val validatedQuestions: List[Map[String, Any]] = QuestionExcelParser.validateQuestions(questions)
+
+      // Step 3: Read framework from the API
+      val frameworkMap = QuestionExcelParser.frameworkRead(AssessmentConstants.FRAMEWORK_READ_URL)
+
+      // Step 4: Check if questions are valid against the framework
+      val isQuestionsValid: Boolean = validatedQuestions.forall { question =>
+        val competency: Seq[String] = question.getOrElse("subject", new java.util.ArrayList[String]()).asInstanceOf[java.util.ArrayList[String]].asScala
+        val difficultyLevel: Seq[String] = question.getOrElse("difficultyLevel", new java.util.ArrayList[String]()).asInstanceOf[java.util.ArrayList[String]].asScala
+
+        // Check if competency and competencyLevels are present in the framework
+        competency.forall(frameworkMap.contains) && difficultyLevel.forall(level => frameworkMap.getOrElse(level, Map.empty).nonEmpty)
+      }
+
+      if (isQuestionsValid) {
+        // Step 5: Process questions if valid
+        val futures = validatedQuestions.map { question =>
+          val headers = commonHeaders(request.headers)
+          val javaQuestion: java.util.Map[String, AnyRef] = question.mapValues(_.asInstanceOf[AnyRef]).asJava
+          val questionRequest = getRequest(javaQuestion, headers, QuestionOperations.createQuestionByBulkUpload.toString)
+          setRequestContext(questionRequest, version, objectType, schemaName)
+          getResponse(ApiId.CREATE_QUESTION, questionActor, questionRequest)
+        }
+
+        // Step 6: Await and handle the result
+        val f = Future.sequence(futures).map(results => results.map(_.asInstanceOf[Response]).groupBy(_.getResponseCode.toString).mapValues(listResult => {
+          listResult.map(result => {
+            setResponseEnvelope(result)
+            JavaJsonUtils.serialize(result.getResult)
+          })
+        })).map(f => Ok(Json.stringify(Json.toJson(f))).as("application/json"))
+
+        Await.result(f, Duration.apply("300s"))
+      } else {
+        // If questions are not valid, respond with an error
+        BadRequest("Invalid questions: competency or competencyLevels not present in the framework")
       }
-    logger.info("questions after parsing " + questions)
-    val futures = questions.get.map(question => {
-      val headers = commonHeaders(request.headers)
-      headers.put("channel", question.get("channel"))
-      question.putAll(headers)
-      logger.info("put headers  " + headers)
-      logger.info("creating question := {}", questions.toString)
-      val questionRequest = getRequest(question, headers, QuestionOperations.createQuestionByBulkUpload.toString)
-      logger.info("After the questionRequest")
-      setRequestContext(questionRequest, version, objectType, schemaName)
-      logger.info("After the setRequestContext")
-      getResponse(ApiId.CREATE_QUESTION, questionActor, questionRequest)
     }
-    )
-    logger.info("After the getResponse")
-    val f = Future.sequence(futures).map(results => results.map(_.asInstanceOf[Response]).groupBy(_.getResponseCode.toString).mapValues(listResult => {
-      listResult.map(result => {
-        setResponseEnvelope(result)
-        JavaJsonUtils.serialize(result.getResult)
-      })
-    })).map(f => Ok(Json.stringify(Json.toJson(f))).as("application/json"))
-    logger.info("in Future sequence")
-    Await.result(f, Duration.apply("300s"))
+
+    // Return the result or a default BadRequest if the file is not present
+    result.getOrElse(BadRequest("File not provided"))
   }
 
   def createFrameworkMappingData() = Action(parse.multipartFormData) { implicit request =>
@@ -212,10 +222,12 @@ class QuestionController @Inject()(@Named(ActorNames.QUESTION_ACTOR) questionAct
     logger.info("in Future sequence")
     Await.result(f, Duration.apply("30s"))
   }
+
   def editorList(fields: Option[String]) = {
     fetchQuestions(fields, true)
   }
-  private def fetchQuestions(fields: Option[String], exclusive: Boolean) = Action.async { implicit request =>
+
+  def fetchQuestions(fields: Option[String], exclusive: Boolean) = Action.async { implicit request =>
     val headers = commonHeaders()
     val body = requestBody()
     val question = body.getOrDefault("search", new java.util.HashMap()).asInstanceOf[java.util.Map[String, Object]];
@@ -231,7 +243,16 @@ class QuestionController @Inject()(@Named(ActorNames.QUESTION_ACTOR) questionAct
   def editorRead(identifier: String, mode: Option[String], fields: Option[String]) = {
     readQuestion(identifier, mode, fields, true)
   }
-  private def readQuestion(identifier: String, mode: Option[String], fields: Option[String], exclusive: Boolean) = Action.async { implicit request =>
+
+  def list(fields: Option[String]) = {
+    fetchQuestions(fields, false)
+  }
+
+  def read(identifier: String, mode: Option[String], fields: Option[String]) = {
+    readQuestion(identifier, mode, fields, false)
+  }
+
+  def readQuestion(identifier: String, mode: Option[String], fields: Option[String], exclusive: Boolean) = Action.async { implicit request =>
     val headers = commonHeaders()
     val question = new java.util.HashMap().asInstanceOf[java.util.Map[String, Object]]
     question.putAll(headers)

assessment-api/assessment-service/app/handlers/QuestionExcelParser.scala

@@ -2,15 +2,17 @@ package handlers
 
 import com.fasterxml.jackson.databind.ObjectMapper
 import org.apache.commons.lang3.StringUtils
-import org.apache.poi.ss.usermodel.CellType
+import org.apache.poi.ss.usermodel.{CellType, Row}
 import org.apache.poi.xssf.usermodel.{XSSFRow, XSSFWorkbook}
 import org.slf4j.{Logger, LoggerFactory}
 import org.sunbird.cache.impl.RedisCache
 import utils.Constants
 
-import java.io.{BufferedReader, File, FileInputStream, FileNotFoundException, IOException, InputStreamReader}
+import java.io._
 import java.net.{HttpURLConnection, URL}
 import java.util
+import java.util.Collections
+import scala.collection.JavaConversions.mapAsScalaMap
 import scala.collection.JavaConverters._
 import scala.util.control.Breaks._
 
@@ -18,80 +20,82 @@ object QuestionExcelParser {
 
   private val logger: Logger = LoggerFactory.getLogger(RedisCache.getClass.getCanonicalName)
 
-  def getQuestions(fileName: String, file: File) = {
+  def getQuestions(fileName: String, file: File): Option[IndexedSeq[Map[String, AnyRef]]] = {
     try {
       val workbook = new XSSFWorkbook(new FileInputStream(file))
-      val sheets = (0 until workbook.getNumberOfSheets).map(index => workbook.getSheetAt(index))  // iterates over the excelsheet
-      sheets.flatMap(sheet => {
+      val sheets = (0 until workbook.getNumberOfSheets).map(index => workbook.getSheetAt(index))
+
+      val filteredQuestions = sheets.flatMap(sheet => {
         logger.info("Inside the getQuestions")
-        (1 until sheet.getPhysicalNumberOfRows)  // iterates over each row in the sheet
+
+        (1 until sheet.getPhysicalNumberOfRows)
           .filter(rowNum => {
-            val oRow = Option(sheet.getRow(rowNum))
-            // matching the row value to determine the value of objects
-            oRow match {
-              case Some(x) => {
-                val questionType = sheet.getRow(rowNum).getCell(11)
-                val isMCQ = questionType.toString.trim.equalsIgnoreCase(Constants.MCQ_SINGLE_SELECT)// checks questionType is MCQ
-                //val isMTF = Constants.MTF.equals(questionType.toString) || Constants.MATCH_THE_FOLLOWING.equals(questionType.toString)
-                //val isFITB = Constants.FITB.equals(questionType.toString)
-                val answerCell = sheet.getRow(rowNum).getCell(10)
-                val isAnswerNotBlank = answerCell.getCellType() != CellType.BLANK
-                //isMCQ || isMTF || isFITB && isAnswerNotBlank
-                isMCQ && isAnswerNotBlank
-              }
-              case None => false
-            }
+            val oRow: Option[Row] = Option(sheet.getRow(rowNum))
+            oRow.exists(row => {
+              val questionType = row.getCell(11)
+              val isMCQ = questionType.toString.trim.equalsIgnoreCase(Constants.MCQ_SINGLE_SELECT)
+              val answerCell = row.getCell(10)
+              val isAnswerNotBlank = answerCell.getCellType() != CellType.BLANK
+              isMCQ && isAnswerNotBlank
+            })
           })
-          .map(rowNum => parseQuestion(sheet.getRow(rowNum))).toList
+          .map(rowNum => parseQuestion(sheet.getRow(rowNum)).toMap).toList
       })
-    }
 
-    catch {
-      case e: Exception => throw new Exception("Invalid File")
+      Some(filteredQuestions.toIndexedSeq)
+    } catch {
+      case e: Exception =>
+        logger.error("Error while processing Excel file", e)
+        None
     }
   }
-  def validateQuestions(questions: List[Map[String, Any]]): List[Map[String, Any]] = {
-    val competencyCodes: Seq[String] = questions.flatMap {
-      case question: Map[String, Any] @unchecked =>
-        question.get("Competency Code") match {
-          case Some(codes: java.util.List[String] @unchecked) => codes.asScala
-          case _ => Seq.empty[String]
-        }
-      case _ => Seq.empty[String]
-    }
-    val competencyLevels: Seq[String] = questions.flatMap {
-      case question: Map[String, Any] @unchecked =>
-        question.get("Competency Level").collect {
-          case levels: java.util.List[String] @unchecked => levels.asScala
-        }.getOrElse(Seq.empty[String])
-      case _ => Seq.empty[String]
-    }
-    questions.map { question =>
-      val validCompetencyCodes: Seq[String] = question match {
+  def validateQuestions(questions: Option[IndexedSeq[Map[String, AnyRef]]]): List[Map[String, Any]] = {
+    logger.info("Inside the validateQuestions")
+    questions.map { questionSeq =>
+      val competencyCodes: Seq[String] = questionSeq.flatMap {
         case q: Map[String, Any] @unchecked =>
-          q.get("competencyCodes") match {
-            case Some(codes: java.util.List[String] @unchecked) => codes.asScala.filter(competencyCodes.contains)
+          q.get("Competency Code") match {
+            case Some(codes: java.util.List[String] @unchecked) => codes.asScala
             case _ => Seq.empty[String]
           }
         case _ => Seq.empty[String]
       }
-      val validCompetencyLevels: Seq[String] = question match {
+      val difficultyLevel: Seq[String] = questionSeq.flatMap {
         case q: Map[String, Any] @unchecked =>
-          q.get("competencyLevels") match {
-            case Some(levels: java.util.List[String] @unchecked) => Option(levels.asScala).getOrElse(Seq.empty[String]).filter(competencyLevels.contains)
-            case _ => Seq.empty[String]
-          }
+          q.get("difficultyLevel").collect {
+            case levels: java.util.List[String] @unchecked => levels.asScala
+          }.getOrElse(Seq.empty[String])
         case _ => Seq.empty[String]
       }
-      question
-    }
+
+      val validatedQuestions = questionSeq.map { question =>
+        val validCompetencyCodes: Seq[String] = question match {
+          case q: Map[String, Any] @unchecked =>
+            q.get("competencyCodes") match {
+              case Some(codes: java.util.List[String] @unchecked) => codes.asScala.filter(competencyCodes.contains)
+              case _ => Seq.empty[String]
+            }
+          case _ => Seq.empty[String]
+        }
+        val validDifficultyLevels: Seq[String] = question match {
+          case q: Map[String, Any] @unchecked =>
+            q.get("difficultyLevel") match {
+              case Some(levels: java.util.List[String] @unchecked) => Option(levels.asScala).getOrElse(Seq.empty[String]).filter(difficultyLevel.contains)
+              case _ => Seq.empty[String]
+            }
+          case _ => Seq.empty[String]
+        }
+        question
+      }
+      validatedQuestions.toList
+    }.getOrElse(List.empty[Map[String, Any]])
   }
   def frameworkRead(frameworkUrl: String): Map[String, Map[String, Object]] = {
     try {
       val url = new URL(frameworkUrl)
       val connection = url.openConnection().asInstanceOf[HttpURLConnection]
       connection.setRequestMethod("GET")
-
+      logger.info("Inside frameworkRead")
       val reader = new BufferedReader(new InputStreamReader(connection.getInputStream))
       val response = new StringBuilder()
       var line: String = null
@@ -158,7 +162,7 @@ object QuestionExcelParser {
     mapOption
   }
 
-  def buildInteractionMap(option: String, level: Integer) = {
+  def buildInteractionMap(option: String, level: String) = {
     val mapOptionValue = new java.util.HashMap().asInstanceOf[java.util.Map[String, AnyRef]]
     mapOptionValue.put(Constants.LABEL, option)
     mapOptionValue.put(Constants.VALUE, level)
@@ -182,99 +186,87 @@ object QuestionExcelParser {
     boolean
   }
 
-  def parseQuestion(xssFRow: XSSFRow) = {
+  def parseQuestion(xssFRow: XSSFRow): java.util.Map[String, AnyRef] = {
     val question = buildDefaultQuestion()
-
     val rowContent = (0 until xssFRow.getPhysicalNumberOfCells)
-      .map(colId => Option(xssFRow.getCell(colId)).getOrElse("").toString).toList
-
-    //fetches data from sheet
-    // this is the role(medium)
-    val medium = rowContent.apply(0)
-    // this is competency label
-    val subject = rowContent.apply(1)
-    // this val is for competency level label
-    val difficultyLevel = rowContent.apply(5)
-    // this val is for activity(GradeLevel)
-    val gradeLevel = rowContent.apply(7)
-    val questionText = rowContent.apply(8)
-    val answer = rowContent.apply(10).trim
-    val board = rowContent.apply(12).trim
-    val channel = rowContent.apply(13).trim
-    val maxScore:Integer = rowContent.apply(14).trim.toDouble.intValue()
-    val assessmentType = rowContent.apply(15)
-
-    var i = -1
-    val options = new util.ArrayList[util.Map[String, AnyRef]](rowContent.apply(9).split("\n").filter(StringUtils.isNotBlank).map(o => {
-      val option = o.split("[)]").toList
-      val optSeq = option.apply(0).trim
-
-      val optText = option.apply(1).trim
-      i += 1
-      buildOptionMap(optText, i, isOptionAnswer(optSeq, answer))
-    }).toList.asJava)
-
-    var j = -1
-    val mapRepsonse = new util.HashMap().asInstanceOf[util.Map[String, AnyRef]]
-    val repsonse1 = new util.HashMap().asInstanceOf[util.Map[String, AnyRef]]
-    val responseDeclarationOption = new util.ArrayList[util.Map[String, AnyRef]](rowContent.apply(9).split("\n").filter(StringUtils.isNotBlank).map(o => {
-      val option = o.split("[)]").toList
-      val optSeq = option.apply(0).trim
-
-      val optText = option.apply(1).trim
-      j += 1
-      if(isOptionAnswer(optSeq, answer)){
-        mapRepsonse.put(Constants.MAX_SCORE,maxScore.asInstanceOf[AnyRef])
-        mapRepsonse.put(Constants.CARDINALITY, "single")
-        mapRepsonse.put(Constants.TYPE, "integer")
-        val mapCorrectResponse = new util.HashMap().asInstanceOf[util.Map[String, AnyRef]]
-        mapCorrectResponse.put(Constants.VALUE, String.valueOf(j))
-        val mapOutcomes = new util.HashMap().asInstanceOf[util.Map[String, AnyRef]]
-        mapOutcomes.put(Constants.SCORE, maxScore.asInstanceOf[AnyRef])
-        mapCorrectResponse.put(Constants.OUTCOMES, mapOutcomes)
-        mapRepsonse.put(Constants.CORRECT_RESPONSE, mapCorrectResponse)
-        mapRepsonse.put(Constants.MAPPING, new util.ArrayList())
-      }
-      repsonse1.put("response1", mapRepsonse)
-      repsonse1
-    }).toList.asJava)
-
-    var k = -1
-    val interactionOptions = new util.ArrayList[util.Map[String, AnyRef]](rowContent.apply(9).split("\n").filter(StringUtils.isNotBlank).map(o => {
-      val option = o.split("[)]").toList
-      val optSeq = option.apply(0).trim
-
-      val optText = option.apply(1).trim
-      k += 1
-      buildInteractionMap(optText, k)
-    }).toList.asJava)
-
-    val mapInteraction: _root_.java.util.Map[_root_.java.lang.String, AnyRef] = createInteractionMap(interactionOptions)
-    val editorState = new util.HashMap().asInstanceOf[util.Map[String, AnyRef]]
+      .map(colId => Option(xssFRow.getCell(colId)).getOrElse("").toString.trim)
+
+    // Extracting values from the row content
+    val medium = rowContent(0)
+    val subject = rowContent(1)
+    val difficultyLevel = rowContent(5)
+    val gradeLevel = rowContent(7)
+    val questionText = rowContent(8)
+    val answer = rowContent(10)
+    val board = rowContent(12)
+    val channel = rowContent(13)
+    val maxScore = rowContent(14).toDouble.toInt
+    val assessmentType = rowContent(15)
+
+    // Extracting options from the row content
+    val options = rowContent(9).split("\n").filter(StringUtils.isNotBlank).zipWithIndex.map {
+      case (option, index) => buildOptionMap(option.split("[)]")(1).trim, index, isOptionAnswer(option.split("[)]")(0).trim, answer))
+    }.toList.asJava
+
+    // Building response1 map
+    val response1 =  {
+      val mapResponse = new util.HashMap[String, AnyRef]()
+      mapResponse.put(Constants.MAX_SCORE, maxScore.asInstanceOf[AnyRef])
+      mapResponse.put(Constants.CARDINALITY, "single")
+      mapResponse.put(Constants.TYPE, "integer")
+
+      val mapCorrectResponse = new util.HashMap[String, AnyRef]()
+      mapCorrectResponse.put(Constants.VALUE, answer)
+
+      val mapOutcomes = new util.HashMap[String, AnyRef]()
+      mapOutcomes.put(Constants.SCORE, maxScore.asInstanceOf[AnyRef])
+      mapCorrectResponse.put(Constants.OUTCOMES, mapOutcomes)
+
+      mapResponse.put(Constants.CORRECT_RESPONSE, mapCorrectResponse)
+      mapResponse.put(Constants.MAPPING, new util.ArrayList())
+
+      Collections.singletonMap("response1", mapResponse)
+    }
+
+    // Building interactionOptions
+    val interactionOptions = rowContent(9).split("\n").filter(StringUtils.isNotBlank).map { option =>
+      buildInteractionMap(option.split("[)]")(1).trim, difficultyLevel)
+    }.toList.asJava
+
+    // Building interaction map
+    val interactionMap = createInteractionMap(interactionOptions)
+
+
+    // Building editorState map
+    val editorState = new util.HashMap[String, AnyRef]()
     val interactionTypes = new util.ArrayList[String]()
     interactionTypes.add("choice")
+    editorState.put(Constants.OPTIONS, options)
+    editorState.put(Constants.QUESTION, questionText)
+
+    // Assembling the final question map
+    question.putAll(response1)
     question.put(Constants.BOARD, board)
-    question.put(Constants.INTERACTION_TYPES,interactionTypes)
-    question.put(Constants.INTERACTIONS,mapInteraction)
-    question.put(Constants.RESPONSE_DECLARATION,repsonse1)
+    question.put(Constants.INTERACTION_TYPES, interactionTypes)
+    question.put(Constants.INTERACTIONS, interactionMap)
+    question.put(Constants.EDITOR_STATE, editorState)
+
     setArrayValue(question, medium, Constants.medium)
     setArrayValue(question, subject, Constants.subject)
     setArrayValue(question, gradeLevel, Constants.gradeLevel)
     setArrayValue(question, difficultyLevel, Constants.difficultyLevel)
-    editorState.put(Constants.OPTIONS, options)
-    editorState.put(Constants.QUESTION, questionText)
-    logger.info("Inside the parseQuestion")
+
     question.put(Constants.BODY, questionText)
-    question.put(Constants.EDITOR_STATE, editorState)
     question.put(Constants.TEMPLATE_ID, "mcq-vertical")
     question.put(Constants.ANSWER, answer)
     question.put("channel", channel)
-    setArrayValue(question,assessmentType,"assessmentType")
+    setArrayValue(question, assessmentType, "assessmentType")
+
     question
   }
 
 
-  private def createInteractionMap(interactionOptions: util.ArrayList[util.Map[String, AnyRef]]) = {
+  private def createInteractionMap(interactionOptions: util.List[util.Map[String, AnyRef]]) = {
     val mapOption = new util.HashMap().asInstanceOf[util.Map[String, AnyRef]]
     mapOption.put(Constants.TYPE, "choice".asInstanceOf[AnyRef])
     mapOption.put(Constants.OPTIONS, interactionOptions)