public async Task Save <T>(T aggregate, CancellationToken cancellationToken = default, NonEmptyGuid?causationId = null, NonEmptyGuid?correlationId = null) where T : IAggregate, new()
{
if (aggregate is Aggregate a)
{
causationId ??= NonEmptyGuid.New();
correlationId ??= causationId;
var uncommitted = a.GetUncommittedEvents().Select(x =>
{
var id = Guid.NewGuid().NonEmpty();
var metaData = CreateMetadata(new Dictionary <string, string>
{
{ "id", Guid.NewGuid().ToString() },
{ "causationId", causationId.Value.ToString() },
{ "correlationId", correlationId.Value.ToString() }
});
causationId = id;
return(x, metaData);
}).ToArray();
await _eventRepository.Save(cancellationToken, uncommitted);
}
else
{
throw new NotImplementedException();
}
}
public static ICurveRecipeCreated CurveRecipeCreated(NonEmptyGuid marketCurveId, NonEmptyString shortName, NonEmptyString description,
NonEmptyString lastLiquidTenor, NonEmptyString dayCountConvention,
NonEmptyString interpolation, NonEmptyString extrapolationShort,
NonEmptyString extrapolationLong, NonEmptyString outputSeries,
double maximumMaturity, NonEmptyString outputType)
=> new CurveRecipeCreated(marketCurveId, shortName, description, lastLiquidTenor, dayCountConvention,
interpolation, extrapolationShort, extrapolationLong, outputSeries,
maximumMaturity, outputType);
async Task <Either <Error, Vendor> > GetVendor(NonEmptyGuid id)
{
var instrument = await _instruments.Get(id);
return(instrument?.Vendor == null ?
new Error("Not found") :
instrument.Vendor.TryParseEnum <Vendor>());
}
public CurvePoint(Tenor tenor, NonEmptyGuid instrumentId, DateLag dateLag, bool isMandatory, PriceType?priceType)
{
Tenor = tenor;
InstrumentId = instrumentId;
DateLag = dateLag;
IsMandatory = isMandatory;
PriceType = priceType;
}
public void Construct_Guid_WithValue()
{
var guid = Guid.NewGuid();
var value = new NonEmptyGuid(guid);
Assert.IsType <NonEmptyGuid>(value);
Assert.Equal(guid, value);
}
public RecipeActor(NonEmptyGuid id)
{
_id = id;
IdempotentEvent <ICurveRecipeCreated>(Ignore, Recover);
Command <Calculate>(Handle);
}
public void CannotBeWithed()
{
var guid = new NonEmptyGuid(Guid.NewGuid());
// Does not compile:
// var b = guid with
// {
// _value = Guid.Empty,
// };
}
public static async Task <Either <Error, Instrument> > FromId(NonEmptyGuid id, GetVendor getVendor)
{
var vendor = await getVendor(id);
return(vendor.MapRight(v => new Instrument(id)
{
Vendor = v
}));
}
public CurveRecipe Define(NonEmptyGuid marketCurveId, NonEmptyString shortName, NonEmptyString description, Tenor lastLiquidTenor, DayCountConvention dayCountConvention, Interpolation interpolation, ExtrapolationShort extrapolationShort,
ExtrapolationLong extrapolationLong, OutputFrequency outputFrequency, OutputType outputType)
{
var @event = CurveRecipeCreated(marketCurveId, shortName, description, lastLiquidTenor, dayCountConvention, interpolation, extrapolationShort,
extrapolationLong, outputFrequency.OutputSeries, outputFrequency.MaximumMaturity.Value, outputType);
GenerateEvent(@event);
return(this);
}
public CurveCalculationResult WithResult(NonEmptyGuid recipeId, Date asOfDate, Either <Error, IEnumerable <CurvePoint> > result)
{
var e = result
.MapLeft(e => (IEvent)CurveCalculationFailed(recipeId, asOfDate.NonEmptyString(), e.Messages))
.Reduce(r => CurveCalculated(recipeId, asOfDate.NonEmptyString(), r.Select(x => Point(x.Maturity.Value, x.Price.Currency, x.Price.Value))));
GenerateEvent(e);
return(this);
}
public void CanCastToGuid()
{
var guid = Guid.NewGuid();
var nonEmptyGuid = new NonEmptyGuid(guid);
Assert.StrictEqual(nonEmptyGuid, guid);
Guid plainGuid = nonEmptyGuid;
Assert.StrictEqual(plainGuid, guid);
}
public async Task <T> Load <T>(NonEmptyGuid id, CancellationToken cancellationToken = default) where T : IAggregate, new()
{
var aggregate = new T();
if (aggregate is Aggregate eventSourced)
{
eventSourced.Id = id;
var filter = EventFilter.ForAggregate(id);
await foreach (var(item, _) in _readRepository.Get(filter, cancellationToken))
{
eventSourced.LoadFromHistory(item);
}
}
else
{
throw new NotImplementedException();
}
return(aggregate);
}
public ICanAddEventTypes ForAggregate(NonEmptyGuid id) => new EventFilterInstance(Checkpoint, id, EventTypes ?? Array.Empty <string>());
public static IInstrumentPricingPublished InstrumentPricingPublished(NonEmptyString asOfDate,
NonEmptyGuid instrumentId, NonEmptyString priceCurrency,
double priceAmount, NonEmptyString?priceType = null)
=> new InstrumentPricingPublished(asOfDate, instrumentId, priceCurrency, priceAmount, priceType);
private Instrument(NonEmptyGuid id)
{
Id = id;
}
public static ICanAddEventTypes ForAggregate(NonEmptyGuid id) => new EventFilterInstance().ForAggregate(id);
public static ICurveCalculated CurveCalculated(NonEmptyGuid curveRecipeId, NonEmptyString asOfDate, IEnumerable <IPoint> points) => new CurveCalculated(curveRecipeId, asOfDate, points);
public Instrument(NonEmptyGuid id, Vendor vendor) : this(id)
{
Vendor = vendor;
}
public static ICurveCalculationFailed CurveCalculationFailed(NonEmptyGuid curveRecipeId, NonEmptyString asOfDate, string[] messages) => new CurveCalculationFailed(curveRecipeId, asOfDate, messages);
public async Task <Either <Error, Nothing> > Handle(CancellationToken cancelationToken, NonEmptyGuid id, Func <TAggregate, Either <Error, TAggregate> > whatToDo)
{
var aggregate = await _aggregateStore.Load <TAggregate>(id, cancelationToken);
return(await
whatToDo(aggregate)
.MapRight(a => _aggregateStore.Save(a, cancelationToken))
.Reduce());
}
public async Task <Either <Error, Nothing> > Handle(CancellationToken cancelationToken, NonEmptyGuid id, Func <TAggregate, TAggregate> whatToDo)
{
var aggregate = await _aggregateStore.Load <TAggregate>(id, cancelationToken);
await _aggregateStore.Save(whatToDo(aggregate), cancelationToken);
return(Nothing.Instance);
}
public InstrumentPricing Define(Date asOfDate, NonEmptyGuid instrumentId, Price price, PriceType?priceType = null)
{
GenerateEvent(InstrumentPricingPublished(asOfDate.NonEmptyString(), instrumentId, price.Currency.NonEmptyString(), price.Value, priceType));
return(this);
}
public static ICurvePointAdded CurvePointAdded(NonEmptyString tenor, NonEmptyGuid instrumentId, short dateLag, bool isMandatory, NonEmptyString?priceType) => new CurvePointAdded(tenor, instrumentId, dateLag, isMandatory, priceType);
