public async Task <ResultOf <TResponse> > Handle(TRequest request, CancellationToken cancellationToken) { var validationFailMessages = _validators.Select(i => i.Validate(request)) .SelectMany(i => i.Errors) .Select(i => i.ErrorMessage) .ToArray(); if (validationFailMessages.Any()) { var errors = string.Join("\n", validationFailMessages); return(ResultOf <TResponse> .BadRequest(errors)); } var result = await ProcessActionAsync(request, cancellationToken) .ConfigureAwait(false); if (_fails?.Any() ?? false) { var errors = string.Join("\n", _fails); return(ResultOf <TResponse> .BadRequest(errors)); } await _unitOfWork.CommitAsync().ConfigureAwait(false); // TODO Remove await, because do not need wait call end await PublishResultAsync(request, result); return(ResultOf <TResponse> .Ok(result)); }
/// <summary> /// При успешном коде ответа, возвращает объект типа <see cref="ResultOf{T}" /> в состоянии 'Success'. /// При ответе <see cref="HttpStatusCode.NotFound"/> возвращает <see cref="ResultOf{T}" /> в состоянии 'Empty'. /// При ответе <see cref="HttpStatusCode.BadRequest"/> возвращает <see cref="ResultOf{T}" /> в состоянии 'Invalid'. /// </summary> /// <exception cref="InvalidOperationException">При неизвестных ответах</exception> /// <typeparam name="T"></typeparam> /// <param name="response"></param> /// <returns>Объект типа <see cref="ResultOf{T}"/>.</returns> public static async Task <ResultOf <T> > HandleAsync <T>(this HttpResponseMessage response) where T : class { if (response.IsSuccessStatusCode) { var dto = await response.Content.ReadAsAsync <T>(formatters); return(ResultOf <T> .CreateSuccess(dto)); } switch (response.StatusCode) { case HttpStatusCode.NotFound: return(ResultOf <T> .CreateEmpty()); case HttpStatusCode.BadRequest: var error = await response.Content.ReadAsStringAsync(); var message = GetBadRequestMessage(error); return(ResultOf <T> .CreateInvalid(message)); default: var exception = await response.Content.ReadAsStringAsync(); throw new InvalidOperationException(exception); } }
public static async Task <SubscriptionInfo[]> GetSubscriptionsAsync(string host, string token) { var url = string.Format("{0}/subscriptions?api-version={1}", Utils.GetCSMUrl(host), Constants.CSM.ApiVersion); using (var client = CreateHttpClient(token)) using (var response = await client.GetAsync(url)) { ResultOf <SubscriptionInfo> result = await ProcessResponse <ResultOf <SubscriptionInfo> >("GetSubscriptionsAsync", response); var subs = result.value; var getRgTasks = new List <Task <ResourceGroupInfo[]> >(); foreach (var sub in subs) { getRgTasks.Add(GetResourceGroups(client, host, sub.subscriptionId)); } var rgsForAllSubs = await Task.WhenAll(getRgTasks.ToArray()); for (int i = 0; i < rgsForAllSubs.Length; i++) { subs[i].resourceGroups = rgsForAllSubs[i]; } return(subs); } }
public void CreateEmpty_IsOk() { var actual = ResultOf <FromTestClass> .CreateEmpty(); Assert.AreEqual(ResultState.Empty, actual.State); Assert.IsNull(actual.InvalidMessage); Assert.IsNull(actual.Result); }
public void CreateInvalid_IsOk() { var actual = ResultOf <FromTestClass> .CreateInvalid("Message!"); Assert.AreEqual(ResultState.Invalid, actual.State); Assert.AreEqual("Message!", actual.InvalidMessage); Assert.IsNull(actual.Result); }
public void CreateSuccess_IsOk() { var actual = ResultOf <FromTestClass> .CreateSuccess(new FromTestClass { FromField = "Test!" }); Assert.AreEqual(ResultState.Success, actual.State); Assert.IsNull(actual.InvalidMessage); Assert.AreEqual("Test!", actual.Result.FromField); }
public void CloneFailedAs_CreateInvalid_IsOk() { var from = ResultOf <FromTestClass> .CreateInvalid("Message!"); var actual = from.CloneFailedAs <ToTestClass>(); Assert.AreEqual(ResultState.Invalid, actual.State); Assert.AreEqual("Message!", actual.InvalidMessage); Assert.IsNull(actual.Result); Assert.AreEqual(typeof(ResultOf <ToTestClass>), actual.GetType()); }
protected IActionResult CreateResponse <T>(ResultOf <T> result, Func <T, object> map = null) { if (!result.IsSuccess) { return(BadRequest(result.ErrorDescription)); } var response = map?.Invoke(result.Value) ?? result.Value; return(Ok(response)); }
/// <summary> /// Позволяет обработать <see cref="ResultOf{T}"/> как HTTP ответ /// </summary> /// <param name="controller">Контроллер</param> /// <param name="result">Результат для обработки</param> /// <typeparam name="T"></typeparam> /// <returns>Возвращается NotFound (404), BadRequest (400) с текстом ошибки или OK (200) с объектом</returns> /// <exception cref="ArgumentOutOfRangeException"></exception> public static ActionResult HandleAsOk <T>(this ControllerBase controller, ResultOf <T> result) where T : class { switch (result.State) { case ResultState.Empty: return(new NotFoundResult()); case ResultState.Invalid: return(new BadRequestObjectResult(result.InvalidMessage)); case ResultState.Success: return(new OkObjectResult(result.Result)); default: throw new ArgumentOutOfRangeException(nameof(result)); } }
private static ResultOf<Circle> GetCircle() { var result = new ResultOf<Circle>(); try { result.Value = new Circle(); } catch (NullReferenceException e) { result.AddMessage(e.Message); } return result; }
public void CloneFailedAs_CreateInvalid_IsOk() { var from = ResultOf <FromTestClass> .CreateInvalid("Message!"); var actual = from.CloneFailedAs <ToTestClass>(); Assert.Multiple(() => { Assert.AreEqual(ResultState.Invalid, actual.State); Assert.AreEqual("Message!", actual.InvalidMessage); Assert.IsNull(actual.Result); Assert.That(actual, Is.InstanceOf <ResultOf <ToTestClass> >()); }); }
private static ResultOf <Circle> GetCircle() { var result = new ResultOf <Circle>(); try { result.Value = new Circle(); } catch (NullReferenceException e) { result.AddMessage(e.Message); } return(result); }
public void Equals_Success_IsFail_Test() { // arrange var result1 = ResultOf <FromTestClass> .CreateSuccess(new FromTestClass()); var result2 = ResultOf <FromTestClass> .CreateSuccess(new FromTestClass()); // act var actual1 = result1.Equals(result2); var actual2 = result2.Equals(result1); // assert Assert.IsFalse(actual1); Assert.IsFalse(actual2); }
public static ResultOf<Image> GetImage(EventHandler processor) { var result = new ResultOf<Image>(); try { result.Value = new Image(); Application.Idle += processor; } catch (NullReferenceException e) { result.AddMessage(e.Message); } return result; }
public static ResultOf <Image> GetImage(EventHandler processor) { var result = new ResultOf <Image>(); try { result.Value = new Image(); Application.Idle += processor; } catch (NullReferenceException e) { result.AddMessage(e.Message); } return(result); }
public void Equals_Invalid_IsOk_Test() { // arrange var result1 = ResultOf <FromTestClass> .CreateInvalid("Test"); var result2 = ResultOf <FromTestClass> .CreateInvalid("Test"); // act var actual1 = result1.Equals(result2); var actual2 = result2.Equals(result1); // assert Assert.IsTrue(actual1); Assert.IsTrue(actual2); }
public void Equals_Empty_IsOk_Test() { // arrange var result1 = ResultOf <FromTestClass> .CreateEmpty(); var result2 = ResultOf <FromTestClass> .CreateEmpty(); // act var actual1 = result1.Equals(result2); var actual2 = result2.Equals(result1); // assert Assert.Multiple(() => { Assert.IsTrue(actual1); Assert.IsTrue(actual2); }); }
public void Equals_Invalid_IsFail_Test() { // arrange var result1 = ResultOf <FromTestClass> .CreateInvalid("Test1"); var result2 = ResultOf <FromTestClass> .CreateInvalid("Test2"); // act var actual1 = result1.Equals(result2); var actual2 = result2.Equals(result1); // assert Assert.Multiple(() => { Assert.IsFalse(actual1); Assert.IsFalse(actual2); }); }
public void Equals_Success_IsOk_Test() { // arrange var obj = new FromTestClass(); var result1 = ResultOf <FromTestClass> .CreateSuccess(obj); var result2 = ResultOf <FromTestClass> .CreateSuccess(obj); // act var actual1 = result1.Equals(result2); var actual2 = result2.Equals(result1); // assert Assert.Multiple(() => { Assert.IsTrue(actual1); Assert.IsTrue(actual2); }); }
public async Task <ResultOf <TResponse> > Handle(TRequest request, CancellationToken cancellationToken) { var validationFails = _validators.Select(i => i.Validate(request)) .Where(i => !i.IsValid) .SelectMany(i => i.Errors) .Select(i => i.ErrorMessage) .ToArray(); if (validationFails.Any()) { var errorMessage = string.Join("\n", validationFails); return(ResultOf <TResponse> .BadRequest(errorMessage)); } var queryResult = await ProcessQueryAsync(request, cancellationToken) .ConfigureAwait(false); return(ResultOf <TResponse> .Ok(queryResult)); }
public ResultOf <MainLang> ParseMainLang(ResultOf <Loop1Syntax> loop1Result) { return(null); }
public void Result(ResultOf <MainLang> main) { }
public void Result(ResultOf <BaseLang> main) { }