public ActionResult Put(Guid id, [FromBody] TeacherRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var teacher = teacherRepository.Get(id);
if (teacher != null)
{
teacher.FirstName = request.FirstName;
teacher.MiddleName = request.MiddleName;
teacher.LastName = request.LastName;
teacher.BirthDate = request.BirthDate;
teacher.Gender = Gender.FromId(request.Gender) ?? Gender.NotSpecified;
teacher.Title = NameTitle.FromId(request.Title) ?? NameTitle.None;
this.teacherRepository.Update(teacher);
return(Ok());
//TODO: Add audit info in response
//var response = new UpdateTeacherResponse(teacher.Id);
//return Ok(response);
}
return(NotFound());
}
catch (Exception e)
{
return(GenericServerErrorResult(e));
}
}
public void CrearDocenteConIdRepetida()
{
var requestUser = new UserRequest {
Name = "cjhair", Password = "******"
};
CreateUserService _service = new CreateUserService(new UnitOfWork(_context));
var responseUser = _service.Execute(requestUser);
User user = _service.Consult(requestUser.Name);
var requestTeacher = new TeacherRequest
{
Name = "Cristian",
Category = "Planta",
DedicationTime = "12h",
DocumentType = "CC",
DocumentId = "1035",
Email = "*****@*****.**",
InvestigationGroup = "Gisco",
Phone = "12345",
User = user
};
CreateTeacherService _teacherService = new CreateTeacherService(new UnitOfWork(_context));
var responseTeacher = _teacherService.Execute(requestTeacher);
Assert.AreEqual("Ya existe un docente registrado con esa id", responseTeacher.Menssage);
}
public ActionResult <CreateTeacherService> Post(TeacherRequest request)
{
CreateTeacherService _service = new CreateTeacherService(_unitOfWork);
CreateTeacherResponse response = _service.Execute(request);
return(Ok(response));
}
public ActionResult <NewRecordResponse> Post([FromBody] TeacherRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
try
{
var teacher = new Teacher
{
FirstName = request.FirstName,
MiddleName = request.MiddleName,
LastName = request.LastName,
BirthDate = request.BirthDate,
Gender = Gender.FromId(request.Gender) ?? Gender.NotSpecified,
Title = NameTitle.FromId(request.Title) ?? NameTitle.None
};
this.teacherRepository.Create(teacher);
var response = new NewRecordResponse(teacher.Id);
return(CreatedAtAction(nameof(Get), new { id = teacher.Id }, response));
}
catch (Exception e)
{
return(GenericServerErrorResult(e));
}
}
public async Task <IActionResult> AddStudent(TeacherRequest model)
{
var appUser = await _userManager.FindByNameAsync(model.Code);
if (appUser != null)
{
return(new BadRequestObjectResult(new { type = 2, message = "Student code already exists" }));
}
appUser = await _userManager.FindByEmailAsync(model.Email);
if (appUser != null)
{
return(new BadRequestObjectResult(new { type = 1, message = "Email already exists" }));
}
var registerUser = new AppUser
{
Email = model.Email,
UserName = model.Code,
RealName = model.RealName,
DOB = Convert.ToDateTime(model.Dob),
Avatar = "default.png"
};
var result = await _userManager.CreateAsync(registerUser, "123@123a");
if (!result.Succeeded)
{
var internalErr = new ObjectResult(new { type = 2, message = result.Errors.ToList()[0].Description })
{
StatusCode = 500
};
return(internalErr);
}
await _userManager.AddToRoleAsync(registerUser, "student");
var urlHelper = _urlHelperFactory.GetUrlHelper(_actionContextAccessor.ActionContext);
var token = await _userManager.GenerateEmailConfirmationTokenAsync(registerUser);
var confirmationLink = urlHelper.Action("ConfirmEmail", "Users", new { token, email = registerUser.Email }, "https");
var content = String.Format(EmailTemplate.HTML_CONTENT, model.Email, model.Code, "123@123a", confirmationLink);
var message = new Message(new string[] { registerUser.Email }, "Your Account On DYSTANCE", content, null);
await _emailSender.SendEmailAsync(message);
return(new OkObjectResult(new TeacherInfoResponse
{
Id = registerUser.Id,
Code = registerUser.UserName,
Email = registerUser.Email,
RealName = registerUser.RealName,
Dob = registerUser.DOB.ToString("yyyy-MM-dd")
}));
}
public IHttpActionResult Get([FromBody] TeacherRequest teachReq)
{
try
{
ScheduleManager s = new ScheduleManager();
return(Ok(s.GetScheduleByTeacher(teachReq.id)));//TODO with date
}
catch (Exception e)
{
LogManager.LogException(e);
return(InternalServerError(e));
}
}
public async Task <IActionResult> GetById(TeacherRequest teacher)
{
try
{
string jsonStr = JsonConvert.SerializeObject(teacher);
return(Ok(await _teacherRepostory.GetTeacherByIdAsync(jsonStr)));
}
catch (Exception ex)
{
_logger.LogInformation($"{ex.Message}");
return(BadRequest(new { Code = 0, Message = ex.Message }));
}
}
public async Task <IActionResult> Reject(int id, [Bind("Id,RejectReason")] TeacherRequest teacherRequest, string returnUrl)
{
if (id != teacherRequest.Id || !TeacherRequestExists(id))
{
return(NotFound());
}
var tR = await _context.TeacherRequests.Include(x => x.GraduationWork).Include(x => x.Teacher).FirstOrDefaultAsync(x => x.Id == id);
tR.Reject(tR.Teacher, teacherRequest.RejectReason);
_context.Update(tR);
await _context.SaveChangesAsync();
return(RedirectToUrl(returnUrl));
}
public async Task <IActionResult> Create([Bind("GraduationWorkId,TeacherId,Motivation,RequestType")] TeacherRequest teacherRequest, string returnUrl)
{
if (ModelState.IsValid)
{
if (!_context.TeacherRequests.Any(x => x.GraduationWorkId == teacherRequest.GraduationWorkId && x.Status == null && x.RequestType == teacherRequest.RequestType))
{
teacherRequest.CreatingDate = DateTime.Now;
_context.Add(teacherRequest);
await _context.SaveChangesAsync();
}
return(RedirectToUrl(returnUrl));
}
ViewData["GraduationWorkId"] = new SelectList(_context.GraduationWorks, "Id", "Id", teacherRequest.GraduationWorkId);
ViewData["TeacherId"] = new SelectList(_context.Teachers, "Id", "FullName", teacherRequest.TeacherId);
return(View(teacherRequest));
}
public async Task <IActionResult> Create(RequestType requestType, string returnUrl)
{
TeacherRequest teacherRequest = new TeacherRequest
{
RequestType = requestType
};
User user = await _userManager.FindByNameAsync(User.Identity.Name);
var graduationWork = await _context.GraduationWorks.FirstOrDefaultAsync(x => x.StudentId == user.SubjectAreaId);
teacherRequest.GraduationWorkId = graduationWork.Id;
ViewData["TeacherId"] = new SelectList(_context.Teachers, "Id", "FullName");
ViewData["returnUrl"] = returnUrl;
return(PartialView("_Create", teacherRequest));
}
public async Task <IActionResult> Register(
[HttpTrigger(AuthorizationLevel.Anonymous, "post", Route = "teacher")]
[RequestBodyType(typeof(TeacherRequest), "Create/update teacher")] HttpRequest request)
{
var validateStatus = base.AuthorizationStatus(request);
if (validateStatus != System.Net.HttpStatusCode.Accepted)
{
return(new BadRequestObjectResult(validateStatus));
}
string requestBody = await new StreamReader(request.Body).ReadToEndAsync();
TeacherRequest requestData = JsonConvert.DeserializeObject <TeacherRequest>(requestBody);
await _teacherService.CreateUpdate(requestData);
return(new OkObjectResult(new { message = "Create/update school successful." }));
}
public async Task <IActionResult> Login(TeacherRequest model)
{
try
{
var auth = await _authRepostory.Authenticate(model.Email, model.Password);
if (auth == null)
{
return(NotFound("Invalid User"));
}
return(Ok(auth));
}
catch (Exception ex)
{
_logger.LogInformation($"{ex.Message}");
return(BadRequest(new { Code = 0, Message = ex.Message }));
}
}
public async void AddTeacher_Returns_Fail_EmailExist(string id)
{
//Arrange
var user = new AppUser
{
Id = id,
UserName = "******",
Email = "Test1@gmail",
Avatar = "default.png",
RealName = "Test 1",
DOB = new DateTime(2020, 09, 29)
};
var teacherRequest = new TeacherRequest
{
Id = user.Id,
Code = user.UserName,
Email = user.Email,
RealName = user.RealName,
Dob = "2020-09-29"
};
var teacherResponses = new List <TeacherInfoResponse>()
{
new TeacherInfoResponse {
Id = teacherRequest.Id,
Code = teacherRequest.Code,
Email = teacherRequest.Email,
RealName = teacherRequest.RealName,
Dob = teacherRequest.Dob
},
};
// create url helper mock
Type t = typeof(UserServiceTest);
var httpContext = new Mock <HttpContext>().Object;
actionContextAccessor.Setup(x => x.ActionContext).Returns(new ActionContext(
httpContext,
new Microsoft.AspNetCore.Routing.RouteData(),
new ControllerActionDescriptor()
{
MethodInfo = t.GetMethod(nameof(TeacherServiceTest.AddTeacher_Returns_Correctly))
}));
mockUrlHelper = new Mock <IUrlHelper>();
mockUrlHelperFactory.Setup(x => x.GetUrlHelper(It.IsAny <ActionContext>())).Returns(mockUrlHelper.Object);
mockUrlHelper.SetupGet(h => h.ActionContext).Returns(actionContextAccessor.Object.ActionContext);
UrlActionContext actual = null;
mockUrlHelper.Setup(h => h.Action(It.IsAny <UrlActionContext>()))
.Callback((UrlActionContext context) => actual = context);
fakeUserManager.Setup(x => x.GenerateEmailConfirmationTokenAsync(It.IsAny <AppUser>())).ReturnsAsync("");
mockEmailSender.Setup(x => x.SendEmailAsync(It.IsAny <Message>())).Returns(() => Task.FromResult(""));
fakeUserManager.Setup(x => x.FindByEmailAsync(teacherRequest.Email)).Returns(() => Task.FromResult(user));
//Act
var result = await _teacherService.Object.AddTeacher(teacherRequest);
var okObjectResult = result as BadRequestObjectResult;
//Assert
Assert.Equal(400, okObjectResult.StatusCode);
Assert.IsType <BadRequestObjectResult>(okObjectResult);
}
/// <summary>
/// The CreateUpdate.
/// </summary>
/// <param name="model">The model<see cref="TeacherRequest"/>.</param>
/// <returns>The <see cref="Task"/>.</returns>
public async Task CreateUpdate(TeacherRequest model)
{
TableQuery <Entites.Teacher> query = new TableQuery <Entites.Teacher>()
.Where(TableQuery.GenerateFilterCondition("RowKey", QueryComparisons.Equal, model.Id));
var teacherQuery = await _tableStorage.QueryAsync <Entites.Teacher>("Teacher", query);
var teacher = teacherQuery.SingleOrDefault();
if (teacher != null)
{
// Update profile
ProfileUpdateRequest profileUpdateRequest = new ProfileUpdateRequest
{
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Id = model.Id
};
await _profileService.UpdateProfile(profileUpdateRequest);
//Update teacher information
teacher.Gender = model.Gender;
teacher.Address1 = model.Address1;
teacher.Address2 = model.Address2;
teacher.Country = model.Country;
teacher.State = model.State;
teacher.City = model.City;
teacher.Zip = model.Zip;
teacher.Latitude = model.Latitude;
teacher.Longitude = model.Longitude;
teacher.Active = true;
teacher.CreatedBy = model.CreatedBy;
teacher.UpdatedOn = DateTime.UtcNow;
teacher.UpdatedBy = model.CreatedBy;
try
{
await _tableStorage.UpdateAsync("Teacher", teacher);
}
catch (Exception ex)
{
throw new AppException("update teacher error: ", ex.InnerException);
}
}
else
{
// Register user as teacher
var userId = String.IsNullOrEmpty(model.Id) ? Guid.NewGuid().ToString() : model.Id;
var defaultPasswrod = "teacher@123"; //SettingConfigurations.GetRandomPassword(10);
RegisterRequest registerRequest = new RegisterRequest
{
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName,
Role = model.Role,
AcceptTerms = true,
Id = userId,
SchoolId = model.SchoolId,
Password = defaultPasswrod,
ConfirmPassword = defaultPasswrod
};
var newTeacher = new Entites.Teacher(model.SchoolId, userId)
{
Address1 = model.Address1,
Address2 = model.Address2,
Country = model.Country,
State = model.State,
City = model.City,
Zip = model.Zip,
Latitude = model.Latitude,
Longitude = model.Longitude,
Active = true,
Gender = model.Gender,
CreatedBy = model.CreatedBy,
UpdatedOn = DateTime.UtcNow,
UpdatedBy = model.CreatedBy,
};
try
{
await _profileService.Register(registerRequest);
await _tableStorage.AddAsync("Teacher", newTeacher);
await NewTeacherNotificationEmail(registerRequest);
}
catch (Exception ex)
{
throw new AppException("Create teacher error: ", ex.InnerException);
}
}
}
public async Task <IActionResult> AddStudent([FromBody] TeacherRequest model)
{
return(await _studentService.AddStudent(model));
}
public async Task <IActionResult> AddTeacher([FromBody] TeacherRequest model)
{
return(await _teacherService.AddTeacher(model));
}
