public async Task <ResponseMeta> UpdateAsync(CourseDto dto)
{
using (var context = await _contextFactory)
{
if (dto.Id == null)
{
return(ResponseMeta.CreateFailure(ResponseFailureType.IdRequired));
}
var existing = await context.Courses.FirstOrDefaultAsync(m => m.Id == dto.Id);
if (existing == null)
{
return(ResponseMeta.CreateFailure(ResponseFailureType.EntityNotFound));
}
var model = dto.ToModel();
try
{
context.Entry(existing).CurrentValues.SetValues(model);
await context.SaveChangesAsync();
}
catch (Exception ex)
{
return(ResponseMeta.CreateFailure(ex.ToString()));
}
return(ResponseMeta.CreateSuccess());
}
}
public async Task <ResponseMeta> AddAsync(CourseDto dto)
{
if (dto.Id != null)
{
return(ResponseMeta <CourseDto> .CreateFailure(ResponseFailureType.IdRequiredNull));
}
using (var context = await _contextFactory)
{
var model = dto.ToModel();
try
{
await context.Courses.AddAsync(model);
await context.SaveChangesAsync();
}
catch (Exception ex)
{
return(ResponseMeta <CourseDto> .CreateFailure(ex.ToString()));
}
return(ResponseMeta.CreateSuccess());
}
}
public async Task <ResponseMeta <CourseDto> > GetAsync(long id)
{
using (var context = await _contextFactory)
{
var model = await context.Courses.FirstOrDefaultAsync(m => m.Id == id);
if (model == null)
{
return(ResponseMeta <CourseDto> .CreateFailure(ResponseFailureType.EntityNotFound));
}
return(ResponseMeta <CourseDto> .CreateSuccess(model.ToDto()));
}
}
public async Task GetCourseInfoForCourse_BubblesErrors()
{
SetupTextFixture(s =>
{
var mock = new Mock <ICourseInfoService>();
mock.Setup(m => m.GetCourseInfoForCourse(1)).ReturnsAsync(ResponseMeta <CourseInfoDto> .CreateFailure(ResponseFailureType.IdRequired));
s.AddTransient <ICourseInfoService>(_ => mock.Object);
});
var api = new CourseInfoApi();
var response = await api.GetCourseInfoForCourse(1);
Assert.IsFalse(response.Success);
Assert.AreEqual(ResponseFailureType.IdRequired, response.FailureType);
}
public async Task AddAsync_BubblesErrors()
{
SetupTextFixture(s =>
{
var mock = new Mock <ICourseService>();
mock.Setup(m => m.AddAsync(It.IsAny <CourseDto>())).ReturnsAsync(ResponseMeta.CreateFailure(ResponseFailureType.IdRequired, new[] { "oh no" }));
s.AddTransient <ICourseService>(_ => mock.Object);
});
var api = new CourseApi();
var response = await api.AddAsync(new CourseDto());
Assert.IsFalse(response.Success);
Assert.AreEqual(ResponseFailureType.IdRequired, response.FailureType);
Assert.AreEqual("oh no", response.Errors.First());
}
public async Task <ResponseMeta> DeleteAsync(long id)
{
using (var context = await _contextFactory)
{
var model = await context.Courses.FirstOrDefaultAsync(m => m.Id == id);
if (model == null)
{
return(ResponseMeta.CreateFailure(ResponseFailureType.EntityNotFound));
}
context.Courses.Remove(model);
await context.SaveChangesAsync();
return(ResponseMeta.CreateSuccess());
}
}
public async Task <ResponseMeta <List <HoleDto> > > GetHolesForCourse(long courseId)
{
using (var context = await _contextFactory)
{
var course = await context.Courses
.Include(c => c.Holes)
.FirstOrDefaultAsync(c => c.Id == courseId);
if (course == null)
{
return(ResponseMeta <List <HoleDto> > .CreateFailure(ResponseFailureType.EntityNotFound));
}
var holes = course.Holes
.Select(h => h.ToDto())
.ToList();
return(ResponseMeta <List <HoleDto> > .CreateSuccess(holes));
}
}
public static async Task <ResponseMeta> GetResponseAsync(this HttpResponseMessage response)
{
if (response.IsSuccessStatusCode)
{
return(ResponseMeta.CreateSuccess());
}
else if (response.StatusCode == HttpStatusCode.BadRequest)
{
dynamic dyn = JObject.Parse(await response.Content.ReadAsStringAsync());
return(ResponseMeta.CreateFailure
(
(ResponseFailureType)dyn.FailureType,
dyn.Errors.ToObject <string[]>()
));
}
else
{
throw new Exception($"Fatal error on request, response status: {response.StatusCode}");
}
}