public Reply UpdateLesson(int id, [FromBody] LessonRequest request)
{
Reply reply = new Reply();
string token = GetToken();
if (userService.VerifyRol(token) != 2 && userService.VerifyRol(token) != 3)
{
reply.message = "No esta autorizado";
return(reply);
}
try
{
Lesson lesson = new Lesson();
#region Lesson
lesson = lessonService.FindById(id);
lesson.latitude = request.latitude;
lesson.lenght = request.lenght;
lesson.day = request.day;
lesson.task_id = request.task_id;
lesson.description = request.description;
#endregion
lessonService.Update(lesson);
reply.message = "Lesson Actualizada";
}
catch (Exception exception)
{
reply.message = exception.Message.ToString();
}
return(reply);
}
public async Task <ActionResult <Lesson> > Create(LessonRequest lesson)
{
var result = await _lessons.Create(lesson, HttpContext.RequestAborted);
if (result == null)
{
return(Conflict());
}
return(result);
}
public JsonResult getLessonInfo(int day, int lesson)
{
int TimeTableid = (int)Session["TimeTableId"];
Lesson ls = db.Lessons.Where(l => l.TimetableId == TimeTableid).
Where(l => l.day == day).Where(l => l.number == lesson).FirstOrDefault();
if (ls == null)
{
return(Json("no"));
}
LessonRequest lr = new LessonRequest();
lr.name = ls.name;
lr.teacher = ls.TeachersName;
return(Json(lr));
}
public async Task Get_Latest_Version(IAuthorizationService authorizationService, IStateService stateService, List <Lesson> entities, Lesson target)
{
var request = new LessonRequest();
request.CloneFrom(target);
var context = TestSetup.SetupContext();
var service = new LessonService(context, TestSetup.SetupHttpContext(), authorizationService, stateService);
await context.Lessons.AddRangeAsync(entities);
await context.Lessons.AddAsync(target);
await context.SaveChangesAsync();
var newLesson = await service.Update(target.Id, request);
var result = await service.Get(target.Id);
result.Should().NotBeNull().And.BeEquivalentTo(newLesson);
}
public Reply Create([FromBody] LessonRequest request)
{
Reply reply = new Reply();
string token = GetToken();
if (userService.VerifyRol(token) != 2 && userService.VerifyRol(token) != 3)
{
reply.message = "No esta autorizado";
return(reply);
}
Lesson lesson = new Lesson();
try
{
#region Lesson
int user_id = userService.GetId(token);
lesson.student_id = user_id;
lesson.teacher_id = request.teacher_id;
lesson.latitude = request.latitude;
lesson.lenght = request.lenght;
lesson.day = request.day;
lesson.task_id = request.task_id;
lesson.description = request.description;
lesson.status = 0;
#endregion
lessonService.Save(lesson);
reply.message = "Lesson Guardada";
}
catch (Exception exception)
{
reply.message = exception.Message.ToString();
}
return(reply);
}
public async Task <ActionResult <Lesson> > Update(Guid id, [CustomizeValidator(RuleSet = "Update")] LessonRequest lesson)
{
var currentUser = HttpContext.GetUser();
var currentLesson = await _lessons.Get(id, HttpContext.RequestAborted);
if (currentLesson == null)
{
return(NotFound());
}
if (!await _authorization.HasWriteAccess(currentUser, currentLesson, HttpContext.RequestAborted))
{
return(Unauthorized());
}
var result = await _lessons.Update(id, lesson, HttpContext.RequestAborted);
if (result == null)
{
return(Conflict());
}
return(result);
}
public async Task Update_Lesson_Or_404(Mock <ILessonService> service, Mock <IAuthorizationService> authorization, LessonRequest validRequest, LessonRequest invalidRequest, Lesson valid, Lesson invalid, User user)
{
authorization.Setup(x => x.HasWriteAccess(user, It.IsAny <It.IsAnyType>(), It.IsAny <CancellationToken>())).ReturnsAsync(true);
service.Setup(x => x.Exists(valid.Id, It.IsAny <CancellationToken>())).ReturnsAsync(true);
service.Setup(x => x.Exists(invalid.Id, It.IsAny <CancellationToken>())).ReturnsAsync(false);
service.Setup(x => x.Get(valid.Id, It.IsAny <CancellationToken>())).ReturnsAsync(valid);
service.Setup(x => x.Get(invalid.Id, It.IsAny <CancellationToken>())).ReturnsAsync((Lesson)null);
service.Setup(x => x.Update(valid.Id, validRequest, It.IsAny <CancellationToken>())).ReturnsAsync(valid);
service.Setup(x => x.Update(invalid.Id, invalidRequest, It.IsAny <CancellationToken>())).ReturnsAsync((Lesson)null);
var controller = TestSetup.SetupController <LessonsController>(service.Object, authorization.Object).SetupSession(user);
var goodResult = await controller.Update(valid.Id, validRequest);
var invalidResult = await controller.Update(invalid.Id, invalidRequest);
goodResult.Value.Should().BeEquivalentTo(valid);
invalidResult.Value.Should().BeNull();
invalidResult.Result.Should().BeOfType <NotFoundResult>();
}
public async Task Create_Lesson_Or_409(Mock <ILessonService> service, IAuthorizationService authorization, LessonRequest request, Lesson lesson, User user)
{
service.Setup(x => x.Create(request, It.IsAny <CancellationToken>())).ReturnsAsync(lesson);
service.Setup(x => x.Create(null, It.IsAny <CancellationToken>())).ReturnsAsync((Lesson)null);
var controller = TestSetup.SetupController <LessonsController>(service.Object, authorization).SetupSession(user);
var goodResult = await controller.Create(request);
var invalidResult = await controller.Create(null);
goodResult.Value.Should().NotBeNull();
invalidResult.Value.Should().BeNull();
invalidResult.Result.Should().BeOfType <ConflictResult>();
}
public async Task Update_Subject_State_On_Create(Mock <IAuthorizationService> authorizationService, Mock <IStateService> stateService, LessonRequest request)
{
stateService.Setup(x => x.UpdateSubjectState(It.IsAny <Guid>(), It.IsAny <CancellationToken>()));
var context = TestSetup.SetupContext();
var httpContext = TestSetup.SetupHttpContext();
var service = new LessonService(context, httpContext, authorizationService.Object, stateService.Object);
await service.Create(request);
stateService.VerifyAll();
}
public async Task Update_Lesson_Version(IAuthorizationService authorizationService, IStateService stateService, Lesson entity, LessonRequest request)
{
var context = TestSetup.SetupContext();
var service = new LessonService(context, TestSetup.SetupHttpContext(), authorizationService, stateService);
await context.Lessons.AddAsync(entity);
await context.SaveChangesAsync();
var expected = new Lesson();
expected.CloneFrom(entity);
expected.CloneFrom(request);
expected.Version += 1;
var result = await service.Update(entity.Id, request);
result.Should().NotBeNull().And.BeEquivalentTo(expected, config => TestSetup.IgnoreTimestamps <Lesson>()(config.Excluding(lesson => lesson.Exercises)));
context.Lessons.Count().Should().Be(2);
}
