public IHttpActionResult PutQuestionPaper(int id, QuestionPaper questionPaper)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != questionPaper.QuestionPaperId)
{
return(BadRequest());
}
db.Entry(questionPaper).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!QuestionPaperExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <IHttpActionResult> PutQuestionPaper(Guid id, QuestionPaper questionPaper)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != questionPaper.Id)
{
return(BadRequest());
}
try
{
await questionPaperRepository.PutQuestionPaper(id, questionPaper);
}
catch (DbUpdateConcurrencyException)
{
if (!questionPaperRepository.QuestionPaperExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
catch (Exception ex)
{
throw;
}
return(StatusCode(HttpStatusCode.NoContent));
}
public void SavePaper(IPaperDTO paperDTO)
{
var portalDb = new QuestionnaireEntities();
QuestionPaper paperE = null;
if (paperDTO.PaperId == -1)
{
paperE = new QuestionPaper();
paperE.Name = paperDTO.Name;
paperE.Description = paperDTO.Description;
paperE.Duration = paperDTO.Duration;
portalDb.QuestionPapers.Add(paperE);
}
else
{
paperE = portalDb.QuestionPapers.SingleOrDefault(n => n.Id == paperDTO.PaperId);
paperE.Name = paperDTO.Name;
paperE.Description = paperDTO.Description;
paperE.Duration = paperDTO.Duration;
}
portalDb.SaveChanges();
paperDTO.PaperId = paperE.Id;
}
public ActionResult DeleteConfirmed(int id)
{
QuestionPaper questionPaper = db.QuestionPapers.Find(id);
db.QuestionPapers.Remove(questionPaper);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit([Bind(Include = "QuestionPaperId,QuestionPaperName,QuestionPaperDescription")] QuestionPaper questionPaper)
{
if (ModelState.IsValid)
{
db.Entry(questionPaper).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(questionPaper));
}
public ActionResult Edit(long id, QuestionPaper model)
{
try
{
if (id <= 0)
{
throw new ArgumentException("QPaperID is invalid.");
}
if (ModelState.IsValid)
{
#region Check Question Bank name Exists or Not while updating
DataTable dt = new DataTable();
using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["dbConnection"].ToString()))
{
using (SqlCommand cmd = new SqlCommand("usp_CheckQuestionPapernameExistsWhileUpdate_GetByName", con))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@QPaperID", id);
cmd.Parameters.AddWithValue("@QPaperName", model.QPaperName);
using (SqlDataAdapter da = new SqlDataAdapter())
{
da.SelectCommand = cmd;
da.Fill(dt);
}
}
}
if (dt.Rows.Count > 0)
{
throw new Exception("Question Paper is already exists!!!");
}
#endregion
using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["dbConnection"].ToString()))
{
con.Open();
using (SqlCommand cmd = new SqlCommand("usp_UpdateQuestionPaper_Update", con))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@QPaperID", id);
cmd.Parameters.AddWithValue("@QPaperName", model.QPaperName);
cmd.ExecuteNonQuery();
}
con.Close();
}
return(RedirectToAction("Index"));
}
return(View(model));
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(model));
}
}
public async Task <IHttpActionResult> PostQuestionPaper(QuestionPaper questionPaper)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
questionPaper = await questionPaperRepository.PostQuestionPaper(questionPaper);
return(CreatedAtRoute("DefaultApi", new { id = questionPaper.Id }, questionPaper));
}
public async Task <IHttpActionResult> GetQuestionPaper(Guid id)
{
QuestionPaper questionPaper = await questionPaperRepository.GetQuestionPaper(id);
if (questionPaper == null)
{
return(NotFound());
}
return(Ok(questionPaper));
}
public IHttpActionResult GetQuestionPaperByQuestionPaperId(Guid Id)
{
QuestionPaper questionPaper = new QuestionPaper();
questionPaper = db.QuestionPapers.Find(Id);
if (questionPaper == null)
{
return(NotFound());
}
return(Ok(questionPaper));
}
public ActionResult Create([Bind(Include = "QuestionPaperId,QuestionPaperName,QuestionPaperDescription")] QuestionPaper questionPaper)
{
if (ModelState.IsValid)
{
db.QuestionPapers.Add(questionPaper);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(questionPaper));
}
public IHttpActionResult PostQuestionPaper(QuestionPaper questionPaper)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.QuestionPapers.Add(questionPaper);
db.SaveChanges();
return(CreatedAtRoute("DefaultApi", new { id = questionPaper.QuestionPaperId }, questionPaper));
}
public IHttpActionResult SubmitQuestionPaperFormData(JObject FormInputs)
{
dynamic inputValues = FormInputs;
QuestionPaperModel questionPaperModel = new QuestionPaperModel();
QuestionPaper questionPaperDBModel = new QuestionPaper();
questionPaperModel = JsonConvert.DeserializeObject <QuestionPaperModel>(inputValues.QuestionPaperModel.ToString());
questionPaperDBModel.CustomerId = new Guid(CustomerConstants.CustomerId);
questionPaperDBModel.AddedOn = DateTime.Now;
questionPaperDBModel.AddedBy = new Guid(CustomerConstants.AddedById);
questionPaperDBModel.duration = questionPaperModel.duration;
questionPaperDBModel.totalmarks = questionPaperModel.totalmarks;
questionPaperDBModel.SubjectName = questionPaperModel.SubjectName;
questionPaperDBModel.ExaminationTypeId = new Guid(questionPaperModel.ExaminationTypeId);
questionPaperDBModel.ExaminationType = questionPaperModel.ExaminationType;
questionPaperDBModel.questionpaperdata = inputValues.QuestionPaperModel.ToString();
questionPaperDBModel.QuestionPaperId = Guid.NewGuid();
db.QuestionPapers.Add(questionPaperDBModel);
try
{
db.SaveChanges();
}
catch (DbUpdateException)
{
if (QuestionPaperExists(questionPaperDBModel.QuestionPaperId))
{
return(Conflict());
}
else
{
throw;
}
}
catch (DbEntityValidationException ex)
{
// Retrieve the error messages as a list of strings.
var errorMessages = ex.EntityValidationErrors
.SelectMany(x => x.ValidationErrors)
.Select(x => x.ErrorMessage);
// Join the list to a single string.
var fullErrorMessage = string.Join("; ", errorMessages);
// Combine the original exception message with the new one.
var exceptionMessage = string.Concat(ex.Message, " The validation errors are: ", fullErrorMessage);
// Throw a new DbEntityValidationException with the improved exception message.
throw new DbEntityValidationException(exceptionMessage, ex.EntityValidationErrors);
}
return(Ok(questionPaperDBModel));
}
// GET: QuestionPapers/Delete/5
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
QuestionPaper questionPaper = db.QuestionPapers.Find(id);
if (questionPaper == null)
{
return(HttpNotFound());
}
return(View(questionPaper));
}
public IHttpActionResult GetQuestionPaper(int id)
{
//QuestionPaper questionPaper = db.QuestionPapers.Find(id);
QuestionPaper questionPaper = db.QuestionPapers.Where(u => u.QuestionPaperId == id)
.Include(u => u.Questions)
.FirstOrDefault();
if (questionPaper == null)
{
return(NotFound());
}
return(Ok(questionPaper));
}
public IHttpActionResult DeleteQuestionPaper(int id)
{
QuestionPaper questionPaper = db.QuestionPapers.Find(id);
if (questionPaper == null)
{
return(NotFound());
}
db.QuestionPapers.Remove(questionPaper);
db.SaveChanges();
return(Ok(questionPaper));
}
public async Task <QuestionPaper> PutQuestionPaper(Guid id, QuestionPaper questionPaper)
{
db.Entry(questionPaper).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (Exception ex)
{
throw;
}
return(questionPaper);
}
public void TestQuestionPaperModelValidation()
{
QuestionPaper paper = new QuestionPaper()
{
Department = DEPARTMENTS.BBA,
Item = new Item()
{
Title = "Question Paper"
}
};
var results = GetValidationErrorList(paper);
Assert.IsTrue(results.Any(v => v.MemberNames.Contains("Month")));
Assert.IsTrue(results.Any(v => v.MemberNames.Contains("Subject")));
}
public async Task <bool> DeleteQuestionPaper(Guid id)
{
QuestionPaper questionPaper = await db.questionPaper.FindAsync(id);
try
{
db.questionPaper.Remove(questionPaper);
await db.SaveChangesAsync();
return(true);
}
catch (SqlException ex)
{
throw ex;
}
}
public async Task <QuestionPaper> PostQuestionPaper(QuestionPaper questionPaper)
{
try {
string refPath = questionPaper.TestId;
//var hb=JsonConvert.DeserializeObject<>
questionPaperBL.WriteQuestionPaper(questionPaper.QuestionList, questionPaper.TestId);
//TODO: Use mapper to map controller object to model
questionPaper.QuestionList = null;
db.questionPaper.Add(questionPaper);
await db.SaveChangesAsync();
return(questionPaper);
}
catch (Exception ex)
{
throw ex;
}
}
public QuestionPaper ExamPapers(int examId, long studentId)
{
QuestionPaper result = new QuestionPaper();
try
{
DataSet dtResponse = examDA.ExamPapers(examId, studentId);
if (dtResponse != null && dtResponse.Tables.Count > 1)
{
result.QuestionList = dtResponse.Tables[0].ConvertToListOf <QuestionMaster>();
result.AnswerList = dtResponse.Tables[1].ConvertToListOf <AnswerMaster>();
}
}
catch (Exception)
{
throw;
}
return(result);
}
public ActionResult Edit(long id)
{
var model = new QuestionPaper();
try
{
DataTable dtResult = new DataTable();
using (SqlConnection con = new SqlConnection(ConfigurationManager.ConnectionStrings["dbConnection"].ToString()))
{
using (SqlCommand cmd = new SqlCommand("usp_GetQuestionPaperRecord_GetByID", con))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@QPaperID", id);
using (SqlDataAdapter da = new SqlDataAdapter())
{
da.SelectCommand = cmd;
da.Fill(dtResult);
}
}
}
if (dtResult.Rows.Count > 0)
{
model.QPaperID = Convert.ToInt64(dtResult.Rows[0]["QPaperID"]);
model.QPaperName = dtResult.Rows[0]["QPaperName"].ToString();
return(View(model));
}
else
{
return(RedirectToAction("Index"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
return(View(model));
}
}
public ActionResult StartExam(int id)
{
List <QuestionMaster> questionList = new List <QuestionMaster>();
try
{
long studentId = long.Parse("0" + Request.Cookies["UserId"].Value);
QuestionPaper result = objExamBL.ExamPapers(id, studentId);
foreach (QuestionMaster ques in result.QuestionList)
{
QuestionMaster question = new QuestionMaster();
question = ques;
question.Options = result.AnswerList.Where(a => a.QuestionId == ques.QuestionId).ToList();
questionList.Add(question);
}
}
catch (Exception ex)
{
}
return(View(questionList));
}
public ActionResult addquestions(int id, MCQ_S a)
{
try
{
DB41Entities db = new DB41Entities();
QuestionPaper s = new QuestionPaper();
s.QuestionID = id;
s.Title = a.Title;
s.Option1 = a.Option1;
s.Option2 = a.Option2;
s.Option3 = a.Option3;
s.Option4 = a.Option4;
db.QuestionPapers.Add(s);
db.SaveChanges();
return(RedirectToAction("ViewAssessment", "Instructor"));
}
catch (Exception e)
{
throw e;
}
}
public async Task <QuestionPaper> GetQuestionPaper(Guid id)
{
QuestionPaper questionPaper = await db.questionPaper.FindAsync(id);
return(questionPaper);
}
