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)
{
}
