public void enrollStudentToCourse(int courseID, string lastName, string firstName, int grade)
{
Table <Person> tablePerson = db.GetTable <Person>();
Person person = new Person();
person.LastName = lastName;
person.FirstName = firstName;
person.HireDate = null;
person.EnrollmentDate = DateTime.Now;
tablePerson.InsertOnSubmit(person);
db.SubmitChanges();
Table <StudentGrade> studentGradePerson = db.GetTable <StudentGrade>();
StudentGrade studentGrade = new StudentGrade();
studentGrade.CourseID = courseID;
studentGrade.StudentID = person.PersonID;
studentGrade.Grade = grade;
studentGradePerson.InsertOnSubmit(studentGrade);
db.SubmitChanges();
}
/// <summary>
/// Appreciation d'un Note System Francais
/// </summary>
/// <param name="grade"></param>
/// <returns></returns>
public static GradeAppreciations GetAppreciation(this StudentGrade grade)
{
if (Math.Abs(grade.Mark) <= 0)
{
return(GradeAppreciations.Null);
}
if (grade.Mark < 4)
{
return(GradeAppreciations.TrèsMal);
}
if (grade.Mark < 7)
{
return(GradeAppreciations.Mal);
}
if (grade.Mark < 9)
{
return(GradeAppreciations.Mediocre);
}
if (grade.Mark < 12)
{
return(GradeAppreciations.Passable);
}
if (grade.Mark < 14)
{
return(GradeAppreciations.AssezBien);
}
if (grade.Mark < 17)
{
return(GradeAppreciations.Bien);
}
return(grade.Mark < 20 ? GradeAppreciations.TresBien : GradeAppreciations.Excellent);
}
public ActionResult AddNewStudentGrade(StudentGrade model)
{
ViewBag.AlreadyExists = false;
if (ModelState.IsValid)
{
if (model.Id != 0)
{
bool IsUpdated = StudentGrade.Update(model.Id, model.Name);
if (IsUpdated)
{
return(RedirectToAction("Index"));
}
}
else
{
bool isAdded = StudentGrade.AddNew(model.Name, ApplicationHelper.LoggedUserId);
if (isAdded)
{
return(RedirectToAction("Index"));
}
}
ViewBag.AlreadyExists = true;
return(View(model));
}
else
{
return(View(model));
}
}
public void DeterminesAveragesGrade()
{
var g1 = new StudentGrade
{
FirstName = "Imma",
LastName = "Avoro",
LetterGrade = "A",
NumberGrade = 100
};
var g2 = new StudentGrade
{
FirstName = "Erin",
LastName = "Bendor",
LetterGrade = "B",
NumberGrade = 86
};
var g3 = new StudentGrade
{
FirstName = "Jim",
LastName = "Carlos",
LetterGrade = "C",
NumberGrade = 72
};
var grades = new ClassGrades(new[] { g1, g2, g3 });
grades.AverageGrade.Should().Be(86);
}
public async Task <IHttpActionResult> PutStudentGrade(int id, StudentGrade studentGrade)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != studentGrade.StudentGradeId)
{
return(BadRequest());
}
db.Entry(studentGrade).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!StudentGradeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public IHttpActionResult PostStudentGrade(StudentGradeDTO studentGradeDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (studentGradeDTO == null)
{
return(BadRequest("Missing values"));
}
StudentGrade studentGrade = Mapper.Map <StudentGrade>(studentGradeDTO);
StudentGradeRepo.Add(studentGrade);
try
{
StudentGradeRepo.Save();
return(Ok(studentGrade));
}
catch
{
return(BadRequest("Failed to add student grade"));
}
}
public async Task <StudentGrade> GetAsync(int id)
{
StudentGrade item = await context.StudentGrade
.FirstOrDefaultAsync(x => x.EnrollmentId == id);
return(item);
}
public void Add(StudentGrade entity)
{
if (entity != null)
{
context.StudentGrades.Add(entity);
}
}
public async Task <bool> UpdateAsync(StudentGrade paraObject)
{
StudentGrade item = await context.StudentGrade
.FirstOrDefaultAsync(x => x.EnrollmentId == paraObject.EnrollmentId);
if (item == null)
{
return(false);
}
else
{
#region 在這裡需要設定需要更新的紀錄欄位值
//context.Entry(paraObject).State = EntityState.Modified;
#endregion
//
var local = context.Set <StudentGrade>()
.Local
.FirstOrDefault(entry => entry.EnrollmentId.Equals(paraObject.EnrollmentId));
// check if local is not null
if (local != null)
{
// detach
context.Entry(local).State = EntityState.Detached;
}
// set Modified flag in your entry
context.Entry(paraObject).State = EntityState.Modified;
// save
await context.SaveChangesAsync();
return(true);
}
}
public StudentCourseGrade(StudentGrade grade)
{
CourseId = grade.CourseID;
Title = grade.Course.Title;
Credits = grade.Course.Credits;
Grade = grade.Grade.Value;
}
public async Task AddGrade(string userId, int subjectId, int value)
{
var student = await this.data.Users.FirstOrDefaultAsync(u => u.Id == userId);
if (student == null)
{
throw new Exception("Student doesn't exist");
}
var subject = await this.data.Subjects.FirstOrDefaultAsync(s => s.Id == subjectId);
if (subject == null)
{
throw new Exception("Subject doesn't exist");
}
var gradeModel = new StudentGrade
{
StudentId = student.Id,
SubjectId = subjectId,
Grade = value
};
this.data.StudentGrades.Add(gradeModel);
await this.data.SaveChangesAsync();
}
public async Task <IActionResult> AddStudentGrade(int courseId, int studentId, float grade = 0)
{
var course = await nhSession.GetAsync <Course>(courseId);
var student = await nhSession.GetAsync <Student>(studentId);
if (course != null && student != null)
{
return(BadRequest(Json(APIResult.New().WithError("Could not find Course or Student"))));
}
else
{
using (var tr = nhSession.BeginTransaction())
{
var studentGrade = new StudentGrade
{
Course = course,
Student = student,
Grade = grade
};
await nhSession.SaveAsync(studentGrade);
await tr.CommitAsync();
return(Json(APIResult.New().WithSuccess().WithResult(studentGrade)));
}
}
}
public async Task <IActionResult> Post(int courseId, int studentId, [FromBody] float grade)
{
using (var tr = nhSession.BeginTransaction())
{
var course = await nhSession.GetAsync <Course>(courseId);
var student = await nhSession.GetAsync <Student>(studentId);
if (course != null && student != null)
{
var studentGrade = new StudentGrade();
studentGrade.Course = course;
studentGrade.Student = student;
studentGrade.Grade = grade;
await nhSession.SaveAsync(studentGrade);
await tr.CommitAsync();
return(Json(APIResult.New().WithSuccess().WithResult(studentGrade)));
}
else
{
return(BadRequest(Json(APIResult.New().WithError("Either Course or Student does not exist"))));
}
}
}
public async Task <IHttpActionResult> PostStudentGrade(StudentGrade studentGrade)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.StudentGrades.Add(studentGrade);
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateException)
{
if (StudentGradeExists(studentGrade.StudentID))
{
return(Conflict());
}
else
{
throw;
}
}
return(CreatedAtRoute("DefaultApi", new { id = studentGrade.StudentID }, studentGrade));
}
private StudentGrade GetCurrentGradeFor(int rosterId)
{
using (var cn = new SqlConnection(Config.GetConnectionString()))
{
var p = new DynamicParameters();
p.Add("@RosterId", rosterId);
if (
cn.Query <StudentGrade>("GradeCurrent_GetByRosterId", p, commandType: CommandType.StoredProcedure)
.Any())
{
return
(cn.Query <StudentGrade>("GradeCurrent_GetByRosterId", p, commandType: CommandType.StoredProcedure)
.First());
}
else
{
var studentGrade = new StudentGrade();
studentGrade.RosterId = rosterId;
studentGrade.CurrentGrade = null;
return(studentGrade);
}
// return
// cn.Query<StudentGrade>("GradeCurrent_GetByRosterId", p, commandType: CommandType.StoredProcedure).First();
}
}
public void Update(StudentGrade entity)
{
if (entity != null)
{
context.StudentGrades.AddOrUpdate(entity);
}
}
public void Remove(StudentGrade entity)
{
if (entity != null)
{
context.StudentGrades.Remove(entity);
}
}
public ActionResult <Transcript> AddGrade(StudentGrade studentGrade)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
if (!_studentsRepo.Exists(studentGrade.StudentID))
{
return(NotFound("Student not found"));
}
if (!_coursesRepo.Exists(studentGrade.CourseID))
{
return(NotFound("Course not found"));
}
var addedGrade = _repo.AddGrade(studentGrade);
if (addedGrade == null)
{
return(BadRequest("Failed to add grade. Please check request values and try again")); // ideally we would let the consumer know exactly why the request failed
}
return(Created("Grade was added", addedGrade));
}
/// <summary>
///
/// </summary>
/// <param name="myGrade"></param>
/// <returns></returns>
private static bool NoteExist(StudentGrade myGrade)
{
using (var db = new SchoolContext())
return(db.Studies.Find(myGrade.StudentGradeGuid) != null ||
db.StudentGrades.Any(t => t.CoursGuid == myGrade.CoursGuid &&
t.StudentGuid == myGrade.StudentGuid));
}
public static StudentAverageGradeInfo Create(StudentGrade model)
{
return(new StudentAverageGradeInfo
{
StudentId = model.StudentId,
AverageGrade = model.AverageGrade
});
}
public ActionResult Delete(int id)
{
StudentGrade stdGrade = db.StudentGrades.Where(studentGrade => studentGrade.Id == id).FirstOrDefault();
db.StudentGrades.Remove(stdGrade);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public ActionResult Edit(int id)
{
StudentGrade student = db.StudentGrades.Where(stdGrd => stdGrd.Id == id).FirstOrDefault();
ViewBag.students = new SelectList(db.Students.ToList(), "Id", "Name", id);
ViewBag.subjects = new SelectList(db.Subjects.ToList(), "Id", "Name", id);
return(View(student));
}
public async Task <bool> AddAsync(StudentGrade paraObject)
{
await context.StudentGrade.AddAsync(paraObject);
await context.SaveChangesAsync();
return(true);
}
private void BtnAddGrade_Click(object sender, EventArgs e)
{
if (ComboBoxCourse.Text != null && ComboBoxGrades.Text != null && ComboBoxStudents.Text != null)
{
using (var db = new SchoolEntities())
{
var getCourse = from o in db.Course
where o.Title.Equals(ComboBoxCourse.Text)
select o.CourseID;
int courseID = default;
if (getCourse.Any())
{
courseID = getCourse.First();
}
var getStudent = from o in db.Person
where (o.FirstName + " " + o.LastName).Equals(ComboBoxStudents.Text)
select o.PersonID;
int studentID = default;
if (getStudent.Any())
{
studentID = getStudent.First();
}
decimal.TryParse(ComboBoxGrades.Text, out decimal studentGrade);
var grade = new StudentGrade()
{
CourseID = courseID,
StudentID = studentID,
Grade = studentGrade
};
db.StudentGrade.Add(grade);
db.SaveChanges();
DataGridViewGrades.DataSource = db.StudentGrade.ToList();
ComboBoxCourse.SelectedItem = null;
ComboBoxGrades.SelectedItem = null;
ComboBoxStudents.SelectedItem = null;
DataGridViewGrades.Rows[DataGridViewGrades.Rows.Count - 1].Selected = true;
DataGridViewGrades.FirstDisplayedCell = DataGridViewGrades.Rows[DataGridViewGrades.Rows.Count - 1].Cells[0];
}
}
else
{
MessageBox.Show("Please provide all required information.", "Message", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
public void CreateObject_WithCorrectValue_ShouldCreateCorrectObject(double value)
{
// When
var grade = new StudentGrade(value);
// Then
grade.Should().NotBeNull();
grade.Value.Should().Be(value);
}
public ReportSession(Session sessionId, Group groupId, Student studentId, Subject subjectId, ExamType examType, DateTime date, StudentGrade grade)
{
SessionId = sessionId ?? throw new ArgumentNullException(nameof(sessionId));
GroupId = groupId ?? throw new ArgumentNullException(nameof(groupId));
StudentId = studentId ?? throw new ArgumentNullException(nameof(studentId));
SubjectId = subjectId ?? throw new ArgumentNullException(nameof(subjectId));
ExamType = examType;
Date = date;
Grade = grade;
}
public async Task <StudentGrade> GetAsync(int id)
{
StudentGrade item = await context.StudentGrade
.AsNoTracking()
.Include(x => x.Course)
.Include(x => x.Student)
.FirstOrDefaultAsync(x => x.EnrollmentId == id);
return(item);
}
public async Task <bool> AddAsync(StudentGrade paraObject)
{
CleanTrackingHelper.Clean <StudentGrade>(context);
await context.StudentGrade.AddAsync(paraObject);
await context.SaveChangesAsync();
CleanTrackingHelper.Clean <StudentGrade>(context);
return(true);
}
/// <summary>
/// Getting a list of student grade record by student id
/// </summary>
/// <param name="studentId"></param>
/// <returns>
/// a list of student grade
/// </returns>
public StudentGrade GetStudentGradeByIds(int studentId, int courseId)
{
using (IDbConnection connection = new SqlConnection(dbConnection))
{
// geting a list of student grade object using Dapper
StudentGrade studentGrade = connection.QueryFirstOrDefault <StudentGrade>(_getStudentGradeById, new { StudentId = studentId, CourseId = courseId });
return(studentGrade);
}
}
public ActionResult Edit(StudentGrade passedStudentGrade)
{
StudentGrade student = db.StudentGrades.Where(stdGrd => stdGrd.Id == passedStudentGrade.Id).FirstOrDefault();
student.StudentId = passedStudentGrade.StudentId;
student.SubjectId = passedStudentGrade.SubjectId;
student.Degree = passedStudentGrade.Degree;
db.SaveChanges();
return(RedirectToAction("Index"));
}
/// <summary>
/// There are no comments for StudentGrade in the schema.
/// </summary>
public void AddToStudentGrade(StudentGrade studentGrade)
{
base.AddObject("StudentGrade", studentGrade);
}
/// <summary>
/// Create a new StudentGrade object.
/// </summary>
/// <param name="enrollmentID">Initial value of EnrollmentID.</param>
public static StudentGrade CreateStudentGrade(int enrollmentID)
{
StudentGrade studentGrade = new StudentGrade();
studentGrade.EnrollmentID = enrollmentID;
return studentGrade;
}
