public IActionResult GetMarks()
{
List <MarksModel> marks = new List <MarksModel>(); //list
try
{
using (SqlConnection connection = new SqlConnection("Data Source=dev;Initial Catalog=Test;Persist Security Info=True;User ID=sa;Password=admin@123"))
{
connection.Open();
SqlCommand command = new SqlCommand("SP_GetMarks", connection);
using (SqlDataReader dataReader = command.ExecuteReader())
{
while (dataReader.Read())
{
MarksModel mark = new MarksModel(); // model name(same table coloumn)
mark.STUDENT_ID = new Guid(dataReader["STUDENT_ID"].ToString());
mark.M1 = Convert.ToInt32(dataReader["M1"]);
mark.M2 = Convert.ToInt32(dataReader["M2"]);
mark.M3 = Convert.ToInt32(dataReader["M3"]);
mark.DATE = Convert.ToDateTime(dataReader["DATE"]);
marks.Add(mark); //add each row to list
}
}
}
}
catch (Exception ex)
{
throw;
}
return(Ok(marks));
}
public IActionResult InsertMark([FromBody] MarksModel marks)
{
try
{
using (SqlConnection connection = new SqlConnection("Data Source=dev;Initial Catalog=Test;Persist Security Info=True;User ID=sa;Password=admin@123"))
{
using (SqlCommand cmd = new SqlCommand("SP_Insertmark", connection))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@student_id", marks.STUDENT_ID);
cmd.Parameters.AddWithValue("@m1", marks.M1);
cmd.Parameters.AddWithValue("@m2", marks.M2);
cmd.Parameters.AddWithValue("@m3", marks.M3);
connection.Open();
cmd.ExecuteNonQuery();
connection.Close();
}
}
return(Ok());
}
catch (Exception)
{
throw;
}
}
public async Task <IActionResult> Create(MarksModel employeeModel)
{
if (ModelState.IsValid)
{
await _repo.Insert(employeeModel);
return(RedirectToAction(nameof(Index)));
}
return(View(employeeModel));
}
public async Task <IActionResult> Post(MarksModel marksModel) //create
{
if (ModelState.IsValid)
{
await _context.Insert(marksModel);
return(Ok());
}
return(BadRequest(marksModel));
}
public async Task <IActionResult> Post(MarksModel employeeModel)
{
if (ModelState.IsValid)
{
await _repo.Insert(employeeModel);
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> Post(MarksModel marksModel)
{
if (ModelState.IsValid)
{
_context.Add(marksModel);
await _context.SaveChangesAsync();
return(Ok("Added Student Marks Succesfully"));
}
return(BadRequest("Can't Perform operation"));
}
/// <summary>
/// Author: Kushal Yadav
/// Date: 24/10/18
/// Updating test logs
/// </summary>
/// <param name="userTestID">userTestID</param>
public bool UpdateTestLog(int userTestID)
{
try
{
var query = from u in context.users
join ut in context.userTests
on u.userID equals ut.userID
join uta in context.userTestAnswers
on ut.userTestID equals uta.userTestID
join q in context.questions
on uta.questionID equals q.questionID
join t in context.topics
on q.topicID equals t.topicID
where uta.answerMarked == q.answer && ut.userTestID == userTestID
group q.marks by t.topicID into g
select new MarksModel {
topicID = g.Key, Marks = g.Sum()
};
int count = context.testLogs.Count();
var testLog = context.testLogs.FirstOrDefault(tl => tl.userTestID == userTestID);
if (testLog != null)
{
foreach (var item in context.testLogs.Where(ut => ut.userTestID == userTestID))
{
MarksModel topicMarks = query.Where(tpcID => tpcID.topicID == item.topicID).FirstOrDefault();
if (topicMarks == null)
{
item.marksScored = 0;
}
else
{
item.marksScored = topicMarks.Marks;
}
}
var testLog01 = context.testLogs.FirstOrDefault(tl => tl.userTestID == userTestID && tl.testEnded == null);
testLog01.testEnded = DateTime.Now;
if (context.SaveChanges() > 0)
{
return(true);
}
}
return(false);
}
catch (SqlException)
{
throw;
}
catch (Exception)
{
throw;
}
}
public async Task Insert(string studId, string subjId, int marks)
{
// _context.Set<T>().Add(entity);
var a = new MarksModel();
// a..Id = "dghsafvagab502";
a.Marks = marks;
a.StudId = studId;
a.Subjid = subjId;
_context.Add(a);
await _context.SaveChangesAsync();
}
public async Task <IActionResult> Post(MarksModel MarkModel, string id, string subname)
{
if (ModelState.IsValid)
{
MarkModel.ID = id;
MarkModel.SubName = subname;
await _repo.Insert(MarkModel);
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> Delete(MarksModel marksModel)
{
List <MarksModel> marks = await _context.Marks.ToListAsync();
marks = marks.Where(m => m.Student_ID == marksModel.Student_ID && m.Subject_ID == marksModel.Subject_ID).ToList();
if (marks.Count != 0)
{
_context.Marks.Remove(marks[0]);
await _context.SaveChangesAsync();
return(Ok("Deleted record Succesfully"));
}
return(BadRequest("No such data found"));
}
public async Task <IActionResult> Put(MarksModel marksModel) //edit
{
if (string.IsNullOrEmpty(marksModel.ID))
{
return(BadRequest());
}
if (ModelState.IsValid)
{
await _context.Update(marksModel);
return(Ok(marksModel));
}
return(BadRequest());
}
public async Task <IActionResult> Edit(string id, MarksModel employeeModel)
{
if (id != employeeModel.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
await _repo.Update(employeeModel);
return(RedirectToAction(nameof(Index)));
}
return(View(employeeModel));
}
public async Task <IActionResult> Put(MarksModel employeeModel)
{
if (string.IsNullOrEmpty(employeeModel.ID))
{
return(BadRequest());
}
if (ModelState.IsValid)
{
await _repo.Update(employeeModel);
return(Ok(employeeModel));
}
return(BadRequest());
}
private List <MarksModel> GetMarks(Student Student)
{
List <MarksModel> mrk = new List <MarksModel>();
foreach (var marks in Student.StudentMarks)
{
MarksModel marksModel = new MarksModel()
{
Marks = marks.Marks,
SubjectID = marks.SubjectID,
SubjectName = marks.Subject.Name
};
mrk.Add(marksModel);
}
return(mrk);
}
public async Task <IActionResult> Update(MarksModel marksModel)
{
List <MarksModel> marks = await _context.Marks.ToListAsync();
marks = marks.Where(m => m.Student_ID == marksModel.Student_ID && m.Subject_ID == marksModel.Subject_ID).ToList();
if (marks.Count != 0)
{
marks[0].Student_Marks = marksModel.Student_Marks;
_context.Update(marks[0]);
await _context.SaveChangesAsync();
return(Ok(marks));
}
return(BadRequest("No Data Found"));
}
private List <MarksModel> GetMarks(Student StudentID)
{
List <MarksModel> mrk = new List <MarksModel>();
foreach (var marks in StudentID.StudentMarks.Where(x => x.Deleted == false))
{
MarksModel marksModel = new MarksModel()
{
Marks = marks.Marks,
SubjectID = marks.SubjectID,
SubjectName = marks.Subject.Name
};
mrk.Add(marksModel);
}
return(mrk);
}
public IActionResult Index()
{
if (User.IsInRole("Teacher"))
{
return(RedirectToAction("TeacherIndex"));
}
var sub = _dbcontext.Subject.Where(x => x.UserId == User.FindFirstValue(ClaimTypes.NameIdentifier));
List <MarksModel> marks = new List <MarksModel>();
foreach (var item in sub)
{
var studentMarks = _dbcontext.Marks.SingleOrDefault(x => x.UserId == User.FindFirstValue(ClaimTypes.NameIdentifier) && x.SubjectId == item.SubjectId);
var studentMark = new MarksModel();
studentMark.SubjectN.SubjectName = item.SubjectName;
studentMark.Marks = studentMarks.Mark;
marks.Add(studentMark);
}
return(View(marks));
}
public IActionResult Update(int studentId, int courseId, [FromBody] MarksModel model)
{
var mark = marksRepository.GetById(studentId, courseId);
if (mark == null)
{
return(NotFound("Mark does not exist for this student."));
}
if (model.MarkValue < 6 || model.MarkValue > 10)
{
return(BadRequest("Invalid mark. Allowed values: 6 - 10"));
}
mark.MarkValue = model.MarkValue;
marksRepository.Save();
return(new NoContentResult());
}
public IActionResult Add(int studentId, int courseId, [FromBody] MarksModel model)
{
var student = studentRepository.GetById(studentId);
if (student == null)
{
return(NotFound("Student does not exist."));
}
var course = courseRepository.GetById(model.CourseCode);
if (course == null)
{
return(NotFound("Course does not exist."));
}
var existingMark = marksRepository.Find(m => m.StudentId == model.StudentId && m.CourseCode == model.CourseCode).FirstOrDefault();
if (existingMark != null)
{
return(BadRequest("Student already has that mark entered."));
}
if (model.MarkValue < 6 || model.MarkValue > 10)
{
return(BadRequest("Invalid mark. Allowed values: 6 - 10"));
}
var mark = new Marks
{
StudentId = model.StudentId,
CourseCode = model.CourseCode,
MarkValue = model.MarkValue
};
marksRepository.Insert(mark);
marksRepository.Save();
return(CreatedAtRoute("GetMark", new { studentId = mark.StudentId, courseId = mark.CourseCode }, mark));
}
private List <MarksModel> PrepareMarksList(List <MarksModel> marks, int StudentID)
{
DuckTaleInterviewDBEntities _db = new DuckTaleInterviewDBEntities();
List <StudentMark> stdmarks;
using (_db)
{
foreach (MarksModel model in marks)
{
StudentMark studentMark = new StudentMark()
{
Marks = model.Marks,
StudentID = StudentID,
SubjectID = model.SubjectID,
Deleted = false
};
_db.StudentMarks.Add(studentMark);
_db.SaveChanges();
}
stdmarks = _db.StudentMarks.Where(x => x.StudentID == StudentID).Where(x => x.Deleted == false).ToList();
}
List <MarksModel> mModel = new List <MarksModel>();
foreach (var m in stdmarks)
{
MarksModel marksModel = new MarksModel()
{
Marks = m.Marks,
SubjectID = m.SubjectID,
SubjectName = GetSubjectName(m.SubjectID)
};
mModel.Add(marksModel);
}
return(mModel);
}
