/// <inheritdoc />
protected override async Task <Result <Array <Entity>, IError> > Run(
IStateMonad stateMonad,
CancellationToken cancellationToken)
{
var entityStreamResult = await EntityStream.Run(stateMonad, cancellationToken);
if (entityStreamResult.IsFailure)
{
return(entityStreamResult.ConvertFailure <Array <Entity> >());
}
var currentState = stateMonad.GetState().ToImmutableDictionary();
async ValueTask <Entity> Action(Entity record)
{
await using var scopedMonad = new ScopedStateMonad(
stateMonad,
currentState,
new KeyValuePair <VariableName, object>(Variable, record)
);
var result = await Function.Run(scopedMonad, cancellationToken);
if (result.IsFailure)
{
throw new ErrorException(result.Error);
}
return(result.Value);
}
var newStream = entityStreamResult.Value.SelectAwait(Action);
return(newStream);
}
/// <inheritdoc />
protected override async Task <Result <Array <Entity>, IError> > Run(
IStateMonad stateMonad,
CancellationToken cancellationToken)
{
var mappings = await Mappings.Run(stateMonad, cancellationToken)
.Map(
e => e
.ToDictionary(x => x.Name, x => x.BestValue.GetPrimitiveString())
);
if (mappings.IsFailure)
{
return(mappings.ConvertFailure <Array <Entity> >());
}
var entityStream = await EntityStream.Run(stateMonad, cancellationToken);
if (entityStream.IsFailure)
{
return(entityStream.ConvertFailure <Array <Entity> >());
}
var newEntityStream = entityStream.Value
.Select(e => ChangeHeader(e, mappings.Value));
return(newEntityStream);
public static async Task <GameModel> CreateAsync(Game game)
{
var stream = await EntityStream.CreateAsync(DatabaseProvider.Connection, game.Id);
var teamHandler = new TeamHandler();
await stream.ExecuteAsync(teamHandler);
var counterTerrorists = await DatabaseProvider.MapPlayersAsync(teamHandler.CounterTerroristIds);
var terrorists = await DatabaseProvider.MapPlayersAsync(teamHandler.TerroristIds);
return(new GameModel
{
Game = game,
CounterTerrorists = counterTerrorists,
Terrorists = terrorists,
});
}
public Task<EntityStream> UpdateAsync(EntityStream entity)
{
throw new NotImplementedException();
}
public EntityStream Update(EntityStream entity)
{
throw new NotImplementedException();
}
public void Delete(EntityStream entity)
{
throw new NotImplementedException();
}
/// <inheritdoc />
protected override async Task <Result <Array <Entity>, IError> > Run(
IStateMonad stateMonad,
CancellationToken cancellationToken)
{
var entityStream = await EntityStream.Run(stateMonad, cancellationToken);
if (entityStream.IsFailure)
{
return(entityStream.ConvertFailure <Array <Entity> >());
}
var schemaEntity = await Schema.Run(stateMonad, cancellationToken);
if (schemaEntity.IsFailure)
{
return(schemaEntity.ConvertFailure <Array <Entity> >());
}
var schema = EntityConversionHelpers.TryCreateFromEntity <Schema>(schemaEntity.Value)
.MapError(e => e.WithLocation(this));
if (schema.IsFailure)
{
return(schema.ConvertFailure <Array <Entity> >());
}
Maybe <ErrorBehavior> errorBehavior;
if (ErrorBehavior == null)
{
errorBehavior = Maybe <ErrorBehavior> .None;
}
else
{
var errorBehaviorResult = await ErrorBehavior.Run(stateMonad, cancellationToken);
if (errorBehaviorResult.IsFailure)
{
return(errorBehaviorResult.ConvertFailure <Array <Entity> >());
}
errorBehavior = Maybe <ErrorBehavior> .From(errorBehaviorResult.Value);
}
var newStream = entityStream.Value.SelectMany(ApplySchema);
return(newStream);
async IAsyncEnumerable <Entity> ApplySchema(Entity entity)
{
await ValueTask.CompletedTask;
var result = schema.Value.ApplyToEntity(entity, this, stateMonad, errorBehavior);
if (result.IsFailure)
{
throw new ErrorException(result.Error.WithLocation(this));
}
if (result.Value.HasValue)
{
yield return(result.Value.Value);
}
}
}
public EntityStream Update(EntityStream entity)
{
throw new NotImplementedException();
}
public void Delete(EntityStream entity)
{
throw new NotImplementedException();
}
