public async Task <StudentResponse> SaveAsync(Student student)
{
try
{
await _studentRepository.AddAsync(student);
await _unitOfWork.CompleteAsync();
return(new StudentResponse(student));
}
catch (Exception e)
{
return(new StudentResponse("Has ocurred an error saving the student " + e.Message));
}
}
public async Task <IActionResult> Post([FromBody] StudentDTO dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
//TODO: AutoMapper
Student student = new Student {
Number = dto.Number,
Name = dto.Name,
Email = dto.Email,
Password = dto.Password
};
if (!await _repo.AddAsync(student))
{
throw new Exception("Unable to add student");
}
return(CreatedAtRoute(
Routes.StudentEntry,
new { number = student.Number },
_studentsRep.Entity(student)
));
}
public async Task <StudentResponse> SaveAsync(Student student)
{
if (_accountRepository.FindById(student.AccountId) != null)
{
if (_careerRepository.FindById(student.CareerId) != null)
{
try
{
await _studentRepository.AddAsync(student);
await _unitOfWork.CompleteAsync();
return(new StudentResponse(student));
}
catch (Exception e)
{
return(new StudentResponse($"An error ocurred while saving {e.Message}"));
}
}
else
{
return(new StudentResponse($"An error ocurred, the career with id {student.CareerId} doesn't exist"));
}
}
else
{
return(new StudentResponse($"An error ocurred, the account with id {student.AccountId} doesn't exist"));
}
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var emptyStudent = new Student();
if (await TryUpdateModelAsync <Student>(
emptyStudent,
"student",
s => s.Prefix
, s => s.FirstName
, s => s.MiddleName
, s => s.LastName
, s => s.Prefix
, s => s.EnrollmentDate
, s => s.DateOfBirth))
{
await _repository.AddAsync(emptyStudent);
return(RedirectToPage("./Index"));
}
return(null);
}
private async Task ProcessCurrentLineAsync(string name, string line, int lineNumber, ILogger log)
{
if (string.IsNullOrWhiteSpace(line))
{
log.LogInformation($"{name}: {lineNumber} is empty.");
return;
}
var studentData = line.Split(',');
if (studentData.Length != 6)
{
log.LogError($"{name}: {lineNumber} invalid data: {line}.");
return;
}
if (!DateTime.TryParse(studentData[4], out DateTime dob))
{
log.LogError($"{name}: {lineNumber} Invalid DOB: {studentData[4]}.");
return;
}
var student = new Student()
{
FirstName = studentData[0],
LastName = studentData[1],
Email = studentData[2],
PhoneNumber = studentData[3],
DateOfBirth = dob,
Department = studentData[5]
};
await _studentRepository.AddAsync(student, new PartitionKey(student.Department));
log.LogInformation($"{name}: {lineNumber} Added student: {student.LastName} {student.FirstName} with id: {student.Id} .");
}
public async Task CreateStudent(string name)
{
var student = new Student();
student.Name = name;
var students = await _studentRepository.GetAll();
var highestIndexNumer = 1;
if (!students.Any())
{
student.IndexNumber = highestIndexNumer;
}
else
{
foreach (var Student in students)
{
if (Student.IndexNumber > highestIndexNumer)
{
highestIndexNumer = Student.IndexNumber;
}
}
student.IndexNumber = highestIndexNumer + 1;
}
await _studentRepository.AddAsync(student);
}
public async Task <int> Handle(CreateStudentCommand request, CancellationToken cancellationToken)
{
var student = mapper.Map <Student>(request);
await repository.AddAsync(student);
return(student.Id);
}
private async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
// Process the message.
Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");
var student = studentDomain.ConvertToStudentEntity(Encoding.UTF8.GetString(message.Body));
string errorMessage = await studentDomain.ApplyBusinessRules(student);
if (!string.IsNullOrWhiteSpace(errorMessage))
{
SendMail("Student not added, " + errorMessage);
}
else
{
await studentRepository.AddAsync(student);
await databaseUnitOfWork.SaveChangesAsync();
SendMail($"Student added Successfully. StudentId:{student.StudentId}");
}
// Complete the message so that it is not received again.
// This can be done only if the queue Client is created in ReceiveMode.PeekLock mode (which is the default).
await queuClient.CompleteAsync(message.SystemProperties.LockToken);
// Note: Use the cancellationToken passed as necessary to determine if the queueClient has already been closed.
// If queueClient has already been closed, you can choose to not call CompleteAsync() or AbandonAsync() etc.
// to avoid unnecessary exceptions.
}
public async Task <ActionResult <StudentDto> > PostStudentAsync([FromBody] StudentDto student)
{
// Api automatically returns BadRequest if StudentDto == null
try
{
// Check if programme exists
var programme = _programmeRepository.FindByIdAsync(student.ProgrammeId);
if (programme == null)
{
_logger.LogWarning($"Programme : {student.ProgrammeId} not found.");
return(NotFound($"Programmee {student.ProgrammeId} does not exist"));
}
// map StudentDto to Student
var studentToDb = _mapper.Map <Student>(student);
var addedStudent = await _studentRepository.AddAsync(studentToDb);
await _studentRepository.SaveChangesAsync();
var studentToReturn = _mapper.Map <StudentDto>(addedStudent);
return(CreatedAtAction("GetStudent", new { id = addedStudent.StudentId }, studentToReturn));
}
catch (DataAccessException e)
{
_logger.LogError(e, "Db error.");
return(BadRequest("Post student failed."));
}
catch (Exception e)
{
_logger.LogError(e, "Db error.");
return(BadRequest("Post student failed."));
}
}
public async Task <IActionResult> updateStudent(Student info)
{
// if(courseId != int.Parse(User.FindFirst(ClaimTypes.NameIdentifier).Value))
// return Unauthorized();
if (info.id != 0)
{
//var course = await _CourseService.GetCourseByIdAsync(info.courseId);
// course = info;
if (await _CourseService.updateStudent(info))
{
_logger.LogInformation("Hello, course uptaded!");
return(Ok());
}
}
else
{
var res = _mapper.Map <Student>(info);
await _CourseService.AddAsync(res);
_logger.LogInformation("Hello, course uptaded!");
return(Ok());
}
_logger.LogInformation("Hello, course not uptaded!");
return(BadRequest());
}
public async Task <StudentDto> CreateStudentAsync(StudentDto newStudentDto)
{
var newStudent = _mapper.Map <Student>(newStudentDto);
await _students.AddAsync(newStudent);
await _unitOfWork.CommitAsync();
return(_mapper.Map <StudentDto>(newStudent));
}
public async Task CreatedStudentIntoDataAsync(People entity)
{
int peopleId = await GetPeopleIdByDocumentAsync(entity.Document);
if (peopleId > 0)
{
await _studentRepository.AddAsync(entity.Student.MapToDto(peopleId));
}
}
public async Task Add(StudentModel model)
{
var courseEntity = new StudentEntity
{
Name = model.Name,
GroupId = model.GroupId
};
await _repository.AddAsync(courseEntity);
}
public async Task <IActionResult> AddStudent(Student s)
{
if (ModelState.IsValid)
{
await _studentRepository.AddAsync(s);
return(RedirectToAction("Students"));
}
return(View(s));
}
public async Task <IActionResult> Create(StudentEntity studentEntity)
{
if (ModelState.IsValid)
{
await _studentRepository.AddAsync(studentEntity);
return(RedirectToAction(nameof(Index)));
}
return(View(studentEntity));
}
public async Task <Student> HandleAsync(AddStudentRequest request, CancellationToken cancellationToken)
{
var result = await _studentRepository.AddAsync(new Student
{
Id = request.Id,
FirstName = request.FirstName,
LastName = request.LastName
});
return(result);
}
public async Task <IActionResult> PostStudent([FromBody] Student student)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
await repository.AddAsync(student);
await unitOfWork.SaveChangesAsync();
return(Created(Url.Action(nameof(GetStudent)), student));
}
public async Task <Result <Exception, Unit> > Handle(Command request, CancellationToken cancellationToken)
{
var student = Mapper.Map <Command, Student>(request);
var studentCallback = await _studentRepository.AddAsync(student);
if (studentCallback.IsFailure)
{
return(studentCallback.Failure);
}
return(Unit.Successful);
}
public async Task AddAsync(StudentRequest studentRequest)
{
Student student = new Student()
{
StId = studentRequest.StId,
FirstName = studentRequest.FirstName,
LastName = studentRequest.LastName,
Birthday = studentRequest.Birthday,
City = studentRequest.City,
Gender = studentRequest.Gender,
Tckn = studentRequest.Tckn
};
await _studentRepository.AddAsync(student);
}
public async Task <ActionResult> Create(IFormCollection collection, Student student)
{
try
{
await studentRepository.AddAsync(student);
return(RedirectToAction(nameof(Index)));
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(View());
}
}
public async Task <StudentResponse> SaveAsync(Student student)
{
try
{
await _studentRepository.AddAsync(student);
await _unitOfWork.CompleteAsync();
return(new StudentResponse(student));
}
catch (Exception e)
{
return(new StudentResponse($"An error occurred when saving the student: {e.Message}"));
}
}
public async Task <ResponseStatus> SaveAsync(Student student)
{
try
{
await _studentRepository.AddAsync(student);
await _unitOfWork.CompleteAsync();
return(new ResponseStatus("", student.Id > 0 ? true : false));
}
catch (Exception ex)
{
// Do some logging stuff
return(new ResponseStatus($"An error occurred when saving the category: {ex.Message}", false));
}
}
public async Task <StudentResponse> SaveAsync(Student student)
{
try
{
await _studentRepository.AddAsync(student);
await _unitOfWork.CompleteAsync(); // if everything is ok , then we can save the changes (transaction).
return(new StudentResponse(student));
}
catch (Exception ex)
{
// Do some logging stuff
return(new StudentResponse($"An error occurred when saving the student: {ex.Message}"));
}
}
public async Task <IActionResult> Register(Student student, IFormFile image)
{
try
{
if (image != null)
{
using (var stream = new MemoryStream())
{
image.CopyTo(stream);
student.StudentImage = stream.ToArray();
}
}
if (ModelState.IsValid)
{
await studentRepository.AddAsync(student);
//Create Student Role for Authentication
string fullName = student.FirstName + " " + student.SurName;
await CreateStudentAsUserAsync(student.StudentID, student.Password, fullName);
// Commit changes
await studentRepository.SaveChangesAsync();
ModelState.Clear();
ViewBag.SuccessMsg = "Student Successfully Registered";
// Redirect to different view to show newly created student
return(RedirectToAction("Details", new { id = student.StudentID }));
}
return(View(student));
}
catch (DataAccessException e)
{
ViewBag.ErrorMsg = ErrorProcessing.ProcessException("Data Access exception. ", e);
return(RedirectToAction("Unknown", "Error"));
}
catch (Exception e)
{
ViewBag.ErrorMsg = ErrorProcessing.ProcessException("General exception. ", e);
return(RedirectToAction("Unknown", "Error"));
}
}
public async Task <StudentResponse> SaveAsync(Student student)
{
try
{
using (TransactionScope scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled))
{
await _studentRepository.AddAsync(student);
await _unitOfWork.CompleteAsync();
scope.Complete();
}
return(new StudentResponse(student));
}
catch (Exception ex)
{
return(new StudentResponse($"An error occurred when saving student: {ex.Message}"));
}
}
public async Task AddAsync_AddANewEntity_ReturnsAddedEntity()
{
// arrange
const int newStudentId = 6;
var student = new Student
{
Id = newStudentId,
FirstName = "c",
LastName = "d"
};
// act
var result = await _sut.AddAsync(student);
var queryResult = _sut.GetById(newStudentId);
// assert
Assert.NotNull(queryResult);
Assert.Equal("c", queryResult.FirstName);
Assert.Equal(result.FirstName, queryResult.FirstName);
}
public async Task <ActionResult <Student> > CreateStudent(Student student)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var user = await GetUser();
if (user == null)
{
return(BadRequest("You need to create a user account first."));
}
student.TeacherId = user.Id;
var studentResponse = await _studentRepository.AddAsync(student);
await AddStudentToUser(user, studentResponse);
return(Ok(studentResponse));
}
public async Task <ResponseModel <StudentResource> > SaveAsync(Student student)
{
try
{
var existingFaculty = await facultyRepository.FindByIdAsync(student.FacultyId);
if (existingFaculty == null)
{
return new ResponseModel <StudentResource>()
{
Success = false,
Message = "Invalid Faculty."
}
}
;
await studentRepository.AddAsync(student);
await unitOfWork.CompleteAsync();
var studentResource = mapper.Map <Student, StudentResource>(student);
return(new ResponseModel <StudentResource>()
{
Success = true,
Data = studentResource,
Message = "Successfully added!"
});
}
catch (Exception ex)
{
return(new ResponseModel <StudentResource>()
{
Success = false,
Message = $"An error occurred when saving the Student: { ex.Message}"
});
}
}
public async Task <Result <Exception, int> > Handle(Command request, CancellationToken cancellationToken)
{
var student = _mapper.Map <Student>(request);
student.SetActivated();
var addStudentCallback = await _studentRepository.AddAsync(student);
if (addStudentCallback.IsFailure)
{
return(addStudentCallback.Failure);
}
var newStudent = addStudentCallback.Success;
await _auditCRUD.ActionCreate(
eventName : nameof(StudentCreate),
user : new UserAuditCRUD(request.UserId, request.UserName, request.Email),
location : typeof(StudentCreate).Namespace,
ipAddress : request.IpAddress,
currentEntity : newStudent);
return(newStudent.Id);
}
public async Task <string> Post([FromBody] Student student)
{
await _studentRepository.AddAsync(student);
return("");
}
