public ActionResult Create(GradeModel model)
{
ViewBag.IsCreate = true;
var result = _gradeService.Add(model);
if (!result.Success)
{
return(Error(result));
}
if (result.Success)
{
if (model.Grade1 < GradeThreshold)
{
var status = _alertService.AddTraineeGrade(model.TraineeId);
if (!status.Success)
{
return(Error(status));
}
}
//TODO: Change Index to other action
return(RedirectToAction("Index", new { id = model.TraineeId }));
}
//TODO: What is these lines below supposed to do? If it needs to refer to Error page that is not the way..
var status1 = new StatusModel(false, result.Message);
ModelState.AddModelError(result.Data, result.Message);
return(View(model));
}
public bool SetGrade(GradeModel m)
{
RedisHelper redisHelper = new RedisHelper("127.0.0.1:6379");
string saveGrade = redisHelper.GetValue("saveGrade");
bool flag = false;
List <GradeModel> grades = null;
if (saveGrade != "[]")
{
grades = JsonConvert.DeserializeObject <List <GradeModel> >(saveGrade);
GradeModel grade = grades.Find(a => a.GName == m.GName);
if (grade != null)
{
grades.Remove(grade);
}
}
else
{
grades = new List <GradeModel>();
}
grades.Add(m);
grades = (from g in grades orderby g.GSize ascending select g).ToList();
flag = redisHelper.SetValue("saveGrade", JsonConvert.SerializeObject(grades));
return(flag);
}
public int AddGrade(GradeModel grade)
{
ValidateGrade(grade);
_gradeRepository.AddedGrade += _note.OnGradeAdded;
return(_gradeRepository.AddGrade(grade));
}
public IActionResult AddG(GradeModel model)
{
if (ModelState.IsValid)
{
var student = StudentManager.GetAll().FirstOrDefault(c => c.Name == model.StudentName && c.Surname == model.StudentSurname);
var subject = SubjectManager.GetAll().FirstOrDefault(c => c.Name == model.SubjectName);
//model.Subject = SubjectController.Subjects.Find(s => s.Name == model.SubjectName);
//model.Student = StudentController.Students.Find(s => s.Name == model.StudentName && s.Surname == model.StudentSurname);
if (student == null)
{
ModelState.AddModelError("stu", "Skolnieks nav atrasts!");
}
else if (subject == null)
{
ModelState.AddModelError("sub", "Priekšmets nav atrasts!");
}
else if (model.Grade < 1 || model.Grade > 10)
{
ModelState.AddModelError("gra", "Atzīmei jābūt intervālā no 1 līdz 10!");
}
else
{
GradeManager.Create(model.Grade, model.Comment, student.Id, subject.Id);
return(RedirectToAction(nameof(IndexG)));
}
}
return(View(model));
}
public ReportModel GetReportForUser(int userId)
{
var user = ctx.Users.Single(p => p.UserId == userId);
var gradesDB = ctx.Enrollments.Where(p => p.UserId == userId);
ReportModel report = new ReportModel();
report.userId = user.UserId;
report.studentId = user.StudentIdNumber;
report.studentName = user.LastName + " " + user.FirstName;
report.currentDateTime = DateTime.Now.ToLongDateString() + DateTime.Now.ToLongTimeString();
report.timeStamp = DateTime.Now;
List <GradeModel> grades = new List <GradeModel>();
foreach (var item in gradesDB)
{
GradeModel grade = new GradeModel()
{
Subject = ctx.Subjects.Single(p => p.SubjectId == item.SubjectId).SubjectName,
Grade = item.Grade ?? 0
};
grades.Add(grade);
}
report.averageMark = gradesDB.Sum(p => p.Grade ?? 0) / gradesDB.Count();
report.grades = grades;
return(report);
}
public void Grades_Controller_Test_On_EditModel_With_Invalid_Model()
{
//Arrange
Guid id = new Guid("f616cc8c-2223-4145-b7d0-232a1f6f0795");
int value = 10;
DateTime date = DateTime.Now;
Grade expectedGrades = new Grade(value, date);
expectedGrades.Id = id;
GradeModel expectedModel = new GradeModel();
expectedModel.Value = 1;
var repo = Substitute.For <IRepository>();
var sut = new GradesController(repo);
repo.Update(expectedGrades);
//Act
sut.ModelState.AddModelError("FirstName", "Firstname Required");
var actual = sut.Edit(id, expectedGrades).Result;
//Assert
Assert.IsInstanceOfType(actual, typeof(ViewResult));
}
public void Grades_Controller_Test_On_EditModel_With_Invalid_Id()
{
//Arrange
Guid id = new Guid("f616cc8c-2223-4145-b7d0-232a1f6f0795");
int value = 10;
DateTime date = DateTime.Now;
Grade expectedGrades = new Grade(value, date);
expectedGrades.Id = id;
GradeModel expectedModel = new GradeModel();
Guid faultId = new Guid("1e4966f0-68f7-4f24-9f4f-53d528787be5");
expectedModel.Value = 1;
var repo = Substitute.For <IRepository>();
var sut = new GradesController(repo);
repo.Update(expectedGrades);
//Act
var actual = sut.Edit(faultId, expectedGrades).Result;
//Assert
Assert.IsInstanceOfType(actual, typeof(NotFoundResult));
}
public IActionResult Add(GradeModel model)
{
if (ModelState.IsValid)
{
var sub = GradeManager.FindSub(model.SubjectTitle);
var name = GradeManager.FindName(model.PupilsName);
var surname = GradeManager.FindSurname(model.PupilsSurname);
if (name != null && surname != null && sub != null && model.Grade > 0 && model.Grade < 11)
{
GradeManager.Create(model.Grade, model.Description, model.PupilsName, model.PupilsSurname, model.SubjectTitle);
return(RedirectToAction("Index"));
}
else if (name == null || surname == null)
{
ModelState.AddModelError("pup", "Pupil is not found!");
}
else if (sub == null)
{
ModelState.AddModelError("sub", "Subject is not found!");
}
else if (model.Grade < 0 || model.Grade > 10)
{
ModelState.AddModelError("gra", "Grade has to be from 0 - 10!");
}
}
return(View(model));
}
public ResponseModel <string> EditGrade(GradeModel gradeModel)
{
ResponseModel <string> responseModel = new ResponseModel <string>();
try
{
using (IDbConnection connection = new System.Data.SqlClient.SqlConnection(GlobalConfig.CnnString(userAccess)))
{
var p = new DynamicParameters();
p.Add("@GradeID", gradeModel.GradeID);
p.Add("@Grade", gradeModel.Grade);
p.Add("@GradeDate", DateTime.UtcNow);
p.Add("@GradeNotes", gradeModel.GradeNotes);
responseModel.Model = connection.Query <string>("dbo.spGrades_Update", p, commandType: CommandType.StoredProcedure).FirstOrDefault();
responseModel.IsSuccess = true;
}
}
catch (Exception e)
{
responseModel.OutputMessage = e.Message;
}
return(responseModel);
}
protected List <GradeModel> ConvertToGradeMode(FormCollection forms)
{
List <GradeModel> results = new List <GradeModel>();
foreach (string key in forms.Keys)
{
var values = forms.GetValues(key);
for (int i = 0; i < values.Length; i++)
{
if (key == "GradeName")
{
var g = new GradeModel();
g.GradeName = values[i];
results.Add(g);
}
else if (key == "Min")
{
var g = results[i];
g.Min = int.Parse(values[i]);
}
else if (key == "Max")
{
var g = results[i];
g.Max = int.Parse(values[i]);
}
}
}
return(results);
}
public ActionResult Index()
{
try
{
var Grade = Connection.GDgetAllGradeMaintenance("Y");
List <GDgetAllGradeMaintenance_Result> Gradelist = Grade.ToList();
GradeModel tcm = new GradeModel();
List <GradeModel> tcmlist = Gradelist.Select(x => new GradeModel
{
GradeId = x.GradeId,
GradeName = x.GradeName,
CreatedBy = x.CreatedBy,
CreatedDate = x.CreatedDate,
IsActive = x.IsActive,
ModifiedBy = x.ModifiedBy,
ModifiedDate = x.ModifiedDate
}).ToList();
return(View(tcmlist));
}
catch (Exception ex)
{
Errorlog.ErrorManager.LogError(ex);
return(View());
}
}
private IEnumerable <GradeModel> GetSampleGrade(GradeModel grade = null)
{
List <GradeModel> common = new List <GradeModel>()
{
new GradeModel()
{
Id = 0, Grade = 3, Date = DateTime.Now, LectionId = 1, StudentId = 2
},
new GradeModel()
{
Id = 1, Grade = 1, Date = DateTime.Now, LectionId = 2, StudentId = 1
},
new GradeModel()
{
Id = 2, Grade = 2, Date = DateTime.Now, LectionId = 3, StudentId = 3
}
};
if (grade != null)
{
common.Add(grade);
}
//var result = from commonModel in common group commonModel by commonModel.St_Last_Name;
return(common);
}
private void ApplyGrades()
{
bool isNewGrade = applyButton.Tag.Equals("Add");
List <GradeModel> currentGrades = gradeDataGridView.DataSource as List <GradeModel>;
StudentService.GradeModel gradeModel = new StudentService.GradeModel
{
StudentID = selectedStudent.StudentID,
TeacherID = selectedTeacher.TeacherID,
Grade = gradeComboBox.SelectedItem.ToString(),
GradeNotes = gradeNotesTextBox.Text
};
if (gradeDataGridView.SelectedRows.Count == 1)
{
int rowindex = gradeDataGridView.SelectedRows[0].Index;
GradeModel selectedGrade = currentGrades[rowindex];
gradeModel.GradeID = selectedGrade.GradeID;
}
ResponseModel <string> gradeResponseModel = new ResponseModel <string>();
gradeResponseModel = encryptor.ResponseDeserializer <string>
(studentService.ModifyGrades(isNewGrade, gradeModel, currentUser.AccessToken));
if (!gradeResponseModel.IsSuccess)
{
Program.outputMessage += gradeResponseModel.OutputMessage + "\n";
CheckResponseError(gradeResponseModel.ErrorAction);
}
}
public Task <int> InsertAsync(GradeModel model)
{
model.FlagForCreate(_identityProvider.Username, UserAgent);
_dbSet.Add(model);
return(_dbContext.SaveChangesAsync());
}
public ActionResult Edit(int id, GradeModel grade)
{
try
{
// TODO: Add update logic here
if (ModelState.IsValid)
{
var dbGrade = _dbContext.Grades.FirstOrDefault(g => g.Id == id);
dbGrade.GradeName = grade.GradeName;
dbGrade.Max = grade.Max;
dbGrade.Min = grade.Min;
_dbContext.SaveChanges();
return(RedirectToAction("Index"));
}
}
catch
{
return(View(grade));
}
return(View(grade));
}
public ActionResult GradeIndex()
{
GradeModel gModel = new GradeModel();
gModel.GradeList = _iSetupService.GetGradeList();
return(View(gModel));
}
//TODO:Fix this :
public ActionResult Create(int traineeId) //,int semesterNumber )
{
ViewBag.IsCreate = true;
var model = new GradeModel {
TraineeId = traineeId
}; //, SemesterNumber = semesterNumber};
return(View(model));
}
public Task <int> UpdateAsync(int id, GradeModel model)
{
var modelToUpdate = _dbSet.FirstOrDefault(s => s.Id == id);
modelToUpdate.SetType(model.Type, _identityProvider.Username, UserAgent);
modelToUpdate.SetCode(model.Code, _identityProvider.Username, UserAgent);
modelToUpdate.SetIsAvalGrade(model.IsAvalGrade, _identityProvider.Username, UserAgent);
return(_dbContext.SaveChangesAsync());
}
public ActionResult CreateGrade(int?gradeId)
{
GradeModel gModel = new GradeModel();
if (gradeId != null)
{
gModel = _iSetupService.GetGradeList().Where(x => x.GradeId == gradeId).FirstOrDefault();
}
return(PartialView("_CreateGrade", gModel));
}
public IActionResult GradeRespons(IFormCollection Collection)
{
int GradeValue = Convert.ToInt32(Collection["Grade"]);
string GradeText = GradeList[GradeValue].Text;
GradeModel gm = new GradeModel(GradeValue, GradeText);
ViewBag.FirstRespons = gm.GetFirstLineRespons();
ViewBag.SecondRespons = gm.GetSecondLineRespons();
return(View());
}
public DetailedCourseModel findCourseDetail(UserModel user, GeneralCourseModel course)
{
// Here lookup for the user id and a desired course id (I assume thats the way the restful server handles this query
GradeModel grade1 = new GradeModel("Examen 1", 5.0, 25);
GradeModel grade2 = new GradeModel("Examen 2", 5.0, 25);
GradeModel grade3 = new GradeModel("Examen 3", 5.0, 25);
GradeModel grade4 = new GradeModel("Examen 4", 5.0, 25);
GradeModel[] grades = new GradeModel[] { grade1, grade2, grade3, grade4 };
return(new DetailedCourseModel(course.Id, course.Name, course.Classrooms, course.Teachers, course.Dates, grades));
}
public static void ValidateGrade(GradeModel grade)
{
if (grade == null)
{
throw new ArgumentNullException(nameof(grade));
}
if ((grade.Grade < 0 || grade.Grade > 5))
{
Log.MakeLog(LoggerOperations.Error, "InvalidGradeException");
throw new InvalidGradeException(grade.Grade);
}
}
internal Grade(Api api, GradeModel model)
{
_api = api;
HtmlUrl = model.HtmlUrl;
CurrentGrade = model.CurrentGrade;
FinalGrade = model.FinalGrade;
CurrentScore = model.CurrentScore;
FinalScore = model.FinalScore;
UnpostedCurrentGrade = model.UnpostedCurrentGrade;
UnpostedFinalGrade = model.UnpostedFinalGrade;
UnpostedCurrentScore = model.UnpostedCurrentScore;
UnpostedFinalScore = model.UnpostedFinalScore;
}
// GET: Grade/Create
public ActionResult Create()
{
GradeModel model = new GradeModel();
model.Grades = Utility.getLookupByName("GRADE");
model.Teachers = Utility.getTeachersNameValue();
model.Schools = Utility.getSchoolsNameValue();
return(View(model));
}
public string AddGrade([FromBody] dynamic Json)
{
GradeModel gradeModel = new GradeModel();
gradeModel.userno = HttpContext.Session.GetString("user");
gradeModel.paperid = Json.papers;
gradeModel.grade = Json.grade;
Debug.WriteLine(gradeModel.grade + "!!!!!!!!!!!!");
gradeRepository.Insert(gradeModel);
return(null);
}
public ActionResult CreateGrade(GradeModel gModel)
{
if (ModelState.IsValid)
{
var result = _iSetupService.CreateGrade(gModel);
return(Json(result, JsonRequestBehavior.AllowGet));
}
else
{
return(Json(rModel, JsonRequestBehavior.AllowGet));
}
}
public ActionResult Delete(string Code)
{
try
{
GradeModel TModel = new GradeModel();
TModel.GradeId = Code;
return(PartialView("DeleteView", TModel));
}
catch (Exception ex)
{
Errorlog.ErrorManager.LogError(ex);
return(View());
}
}
public int Insert(GradeModel item)
{
string cmdText = "INSERT INTO grade (`userno`, `paperid`, `grade`) VALUES (?userno, ?paperid,?grade);";
MySqlParameter[] param = new MySqlParameter[] {
new MySqlParameter("?userno", MySqlDbType.String),
new MySqlParameter("?paperid", MySqlDbType.Int32),
new MySqlParameter("?grade", MySqlDbType.Int32),
};
param[0].Value = item.userno;
param[1].Value = item.paperid;
param[2].Value = item.grade;
return(MysqlHelper.ExecuteNonQuery(cmdType, cmdText, param));
}
public List <GradeModel> procentajNote(int idUtilizator)
{
SqlConnection conn = db.initializare();
SqlCommand cmd;
List <GradeModel> gradeList = new List <GradeModel>();
GradeModel exam = null;
try
{
cmd = new SqlCommand(Query.getGradeByIdOfStudent, conn);
cmd.Parameters.Add(new SqlParameter("idUtilizator", idUtilizator));
reader = cmd.ExecuteReader();
int contor = 0;
if (reader.HasRows)
{
while (reader.Read())
{
// exam = new GradeModel(idExam, idSpecializare, idMaterie, data, timp, oraExamen, numeSpecializare, numeMaterie, anStudiu);
// [nota]
// ,a.[semestru]
// ,a.[an_studiu]
//,b.nume_materie
//,c.nume,c.prenume
int nota = Int32.Parse(reader["nota"].ToString());
int semestru = Int32.Parse(reader["semestru"].ToString());
int anStudiu = Int32.Parse(reader["an_studiu"].ToString());
string numeMaterie = reader["nume_materie"].ToString();
string nume = reader["nume"].ToString();
string prenume = reader["prenume"].ToString();
if (nota >= 5)
{
contor++;
}
exam = new GradeModel(nume, prenume, numeMaterie, nota, semestru, anStudiu, contor);
gradeList.Add(exam);
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
conn.Dispose();
conn.Close();
}
return(gradeList);
}
public ActionResult Details(int id, GradeModel grade)
{
try
{
var dbGrade = _dbContext.Grades.FirstOrDefault(g => g.Id == id);
return(View(grade));
return(RedirectToAction("Index"));
}
catch
{
return(View(grade));
}
}
public HttpResponseMessage SaveGrade(GradeModel grade)
{
HttpResponseMessage response = new HttpResponseMessage(HttpStatusCode.OK);
UserPrincipal loggedInUser = (UserPrincipal)HttpContext.Current.User;
grade.ClubId = loggedInUser.AccountSession.ClubId;
grade = GradeModel.MapGradeModel(GradingAdminBLL.SaveGrade(GradeModel.MapGradeDal(grade)), true);
response.Content = new ObjectContent<GradeModel>(grade, new JsonMediaTypeFormatter());
return response;
}