public static MethodResult <TResult> MapMethodResult <TSource, TResult>(
this MethodResult <TSource> @this,
Func <TResult> onSuccessFunction,
ErrorDetail errorDetail
) => @this.IsSuccess
? MethodResult <TResult> .Ok(onSuccessFunction())
: MethodResult <TResult> .Fail(errorDetail);
public static async Task <MethodResult> MapMethodResultAsync <TSource>(
this Task <MethodResult <TSource> > @this)
{
var methodResult = await @this;
return(methodResult.IsSuccess ? MethodResult.Ok() : MethodResult.Fail(methodResult.Detail));
}
public Task <MethodResult> CreateAsync(PersonViewModel personViewModel) =>
TryExtensions.TryAsync(async() => {
var validationResult = await ValidatePersonViewModel(personViewModel);
if (!validationResult.IsSuccess)
{
return(validationResult);
}
var standardPhoneResult = PhoneUtility.GetPhone(personViewModel.Phone);
if (!standardPhoneResult.IsSuccess)
{
return(MethodResult.Fail(standardPhoneResult.Detail));
}
personViewModel.Phone = standardPhoneResult.Value;
personViewModel.RegisterDateTime = DateTime.UtcNow;
var mainPersonModel = MapToMainModel(personViewModel);
if (personViewModel.ProfilePhotoFile != null)
{
var processResult = await ProcessFile(personViewModel.ProfilePhotoFile, personViewModel.Id);
if (!processResult.IsSuccess)
{
return(MethodResult.Fail(processResult.Detail));
}
mainPersonModel.ProfileImageName = processResult.Value;
}
await _context.Person.AddAsync(mainPersonModel);
await _context.SaveChangesAsync();
return(MethodResult.Ok());
}, 1);
public static MethodResult <TResult> MapMethodResult <TSource, TResult>(
this MethodResult <TSource> @this,
Func <TSource, TResult> onSuccessFunction,
Func <ResultDetail, ErrorDetail> onFailFunction
) => @this.IsSuccess
? MethodResult <TResult> .Ok(onSuccessFunction(@this.Value))
: MethodResult <TResult> .Fail(onFailFunction(@this.Detail));
public MethodResult Compare(List <ExcelTest_CoordinateInfo> info, ExcelResult expected, ExcelResult actual, string testName, string testOutputDirectory, string errorFileName)
{
var expectedWS = expected.ExcelPackage.Workbook.Worksheets[1];
var actualWS = actual.ExcelPackage.Workbook.Worksheets[1];
var mainDataComparisonResults = new List <ExcelComparison>();
foreach (var i in info)
{
var xs = this.Compare(i, expectedWS, actualWS);
mainDataComparisonResults.AddRange(xs);
}
var isOk = mainDataComparisonResults.All(a => a.ExpectedAndActual_AreEqual);
if (isOk)
{
return(MethodResult.Ok(Status.Success, "Files are the same."));
}
var message = new StringBuilder();
var errorCount = mainDataComparisonResults.Where(a => !a.ExpectedAndActual_AreEqual).Count();
var fullCount = mainDataComparisonResults.Count();
var percentFailed = Math.Round(((double)errorCount / fullCount) * 100);
message.AppendLine($"All numeric cells are expected to be identical. { percentFailed }% ({ errorCount } of { fullCount }) error rate.");
foreach (var excelComparisonResult in mainDataComparisonResults.Where(a => !a.ExpectedAndActual_AreEqual))
{
excelComparisonResult.Message = $"{ this.ExcelService.ColumnLetter_FromColumnNumber(excelComparisonResult.Column) }{ excelComparisonResult.Row } Expected: { excelComparisonResult.Expected } Actual: { excelComparisonResult.Actual }";
message.AppendLine(excelComparisonResult.Message);
}
var _message = message.ToString();
this.CreateOutputWorksheet(mainDataComparisonResults, actual, testName, testOutputDirectory, errorFileName, _message);
return(MethodResult.Fail($"Files are not the same. Failure: { percentFailed }%.\r\nDetails here: { testOutputDirectory }/{ errorFileName }"));
}
public static MethodResult <TResult> Try <TResult>(
Func <TResult> function)
{
try {
return(MethodResult <TResult> .Ok(function()));
}
catch (Exception e) {
return(MethodResult <TResult> .Fail(new ExceptionError(e, message : e.Message)));
}
}
public static MethodResult Try(Action action)
{
try {
action();
return(MethodResult.Ok());
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e, message: e.Message)));
}
}
public static async Task <MethodResult <TResult> > TryAsync <TResult>(
Func <Task <MethodResult <TResult> > > onSuccessFunction
)
{
try {
return(await onSuccessFunction());
}
catch (Exception e) {
return(MethodResult <TResult> .Fail(new ExceptionError(e, e.Message)));
}
}
public static MethodResult Try <T>(
this T @this,
Action <T> action)
{
try {
action(@this);
return(MethodResult.Ok());
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e)));
}
}
public static async Task <MethodResult> TryAsync <T>(
this T @this,
Func <T, Task <MethodResult> > onSuccessFunction
)
{
try {
return(await onSuccessFunction(@this));
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e, e.Message)));
}
}
public static async Task <MethodResult <TResult> > TryMapAsync <TResult>(
this Task @this,
Func <MethodResult <TResult> > onSuccessFunction
)
{
try {
await @this;
return(onSuccessFunction());
}
catch (Exception e) {
return(MethodResult <TResult> .Fail(new ExceptionError(e, e.Message)));
}
}
public static async Task <MethodResult <TResult> > TryMapAsync <TSource, TResult>(
this Task <TSource> @this,
Func <TSource, Task <MethodResult <TResult> > > onSuccessFunction
)
{
try {
var source = await @this;
return(await onSuccessFunction(source));
}
catch (Exception e) {
return(MethodResult <TResult> .Fail(new ExceptionError(e, e.Message)));
}
}
public static async Task <MethodResult <T> > TryAsync <T>(
Func <Task <T> > onSuccessFunction
)
{
try {
var result = await onSuccessFunction();
return(MethodResult <T> .Ok(result));
}
catch (Exception e) {
return(MethodResult <T> .Fail(new ExceptionError(e, e.Message)));
}
}
public static async Task <MethodResult <TResult> > TryMapAsync <TSource, TResult>(
this TSource _,
Func <Task <TResult> > onSuccessFunction
)
{
try {
var result = await onSuccessFunction();
return(MethodResult <TResult> .Ok(result));
}
catch (Exception e) {
return(MethodResult <TResult> .Fail(new ExceptionError(e, e.Message)));
}
}
public static async Task <MethodResult> TryAsync(
this Task @this,
Action onSuccessFunction
)
{
try {
await @this;
onSuccessFunction();
return(MethodResult.Ok());
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e, e.Message)));
}
}
public static async Task <MethodResult> TryAsync <TSource>(
this Task <TSource> @this,
Action <TSource> onSuccessFunction
)
{
try {
var source = await @this;
onSuccessFunction(source);
return(MethodResult.Ok());
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e, e.Message)));
}
}
public static MethodResult ForEachUntilIsSuccess <TSource, TResult>(
this IEnumerable <TSource> @this,
Func <TSource, MethodResult <TResult> > function)
{
foreach (var item in @this)
{
var result = function(item);
if (!result.IsSuccess)
{
return(MethodResult.Fail(result.Detail));
}
}
return(MethodResult.Ok());
}
public static async Task <MethodResult <TResult> > TryMapAsync <TSource, TResult>(
this Task <TSource> @this,
Func <TResult> onSuccessFunction,
Func <ResultDetail, MethodResult <TResult> > onFailFunction
)
{
try {
await @this;
var result = onSuccessFunction();
return(MethodResult <TResult> .Ok(result));
}
catch (Exception e) {
return(MethodResult <TResult> .Fail(new ExceptionError(e)));
}
}
public static Task <MethodResult> ForEachUntilIsSuccessAsync <TSource, TResult>(
this Task <IEnumerable <TSource> > @this,
Func <TSource, Task <MethodResult <TResult> > > function) =>
TryExtensions.TryAsync(() => @this)
.OnSuccessAsync(async items => {
foreach (var item in items)
{
var result = await function(item);
if (!result.IsSuccess)
{
return(MethodResult.Fail(result.Detail));
}
}
return(MethodResult.Ok());
});
public static MethodResult IsNotNullOrEmpty(
this IEnumerable? @this,
ErrorDetail?errorDetail = null,
bool showDefaultMessageToUser = true)
{
var error = errorDetail ?? new ErrorDetail(StatusCodes.Status400BadRequest,
title: "IsNullOrEmptyError",
message: "object is not null or empty.",
showDefaultMessageToUser: showDefaultMessageToUser);
if (@this is null || @this.IsNullOrEmpty())
{
return(MethodResult.Fail(error));
}
return(MethodResult.Ok());
}
private static MethodResult ValidateInputs(string fileName, params string[] validTypes)
{
if (string.IsNullOrEmpty(fileName))
{
return(MethodResult.Fail(new BadRequestError(message: $"{nameof(fileName)} is null or empty.")));
}
if (!File.Exists(fileName))
{
return(MethodResult.Fail(new NotFoundError(message: $"{nameof(fileName)} is not exist.")));
}
if (validTypes.IsNullOrEmpty())
{
return(MethodResult.Fail(new BadRequestError(message: $"{nameof(validTypes)} is null or empty.")));
}
return(MethodResult.Ok());
}
public static Task <MethodResult> ForEachUntilIsSuccessAsync <T>(
this Task <IEnumerable <T> > @this,
Func <T, Task> action) => TryExtensions.TryAsync(() => @this)
.OnSuccessAsync(async items => {
var list = items.ToList();
foreach (var item in list)
{
try {
await action(item);
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e,
moreDetails: new { thisObj = list, targetItem = item })));
}
}
return(MethodResult.Ok());
});
public static MethodResult ForEachUntilIsSuccess <T>(
this IEnumerable <T> @this,
Action <T> action)
{
var list = @this.ToList();
foreach (var item in list)
{
try {
action(item);
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e,
moreDetails: new { thisObj = list, targetItem = item })));
}
}
return(MethodResult.Ok());
}
public static async Task <MethodResult <List <TResult> > > SelectResultsAsync <TSource, TResult>(
this Task <IEnumerable <TSource> > @this,
Func <TSource, MethodResult <TResult> > function)
{
var thisList = (await @this).ToList();
var selectedResult = new List <TResult>(thisList.Count);
foreach (var item in thisList)
{
var result = function(item);
if (!result.IsSuccess)
{
result.Detail.AddDetail(new { thisObj = @this, targetItem = item });
return(MethodResult <List <TResult> > .Fail(result.Detail));
}
selectedResult.Add(result.Value);
}
return(MethodResult <List <TResult> > .Ok(selectedResult));
}
public static async Task <MethodResult> ForEachUntilIsSuccessAsync <TSource, TResult>(
this IEnumerable <MethodResult <TSource> > @this,
Func <TSource, Task <MethodResult <TResult> > > function)
{
foreach (var item in @this)
{
if (!item.IsSuccess)
{
return(item.MapMethodResult());
}
var result = await function(item.Value);
if (!result.IsSuccess)
{
return(MethodResult.Fail(result.Detail));
}
}
return(MethodResult.Ok());
}
public static async Task <MethodResult <T> > TryAsync <T>(
Func <Task <MethodResult <T> > > function,
int numOfTry)
{
var counter = 0;
while (true)
{
try {
return(await function());
}
catch (Exception e) {
counter++;
if (counter >= numOfTry)
{
return(MethodResult <T> .Fail(new ExceptionError(e,
moreDetails : new { numOfTry })));
}
}
}
}
public static async Task <MethodResult <List <TResult> > > SelectResultsAsync <TSource, TResult>(
this Task <IEnumerable <TSource> > @this,
Func <TSource, TResult> function)
{
var thisList = (await @this).ToList();
var selectedResult = new List <TResult>(thisList.Count);
foreach (var item in thisList)
{
try {
var result = function(item);
selectedResult.Add(result);
}
catch (Exception e) {
return(MethodResult <List <TResult> > .Fail(new ExceptionError(e,
moreDetails : new { thisObj = thisList, targetItem = item })));
}
}
return(MethodResult <List <TResult> > .Ok(selectedResult));
}
private async Task <MethodResult> ValidatePersonViewModel(PersonViewModel personViewModel)
{
var modelValidationResult = Method.MethodParametersMustValid(
new [] { personViewModel }, showDefaultMessageToUser: false);
if (!modelValidationResult.IsSuccess)
{
return(modelValidationResult);
}
if (personViewModel.ProfilePhotoFile != null)
{
var fileValidationResult = await FileValidationAsync(
personViewModel.ProfilePhotoFile, nameof (personViewModel.ProfilePhotoFile));
if (!fileValidationResult.IsSuccess)
{
return(MethodResult.Fail(fileValidationResult.Detail));
}
}
return(MethodResult.Ok());
}
public static async Task <MethodResult> ForEachUntilIsSuccessAsync <T>(
this IEnumerable <MethodResult <T> > @this,
Func <T, Task> action)
{
var list = @this.ToList();
foreach (var item in list)
{
if (!item.IsSuccess)
{
return(item.MapMethodResult());
}
try {
await action(item.Value);
}
catch (Exception e) {
return(MethodResult.Fail(new ExceptionError(e,
moreDetails: new { thisObj = list, targetItem = item })));
}
}
return(MethodResult.Ok());
}
public void Invalid_First_Argument_Returns_False()
{
var arguments = new string[] { "operation", "filename" };
var mockTarget = new Mock <ArgumentParser>();
mockTarget.CallBase = true;
mockTarget.Setup(t => t.ParseOperationParameter(It.Is <string>(s => s == "operation"))).Returns(MethodResult <FileInformationArguments> .Fail("error"));
var target = mockTarget.Object;
var result = target.Parse(arguments);
Assert.IsFalse(result.IsSuccess);
mockTarget.VerifyAll();
}
