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> 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 void FromModifiedXml(ModifiedXmlDocument doc, string path) { Result = doc.GetStringFromXml(path + "/RESULT"); Meta = new ResponseMeta(); Meta.FromModifiedXml(doc, path); Status = new OrderStatus(); Status.FromModifiedXml(doc, path + "/STATUS"); }
protected ApiResponse(HttpStatusCode status_number, object result = null, string errorMessage = null) { Meta = new ResponseMeta { StatusNumber = (int)status_number, Message = errorMessage }; Data = result; }
public async Task <string> Add(CloudTable responseMetasTable, HttpResponseMessage response) { var responseMeta = new ResponseMeta(response, DateTimeOffset.UtcNow); logger.LogDebug($"Adding new response meta:\n{responseMeta}"); await tableRepository.Add(responseMetasTable, responseMeta); return(responseMeta.RowKey); }
protected ApiPaginationResponse(HttpStatusCode status_number, long page, long totalPages, object result = null, string errorMessage = null) { Meta = new ResponseMeta { StatusNumber = (int)status_number, Message = errorMessage, Page = page, TotalPages = totalPages }; Data = result; }
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 ResponseMetaDisplayable(ResponseMeta responseMeta) { if (responseMeta == null) { throw new ArgumentNullException("responseMeta"); } BlobKey = responseMeta.RowKey; ReceivedOn = DateTimeOffset.Parse(responseMeta.RowKey); IsSuccess = bool.Parse(responseMeta.PartitionKey); StatusCode = responseMeta.StatusCode; Headers = responseMeta.Headers; }
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 <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 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 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_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 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 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 <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}"); } }
public ErrorResult(ResponseMeta response) { _response = response ?? throw new ArgumentNullException(nameof(response)); }
public ErrorChecker() { Meta = new ResponseMeta(); Errors = new List <ErrorRow>(); }
protected ResponseBase() { Meta = new ResponseMeta(); }