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 SearchAsync_ReturnsMatches()
{
var list = new List <CourseDto>
{
new CourseDto {
Name = "Response1"
},
new CourseDto {
Name = "Other Response"
}
};
SetupTextFixture(s =>
{
var mock = new Mock <ICourseService>();
mock.Setup(m => m.SearchAsync("David")).ReturnsAsync(ResponseMeta <List <CourseDto> > .CreateSuccess(list));
s.AddTransient <ICourseService>(_ => mock.Object);
});
var api = new CourseApi();
var response = await api.SearchAsync("David");
Assert.IsTrue(response.Success);
response.Item.Should().BeEquivalentTo(list);
}
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 <SettingsDto> > GetSettings()
{
using (var context = await _contextFactory)
{
var list = context.Settings.ToList();
var settings = new SettingsDto();
settings.CourseImageUrl = list.FirstOrDefault(s => s.Key == "CourseImageUrl")?.Value;
return(ResponseMeta <SettingsDto> .CreateSuccess(settings));
}
}
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 AddAsync_ReturnsSuccess()
{
SetupTextFixture(s =>
{
var mock = new Mock <ICourseService>();
mock.Setup(m => m.AddAsync(It.IsAny <CourseDto>())).ReturnsAsync(ResponseMeta.CreateSuccess());
s.AddTransient <ICourseService>(_ => mock.Object);
});
var api = new CourseApi();
var response = await api.AddAsync(Dtos.CourseDto);
Assert.IsTrue(response.Success);
}
public async Task <ResponseMeta <List <CourseDto> > > SearchAsync(string search)
{
using (var context = await _contextFactory)
{
var items = context.Courses.ToList();
var recs = context.Courses
.Where(c => c.Name.Contains(search))
.Take(25)
.ToList()
.Select(c => c.ToDto())
.ToList();
return(ResponseMeta <List <CourseDto> > .CreateSuccess(recs));
}
}
public async Task GetSettings_ReturnsSettings()
{
SetupTextFixture(s =>
{
var mock = new Mock <ISettingsService>();
mock.Setup(m => m.GetSettings()).ReturnsAsync(ResponseMeta <SettingsDto> .CreateSuccess(Dtos.SettingsDto));
s.AddTransient <ISettingsService>(_ => mock.Object);
});
var api = new SettingsApi();
var response = await api.GetSettings();
Assert.IsTrue(response.Success);
response.Item.Should().BeEquivalentTo(Dtos.SettingsDto);
}
public async Task GetCourseInfoForCourse_ReturnsCourseInfo()
{
SetupTextFixture(s =>
{
var mock = new Mock <ICourseInfoService>();
mock.Setup(m => m.GetCourseInfoForCourse(1)).ReturnsAsync(ResponseMeta <CourseInfoDto> .CreateSuccess(Dtos.CourseInfoDto));
s.AddTransient <ICourseInfoService>(_ => mock.Object);
});
var api = new CourseInfoApi();
var response = await api.GetCourseInfoForCourse(1);
Assert.IsTrue(response.Success);
response.Item.Should().BeEquivalentTo(Dtos.CourseInfoDto);
}
public async Task GetHolesForCourse_ReturnsCourse()
{
SetupTextFixture(s =>
{
var mock = new Mock <IHoleService>();
mock.Setup(m => m.GetHolesForCourse(1)).ReturnsAsync(ResponseMeta <List <HoleDto> > .CreateSuccess(Dtos.HoleDtoList));
s.AddTransient <IHoleService>(_ => mock.Object);
});
var api = new HoleApi();
var response = await api.GetHolesForCourse(1);
Assert.IsTrue(response.Success);
response.Item.Should().BeEquivalentTo(Dtos.HoleDtoList);
}
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}");
}
}