//
// Async types
//
public static TryOptionAsync <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, TryOptionAsync <A> > ma, Func <A, B> f)
{
return(ToTry(() => Go(ma, f)));
async Task <OptionalResult <EitherAsync <L, B> > > Go(EitherAsync <L, TryOptionAsync <A> > ma, Func <A, B> f)
{
var da = await ma.Data;
if (da.State == EitherStatus.IsBottom)
{
return(OptionalResult <EitherAsync <L, B> > .Bottom);
}
if (da.State == EitherStatus.IsLeft)
{
return(new OptionalResult <EitherAsync <L, B> >(EitherAsync <L, B> .Left(da.Left)));
}
var rb = await da.Right.Try();
if (rb.IsFaulted)
{
return(new OptionalResult <EitherAsync <L, B> >(rb.Exception));
}
if (rb.IsNone)
{
return(OptionalResult <EitherAsync <L, B> > .None);
}
return(new OptionalResult <EitherAsync <L, B> >(EitherAsync <L, B> .Right(f(rb.Value.Value))));
}
}
public EitherAsync <L, R> Plus(EitherAsync <L, R> ma, EitherAsync <L, R> mb)
{
async Task <EitherData <L, R> > Do(EitherAsync <L, R> mma, EitherAsync <L, R> mmb)
{
var resA = ma.ToEither();
var resB = mb.ToEither();
var tasks = Set <OrdTask <Either <L, R> >, Task <Either <L, R> > >(resA, resB);
while (tasks.Count > 0)
{
// Return first one that completes
var completed = await Task.WhenAny(tasks).ConfigureAwait(false);
if (!completed.IsFaulted && !completed.Result.IsRight)
{
return(completed.Result.Head());
}
tasks = tasks.Remove(completed);
}
if (resA.IsCompleted && !resA.IsFaulted && !resA.IsCanceled && resA.Result.IsRight)
{
return(resA.Result.Head());
}
if (resB.IsCompleted && !resB.IsFaulted && !resB.IsCanceled && resB.Result.IsRight)
{
return(resB.Result.Head());
}
return(EitherData <L, R> .Bottom);
}
return(new EitherAsync <L, R>(Do(ma, mb)));
}
public EitherAsync <L, R> Apply(Func <R, R, R> f, EitherAsync <L, R> ma, EitherAsync <L, R> mb)
{
async Task <EitherData <L, R> > Do(Func <R, R, R> ff, EitherAsync <L, R> mma, EitherAsync <L, R> mmb)
{
var resA = ma.ToEither();
var resB = mb.ToEither();
await Task.WhenAll(resA, resB).ConfigureAwait(false);
if (resA.IsCompleted && !resA.IsFaulted && !resA.IsCanceled && resA.Result.IsLeft)
{
return(resA.Result.Head());
}
if (resB.IsCompleted && !resB.IsFaulted && !resB.IsCanceled && resB.Result.IsLeft)
{
return(resB.Result.Head());
}
if (resA.Result.IsRight && resB.Result.IsRight)
{
return(new EitherData <L, R>(EitherStatus.IsRight, ff(resA.Result.RightValue, resB.Result.RightValue), default(L)));
}
return(EitherData <L, R> .Bottom);
}
return(new EitherAsync <L, R>(Do(f, ma, mb)));
}
public Task <TokenDto> Handle(RegisterUserCommand request, CancellationToken cancellationToken)
{
return(_applicationUserDxo.Map(request)
.MapAsync(async user =>
{
var identityResult = await _userManager.CreateAsync(user, request.Password);
return (user, identityResult);
})
.Map(tuple => tuple.identityResult.Succeeded
? EitherAsync <IdentityResult, ApplicationUser> .Right(tuple.user)
: EitherAsync <IdentityResult, ApplicationUser> .Left(tuple.identityResult))
.MapAsyncT(user => _jwtService.GenerateSecurityToken(user))
.MapT(s => _tokenDxo.Map(s))
.Match(async => async.Match(
dto =>
{
return dto.Match(tokenDto => tokenDto.AsTask(),
exception => exception.AsFailedTask <TokenDto>());
},
result =>
{
return new ArgumentException(string.Join(",", result.Errors.Select(error => error.Description)))
.AsFailedTask <TokenDto>();
}),
exception => exception.AsFailedTask <TokenDto>())
.Flatten());
}
//
// Async types
//
public static TryAsync <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, TryAsync <A> > ma, Func <A, B> f)
{
return(ToTry(() => Go(ma, f)));
async Task <Result <EitherAsync <L, B> > > Go(EitherAsync <L, TryAsync <A> > ma, Func <A, B> f)
{
var da = await ma.Data.ConfigureAwait(false);
if (da.State == EitherStatus.IsBottom)
{
return(Result <EitherAsync <L, B> > .Bottom);
}
if (da.State == EitherStatus.IsLeft)
{
return(new Result <EitherAsync <L, B> >(da.Left));
}
var rb = await da.Right.Try().ConfigureAwait(false);
if (rb.IsFaulted)
{
return(new Result <EitherAsync <L, B> >(rb.Exception));
}
return(new Result <EitherAsync <L, B> >(EitherAsync <L, B> .Right(f(rb.Value))));
}
}
private void MockGetUser(EitherAsync <Error, User> result)
{
_getHandler.Handle(Arg.Any <GetUser.Request>())
.Returns(result);
OverrideHandlerMetadata <GetUser.Request>(
new HandlerInfo("IdentityAndAccess", "GetUser"));
}
public static EitherAsync <L, EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, EitherAsync <L, A> > ma, Func <A, B> f)
{
return(new EitherAsync <L, EitherAsync <L, B> >(Go(ma, f)));
async Task <EitherData <L, EitherAsync <L, B> > > Go(EitherAsync <L, EitherAsync <L, A> > ma, Func <A, B> f)
{
var da = await ma.Data.ConfigureAwait(false);
if (da.State == EitherStatus.IsBottom)
{
return(EitherData <L, EitherAsync <L, B> > .Bottom);
}
if (da.State == EitherStatus.IsLeft)
{
return(EitherData.Right <L, EitherAsync <L, B> >(EitherAsync <L, B> .Left(da.Left)));
}
var db = await da.Right.Data.ConfigureAwait(false);
if (db.State == EitherStatus.IsBottom)
{
return(EitherData <L, EitherAsync <L, B> > .Bottom);
}
if (db.State == EitherStatus.IsLeft)
{
return(EitherData.Left <L, EitherAsync <L, B> >(db.Left));
}
return(EitherData.Right <L, EitherAsync <L, B> >(EitherAsync <L, B> .Right(f(db.Right))));
}
}
public static Task <IActionResult> ToActionResult <T>(this EitherAsync <RfcErrorInfo, T> result)
{
return(result.Match(
r => (IActionResult) new ObjectResult(r),
l => new ObjectResult(l.Message)
{
StatusCode = (int)HttpStatusCode.InternalServerError
}));
}
public MB BindAsync <MONADB, MB, B>(EitherAsync <L, R> ma, Func <R, Task <MB> > f) where MONADB : struct, MonadAsync <Unit, Unit, MB, B>
{
Task <MB> Do(Unit _) =>
ma.MatchAsync(
Left: l => default(MONADB).Fail(l),
RightAsync: async r => await f(r).ConfigureAwait(false),
Bottom: () => default(MONADB).Fail(BottomException.Default));
return(default(MONADB).RunAsync(Do));
}
public static EitherAsync <TLeft, TRight> LogWarningLeft <TLeft, TRight>(this EitherAsync <TLeft, TRight> @this, ILogger logger, Func <TLeft, string> messageFunc)
{
@this.Match(
_ => unit,
leftCase =>
{
logger.LogWarning(messageFunc(leftCase));
return(unit);
});
return(@this);
}
//
// Async types
//
public static Aff <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, Aff <A> > ma, Func <A, B> f)
{
return(AffMaybe <EitherAsync <L, B> >(() => Go(ma, f)));
async ValueTask <Fin <EitherAsync <L, B> > > Go(EitherAsync <L, Aff <A> > ma, Func <A, B> f)
{
var da = await ma.Data.ConfigureAwait(false);
if (da.State == EitherStatus.IsBottom)
{
return(default);
public static Aff <RT, EitherAsync <L, B> > Traverse <RT, L, A, B>(this EitherAsync <L, Aff <RT, A> > ma, Func <A, B> f)
where RT : struct, HasCancel <RT>
{
return(AffMaybe <RT, EitherAsync <L, B> >(env => Go(env, ma, f)));
async ValueTask <Fin <EitherAsync <L, B> > > Go(RT env, EitherAsync <L, Aff <RT, A> > ma, Func <A, B> f)
{
var da = await ma.Data.ConfigureAwait(false);
if (da.State == EitherStatus.IsBottom)
{
return(default);
public Task <EitherAsync <Error, Unit> > Handle(SaveXmlCommand request, CancellationToken cancellationToken)
{
return(_xmlTransactionService.GetXmlTransactionModel(request)
.Bind(xmlTransactionModel => _xmlTransactionDxo.MapTransaction(xmlTransactionModel))
.Bind(transactions => _transactionRepository.CreateAsync(transactions))
.Bind(transactions => _transactionRepository.SaveAsync())
.Match(EitherAsync <Error, Unit> .Right,
error =>
{
_mediator.Publish(SaveXmlFailedEvent.CreateInstance(error.Message),
cancellationToken).ToUnit();
return EitherAsync <Error, Unit> .Left(error);
}));
}
public static async ValueTask <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, ValueTask <A> > ma, Func <A, B> f)
{
var da = await ma.Data.ConfigureAwait(false);
if (da.State == EitherStatus.IsBottom)
{
throw new BottomException();
}
if (da.State == EitherStatus.IsLeft)
{
return(EitherAsync <L, B> .Left(da.Left));
}
var a = await da.Right.ConfigureAwait(false);
return(EitherAsync <L, B> .Right(f(a)));
}
public EitherAsync <Error, Player> Get(TenantId tenant, PlayerId id)
{
return(PerformStorageOperation(_options.PlayersTable,
tableRef =>
{
var getOperation = TableOperation.Retrieve <PlayerEntity>(tenant.ToString(), id.ToString());
EitherAsync <Error, TableResult> getResult = tableRef.ExecuteAsync(getOperation);
return getResult.Match <Either <Error, Player> >(
tableResult => tableResult.Result switch
{
PlayerEntity playerEntity => _playerFactory.Create(
_mapper.Map <PlayerEntity, PlayerFactoryDto>(playerEntity)),
_ => Error.NotFound()
},
public EitherAsync <Error, User> Add(User user)
{
return(PerformStorageOperation(_options.UsersTable,
tableRef =>
{
var userEntity = new UserEntity(user);
var createOperation = TableOperation.Insert(userEntity);
EitherAsync <Error, TableResult> createResult = tableRef.ExecuteAsync(createOperation);
return createResult.Match(
tableResult => tableResult.Result switch
{
UserEntity created => (Either <Error, User>)_userFactory.CreateUser(
_mapper.Map <UserEntity, UserFactoryDto>(created)),
_ => Error.InternalError(
$"Azure Storage: Failed to create user with {tableResult.HttpStatusCode} error.")
},
//
// Async types
//
public static async Task <EitherAsync <L, B> > Traverse <L, A, B>(this EitherAsync <L, Task <A> > ma, Func <A, B> f)
{
var da = await ma.Data;
if (da.State == EitherStatus.IsBottom)
{
throw new BottomException();
}
if (da.State == EitherStatus.IsLeft)
{
return(EitherAsync <L, B> .Left(da.Left));
}
var a = await da.Right;
if (da.Right.IsFaulted)
{
ExceptionDispatchInfo.Capture(da.Right.Exception.InnerException).Throw();
}
return(EitherAsync <L, B> .Right(f(a)));
}
public Task <TokenDto> Handle(SignInCommand request, CancellationToken cancellationToken)
{
return(TryAsync(async() =>
{
var user = await _userManager.FindByEmailAsync(request.Email);
var identityResult = await _userManager.CheckPasswordAsync(user, request.Password);
return (user, identityResult);
}).Map(tuple => tuple.identityResult
? EitherAsync <bool, ApplicationUser> .Right(tuple.user)
: EitherAsync <bool, ApplicationUser> .Left(tuple.identityResult))
.MapAsyncT(user => _jwtService.GenerateSecurityToken(user))
.MapT(s => _tokenDxo.Map(s))
.Match(async => async.Match(
dto =>
{
return dto.Match(tokenDto => tokenDto.AsTask(),
exception => exception.AsFailedTask <TokenDto>());
},
result => new ArgumentException("Bad password")
.AsFailedTask <TokenDto>()),
exception => exception.AsFailedTask <TokenDto>())
.Flatten());
}
public EitherAsync <L, A> PureAsync(Task <A> x) => EitherAsync <L, A> .RightAsync(x);
public EitherAsync <L, B> MapAsync(EitherAsync <L, A> ma, Func <A, Task <B> > f) => ma.MapAsync(f);
public EitherAsync <L, B> Map(EitherAsync <L, A> ma, Func <A, B> f) => ma.Map(f);
public EitherAsync <L, B> BiMapAsync(EitherAsync <L, A> ma, Func <L, Task <B> > fa, Func <A, Task <B> > fb) => default(FEitherAsync <L, A, B>).BiMapAsync(ma, fa, fb);
public EitherAsync <L, B> Apply(EitherAsync <L, Func <A, B> > fab, EitherAsync <L, A> fa) => from f in fab from a in fa select f(a);
public EitherAsync <L, B> Action(EitherAsync <L, A> fa, EitherAsync <L, B> fb) => from a in fa from b in fb select b;
public static EitherAsync <L, EitherAsync <L, B> > Sequence <L, A, B>(this EitherAsync <L, A> ta, Func <A, EitherAsync <L, B> > f) => ta.Map(f).Sequence();
public EitherAsync <Exception, Option <Tea> > FetchById(string id) =>
EitherAsync <Exception, Option <Tea> > .Right(
new Option <Tea>(Some(_teas.Single())));
public EitherAsync <Exception, Option <IList <Tea> > > FetchAll() =>
EitherAsync <Exception, Option <IList <Tea> > > .Right(
new Option <IList <Tea> >(Some(_teas))
);
public static TryAsync <EitherAsync <L, A> > Sequence <L, A>(this EitherAsync <L, TryAsync <A> > ta) => ta.Traverse(identity);
public static OptionAsync <EitherAsync <L, B> > Sequence <L, A, B>(this EitherAsync <L, A> ta, Func <A, OptionAsync <B> > f) => ta.Map(f).Sequence();
public static async Task ShouldBeRight <TLeft, TRight>(this EitherAsync <TLeft, TRight> @this, Action <TRight> rightValidation) => await @this.Match(rightValidation, Common.ThrowIfLeft);
