protected async Task <StudentResource> GivenAnExistingStudent(StudentResource resource)
{
var response = await Post(string.Format(EndPoints.STUDENT_POST_END_POINT), resource);
response.IsSuccessStatusCode.Should().BeTrue();
return(await response.DeserializeJsonContextAsync <StudentResource>());
}
public async Task GetStudent_Found()
{
var newStudent = new StudentResource
{
FirstName = "StudentName",
LastName = "StudentLastName",
AdmissionGrade = 9,
Faculty = "TestFaculty",
PassGrade = 8,
StudyYear = 3
};
var response = await GivenAnExistingStudent(newStudent);
await WhenIExecuteAGetRequest(response.Id);
ThenTheReturnedStatusIs(HttpStatusCode.OK);
var actualResponse = await GetResponseBody <StudentResource>();
var expectedResponse = new StudentResource
{
Id = response.Id,
FirstName = "StudentName",
LastName = "StudentLastName",
AdmissionGrade = 9,
Faculty = "TestFaculty",
PassGrade = 8,
StudyYear = 3
};
ThenTheResourcesMatchProperties(actualResponse, expectedResponse);
}
public IActionResult AddStudent(StudentResource studentResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
else
{
var response = this.studentService.SingleOrDefault(s => s.StudentNo == studentResource.StudentNo);
if (response.Success)
{
return(BadRequest(new ErrorMessageCode().AlreadyExistEntity));
}
else
{
Student student = mapper.Map <StudentResource, Student>(studentResource);
/*
* var resp = this.studentService.AddStudent(student);
* if (resp.Success) {
* return NoContent();
* }
*
* return BadRequest(resp.ErrorMessageCode);
*/
var resp = this.studentService.Add(student);
if (resp.Success)
{
return(NoContent());
}
return(BadRequest(resp.ErrorMessageCode));
}
}
}
public IActionResult UpdateStudent(StudentResource studentResource)
{
Student student = mapper.Map <StudentResource, Student>(studentResource);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
else
{
/*
* var response = this.studentService.Remove(student);
* if (response.Success) {
* student.Id = 0;
* var stu = this.studentService.Add(student);
* if (stu.Success) {
* return NoContent();
* }
* return BadRequest(stu.ErrorMessageCode);
* }
* return BadRequest(response.ErrorMessageCode);
*/
var response = this.studentService.UpdateStudent(student);
if (response.Success)
{
return(NoContent());
}
return(BadRequest(response.ErrorMessageCode));
}
}
public async Task <IActionResult> UpdateStudent(int id, [FromBody] StudentResource studentResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var student = await studentRepository.GetStudent(id);
if (student == null)
{
return(NotFound());
}
mapper.Map <StudentResource, Student>(studentResource, student);
studentRepository.UpdateEnrollments(student, studentResource);
var major = await majorRepository.GetMajor(studentResource.MajorId);
student.Major = major;
await unitOfWork.Complete();
var result = mapper.Map <Student, StudentResource>(student);
return(Ok(result));
}
public IActionResult AddStudent([FromBody] StudentResource studentResource)
{
try {
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
else
{
Student student = mapper.Map <StudentResource, Student>(studentResource);
var st = this._StudentRepo.AddStudent(student);
if (st != null)
{
return(Ok(new ApiResponse <Student> {
Status = true, Entry = st
}));
}
return(BadRequest(new ApiResponse <Student> {
Status = false, Entry = null
}));
}
}
catch (Exception ex) {
_Logger.LogError(ex.Message);
Console.WriteLine("HATA MESAJI" + ex.Message);
return(BadRequest(new ApiResponse <Student> {
Status = false, Entry = null
}));
}
}
public ActionResult DeleteConfirmed(int id)
{
StudentResource studentResource = db.StudentResources.Find(id);
db.StudentResources.Remove(studentResource);
db.SaveChanges();
return(RedirectToAction("ManageResources"));
}
public ActionResult Post(StudentResource student, int classId)
{
if (!ModelState.IsValid)
{
return(BadRequest("Data Invalid."));
}
_studentClassService.add(student, classId);
return(Ok());
}
public bool add(StudentResource student, int classId)
{
_studentClassManager.add(new Student
{
StudentName = student.StudentName
}, classId);
_studentClassManager.SaveChange();
return(true);
}
public bool add(StudentResource student)
{
_studentManager.add(new Student
{
StudentName = student.StudentName
});
_studentManager.SaveChange();
return(true);
}
// public async Task<ActionResult<StudentResource>> add(StudentResource student)
// {
// _context.Students.Add(student);
// await _context.SaveChangesAsync();
// return CreatedAtAction(nameof(getAll), new { id = student.StudentId }, student);
// }
public bool update(StudentResource student)
{
_studentManager.update(new Student {
StudentId = student.StudentId,
StudentName = student.StudentName
});
_studentManager.SaveChange();
return(true);
}
public ActionResult <StudentResource> Put(StudentResource student)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
_studentClassService.update(student);
return(Ok());
}
public async Task <IActionResult> updateStudent(int id, StudentResource resource)
{
var student = await IStudent.getStudent(id);
mapper.Map <StudentResource, Students>(resource, student);
IStudent.Saver();
return(Ok(mapper.Map <Students, StudentResource>(student)));
}
public async Task <IActionResult> EditStudent(int id, [FromBody] StudentResource resource)
{
if (id == 0 && !ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var result = await studentService.UpdateStudent(id, resource);
return(Ok(result));
}
public ActionResult Edit([Bind(Include = "ID,Topic,URL,DisplayText,UserID")] StudentResource studentResource)
{
if (ModelState.IsValid)
{
db.Entry(studentResource).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("ManageResources"));
}
ViewBag.UserID = new SelectList(db.BTTUsers, "ID", "FirstName", studentResource.UserID);
return(View(studentResource));
}
public async Task <Student> UpdateStudent(int id, StudentResource resource)
{
var student = await this.studentRepository.GetStudentById(id);
student.FirstName = resource.firstName;
student.LastName = resource.lastName;
student.Age = resource.age;
student.GPA = Convert.ToDouble(resource.gpa);
await this.studentRepository.Save();
return(student);
}
public ActionResult Post(StudentResource student)
{
if (!ModelState.IsValid)
{
return(BadRequest("Data Invalid."));
}
_studentService.add(student);
// // context.Students.Add(new Student()
// // {
// // StudentName = student.StudentName
// // });
// // await context.SaveChangesAsync();
return(Ok());
}
public ActionResult Delete(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
StudentResource studentResource = db.StudentResources.Find(id);
if (studentResource == null)
{
return(HttpNotFound());
}
return(View(studentResource));
}
public void UpdateEnrollments(Student student, StudentResource studentResource)
{
if (studentResource.Enrollments != null && studentResource.Enrollments.Count >= 0)
{
//remove old enrollments
student.Enrollments.Clear();
//add new enrollments
var newEnrollments = context.Enrollments.Where(e => studentResource.Enrollments.Any(id => id == e.EnrollmentId)).ToList();
foreach (var e in newEnrollments)
{
student.Enrollments.Add(e);
e.Student = student;
}
}
}
public async Task <IActionResult> Create([FromBody] StudentResource studentResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Student student = mapper.Map <Student>(studentResource);
context.Students.Add(student);
await context.SaveChangesAsync();
var result = mapper.Map <StudentResource>(student);
return(Ok(result));
}
public async Task <StudentResource> getSDetails(int id)
{
var res = await IStudent.getTeacherStudent(id, true);
var final = new StudentResource();
var temp = mapper.Map <List <TeacherStudent>, List <TeacherStudentResource> >(res);
final.PersonalInfo = temp[0].Student.PersonalInfo;
final.StudentId = Convert.ToInt32(temp[0].StudentId);
foreach (var i in temp)
{
final.teacherInfo.Add(await GetTeacher(Convert.ToInt32(i.TeacherId)));
}
return(final);
}
public async Task <Student> CreateStudent(StudentResource resource)
{
var student = new Student
{
ClassId = resource.classId,
FirstName = resource.firstName,
LastName = resource.lastName,
Age = resource.age,
GPA = resource.gpa
};
await this.studentRepository.Insert(student);
await this.studentRepository.Save();
return(student);
}
public async Task <IActionResult> CreateStudent([FromBody] StudentResource studentResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var student = mapper.Map <StudentResource, Student>(studentResource);
var major = await majorRepository.GetMajor(studentResource.MajorId);
student.Major = major;
var user = new ApplicationUser
{
FullName = student.Name,
Email = student.Email,
Avatar = "/assets/images/user.png",
Major = student.Major.MajorName,
UserName = student.Email
};
if (RoleExists("Student"))
{
//Check Student Existence
if (!StudentExists(user.Email) && !StudentIdExists(student.StudentCode))
{
var password = student.StudentCode.ToString(); // Password Default
await userManager.CreateAsync(user, password);
await userManager.AddToRoleAsync(user, "Student");
}
}
studentRepository.AddStudent(student);
await unitOfWork.Complete();
student = await studentRepository.GetStudent(student.Id);
await hubContext.Clients.All.InvokeAsync("LoadData");
var result = mapper.Map <Student, StudentResource>(student);
return(Ok(result));
}
public async Task <IActionResult> CreateStudent([FromBody] StudentResource studentResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var student = mapper.Map <StudentResource, Student>(studentResource);
repository.Add(student);
await unitOfWork.CompleteAsync();
// student = await repository.GetStudentAsync(student.StudentId);
// var result = mapper.Map<Student, StudentResource>(student);
// retornamos 201
return(CreatedAtAction(nameof(GetStudent), new { id = student.StudentId }, student));
}
public ActionResult Edit(int?id)
{
var userID = User.Identity.GetUserId();
ViewBag.CurrentUserID = db.BTTUsers.Where(m => m.ASPNetIdentityID.Equals(userID)).FirstOrDefault().ID;
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
StudentResource studentResource = db.StudentResources.Find(id);
if (studentResource == null)
{
return(HttpNotFound());
}
ViewBag.UserID = new SelectList(db.BTTUsers, "ID", "FirstName", studentResource.UserID);
return(View(studentResource));
}
public IEnumerable <StudentResource> StudentsModules()
{
var students = _context
.Students
.Include(item => item.Modules);
var studentResources = new List <StudentResource>(); //an empty list of student resources
foreach (var student in students)
{
var resource = new StudentResource(); //foreach student in the db, we create a student resource object
resource.Id = student.Id;
resource.FirstName = student.FirstName;
resource.LastName = student.LastName;
/*
* Remember that A student can have 0...N modules.
* We need to iterate through all the modules that are associated with this each student
* Goal of action: Get Student Enrollments
*
* Each student already has a list of modules,
* so we do not need the studentId in modules entity
* this is why we make use of a resource
*/
foreach (var module in student.Modules)
{
var moduleResource = new ModuleResource
{
Id = module.Id,
Name = module.Name,
Code = module.Code
};
resource.ModuleResources.Add(moduleResource);
}
studentResources.Add(resource);
}
return(studentResources);
}
public async Task <StudentResource> getSInfo(int id) //studentid
{
var res = await ITeacher.getTeacherStudent(id, true);
var final = new StudentResource();
var temp = mapper.Map <List <TeacherStudent>, List <TeacherStudentResource> >(res);
/*Add *NULL Teacher* for newly added students with no Courses*/
final.PersonalInfo = temp[0].Student.PersonalInfo;
final.StudentId = Convert.ToInt32(temp[0].StudentId);
foreach (var i in temp)
{
final.teacherInfo.Add(await GetTeacher(Convert.ToInt32(i.TeacherId)));
}
return(final);
}
public async Task <IActionResult> CreateStudent([FromBody] StudentResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var result = await studentService.CreateStudent(resource);
return(Ok(result));
}
catch (Exception ex)
{
logger.LogError(1003, ex, ex.Message);
}
return(BadRequest());
}
public async Task GetStudent_NotFound()
{
var id = "608f9937e43fbd9bfd44e4b8";
var newStudent = new StudentResource
{
Id = id,
FirstName = "StudentName",
LastName = "StudentLastName",
AdmissionGrade = 9,
Faculty = "TestFaculty",
PassGrade = 8,
StudyYear = 3
};
await GivenAnExistingStudent(newStudent);
await WhenIExecuteAGetRequest("607f1937e43fbd9bfd44e4b5");
ThenTheReturnedStatusIs(HttpStatusCode.NotFound);
}
public void SaveOrUpdateStudentResource(StudentResource studentResource)
{
using (var dbContext = new DataAccess.TeachersAssistantDbContext())
{
_unitOfWork.InitializeDbContext(dbContext);
var stuRes = _unitOfWork._studentResourcesRepository.GetById(studentResource.StudentResourceId);
if (stuRes == null)
{
_unitOfWork._studentResourcesRepository.Add(studentResource);
_unitOfWork.SaveChanges();
}
else
{
stuRes.SubjectId = studentResource.SubjectId;
stuRes.CourseId = studentResource.CourseId;
stuRes.FilePath = studentResource.FilePath;
stuRes.RoleName = studentResource.RoleName;
stuRes.StudentResourceName = studentResource.StudentResourceName;
_unitOfWork.SaveChanges();
}
}
}
