public Task Handle(IEventWrapper <ICurvePointAdded> @event, CancellationToken cancellationToken)
=> _readModelRepository.Get(@event.AggregateId)
.IfNotNull(x =>
{
x.Tenors.Add(@event.Content.Tenor);
return(_readModelRepository.Update(x));
});
public Task Handle(IEventWrapper <IParallelShockAdded> @event, CancellationToken cancellationToken)
{
var transformation = new TransformationDto
{
Name = ParallelShock,
Parameters = new List <ParameterDto>()
{
new ParameterDto
{
Name = nameof(@event.Content.Shift),
Value = @event.Content.Shift.ToString()
},
new ParameterDto
{
Name = nameof(@event.Content.ShockTarget),
Value = @event.Content.ShockTarget
}
}
};
return(_readModelRepository.Get(@event.AggregateId)
.IfNotNull(recipe =>
{
recipe.Transformations.Add(transformation);
UpdateName(recipe, transformation);
return _readModelRepository.Update(recipe);
}));
}
public async Task Handle(IEventWrapper <ICurveCalculated> wrapper, CancellationToken cancellationToken)
{
var @event = wrapper.Content;
var asOfDate = @event.AsOfDate;
var recipe = (await _recipeRepository.Single(x => x.Id == @event.CurveRecipeId)) ?? new RecipeDto
{
Id = @event.CurveRecipeId.NonEmpty(),
Name = "unknown"
};
var dto = await _dtoRepository.Single(x => x.AsOfDate == asOfDate);
if (dto == null)
{
dto = new Dto
{
Id = NonEmpty.Guid(),
AsOfDate = asOfDate,
Recipes = new RecipeDto[] { recipe }
};
await _dtoRepository.Insert(dto);
}
else
{
var recipes = dto.Recipes.ToList();
recipes.Add(recipe);
dto.Recipes = recipes;
await _dtoRepository.Update(dto);
}
}
public Task Handle(IEventWrapper <ICurvePointAdded> wrapper, CancellationToken cancellationToken)
{
var @event = wrapper.Content;
return(_curveRepo.Get(wrapper.AggregateId).IfNotNull(curve =>
{
return _instrumentRepo.Get(@event.InstrumentId.NonEmpty()).IfNotNull(instrument =>
{
var points = curve.CurvePoints.ToList();
points.Add(new PointDto
{
InstrumentId = @event.InstrumentId,
DateLag = @event.DateLag,
IsMandatory = @event.IsMandatory,
Tenor = @event.Tenor,
PriceType = @event.PriceType,
Name = instrument.Name,
Vendor = instrument.Vendor
});
curve.CurvePoints = points.OrderBy(x => x.Tenor).ToList();
return _curveRepo.Update(curve);
});
}));
}
private void InternalSendNotification(string key, IEventWrapper eventWrapper)
{
if (_eventDict.ContainsKey(key) == true && _eventDict[key] != null)
{
//send event with delegates to listeners
_eventDict[key](eventWrapper);
}
}
public Task Handle(IEventWrapper <ICurveRecipeCreated> @event, CancellationToken cancellationToken)
{
return(_recipeRepository.Insert(new RecipeDto
{
Id = @event.AggregateId,
Name = @event.Content.ShortName
}));
}
public Task Handle(IEventWrapper <ICurveRecipeCreated> @event, CancellationToken cancellationToken)
{
_db.Add(new CurveRecipe
{
Id = @event.AggregateId,
Name = @event.Content.ShortName
});
return(Task.CompletedTask);
}
public static dynamic ConcreteGeneric(this IEventWrapper abst, Type?type = null)
{
type ??= abst.GetContent().GetType();
var ex = typeof(EventWrapperExtensions);
var mi = ex.GetMethod("Concrete");
var miConstructed = mi?.MakeGenericMethod(type);
object[] args = { abst };
return(miConstructed?.Invoke(null, args) ?? throw new Exception());
}
public Task Handle(IEventWrapper <ICurveRecipeCreated> @event, CancellationToken cancellationToken)
{
var dto = new Dto
{
Id = @event.AggregateId,
Name = @event.Content.ShortName
};
return(_readModelRepository.Insert(dto));
}
public Task Handle(IEventWrapper <IMarketCurveCreated> @event, CancellationToken cancellationToken)
{
var curve = new MarketCurveDto
{
Id = @event.AggregateId,
Name = GenerateName(@event.Content)
};
return(_readModelRepository.Insert(curve));
}
public Task Handle(IEventWrapper <IMarketCurveCreated> @event, CancellationToken cancellationToken)
{
var dto = new MarketCurveNamePartDto
{
Id = @event.AggregateId,
Value = GenerateName(@event.Content)
};
return(_marketCurveRepository.Insert(dto));
}
public async Task Done(IEventWrapper eventWrapper)
{
var eventRow = await Retrieve <EventRow>(eventWrapper.Id.ToString());
eventRow.IsDone = true;
eventRow.IsSuccessful = true;
eventRow.IsStarted = true;
eventRow.ExecutionDate = DateTimeOffset.UtcNow;
var replaceOperation = TableOperation.Replace(eventRow);
await _eventTable.ExecuteAsync(replaceOperation);
}
public static IEventWrapper <T> Concrete <T>(this IEventWrapper abst) where T : IEvent
{
var content = abst.GetContent();
if (content is T conc)
{
return(new EventWrapper <T>(conc, abst.Id, abst.AggregateId, abst.Timestamp, abst.Version));
}
throw new Exception();
}
internal void LoadFromHistory(IEventWrapper eventWrapper)
{
Version++;
if (eventWrapper.Version != Version)
{
throw new Exception();
}
When(eventWrapper.GetContent());
}
private void AddVersion <T>(IEventWrapper <T> e) where T : IEvent
{
if (!_eventVersions.ContainsKey(e.AggregateId))
{
_eventVersions.Add(e.AggregateId, e.Version);
}
else
{
_eventVersions[e.AggregateId] = e.Version;
}
}
public ActionManager(UserManager <User> userManager, IRepositoryWrapper repoWrapper, IMapper mapper,
IParticipantStatusManager participantStatusManager, IParticipantManager participantManager,
IEventWrapper eventWrapper)
{
_userManager = userManager;
_repoWrapper = repoWrapper;
_mapper = mapper;
_participantStatusManager = participantStatusManager;
_participantManager = participantManager;
_eventWrapper = eventWrapper;
}
private static Either <Error, PublishedPricing> TryMap(IEventWrapper <IInstrumentPricingPublished> wrapper)
{
var e = wrapper.Content;
var price = new Price(e.PriceCurrency, e.PriceAmount);
var asOfDate = Date.FromString(e.AsOfDate);
var priceTypeResult = e.PriceType.TryParseOptionalEnum <PriceType>();
return(priceTypeResult
.MapRight(priceType => new PublishedPricing(asOfDate, wrapper.Timestamp, e.InstrumentId, price, priceType)));
}
public Task Handle(IEventWrapper <IInstrumentCreated> @event, CancellationToken cancellationToken)
{
var dto = new InstrumentDto
{
Id = @event.AggregateId,
HasPriceType = @event.Content.HasPriceType,
Name = @event.Content.Description,
Vendor = @event.Content.Vendor
};
return(_readModelRepository.Insert(dto));
}
public Task Handle(IEventWrapper <IInstrumentCreated> @event, CancellationToken cancellationToken)
{
var instrument = new Instrument
{
Id = @event.AggregateId,
Vendor = @event.Content.Vendor,
Name = @event.Content.Description,
HasPriceType = @event.Content.HasPriceType
};
return(_instruments.Insert(instrument));
}
void OnEvent(object sender, PropertyChangedEventArgs e)
{
IEventWrapper obj = (IEventWrapper)eventDestination.Target;
if (obj != null)
{
obj.OnPropertyChanged(sender, e);
}
else
{
Deregister();
}
}
public async Task Handle(IEventWrapper <IInstrumentPricingPublished> @event, CancellationToken cancellationToken)
{
var asOfDate = @event.Content.AsOfDate;
var existing = await _repository.Single(x => x.AsOfDate == asOfDate);
if (existing == null)
{
var newDto = new Dto {
AsOfDate = asOfDate
};
await _repository.Insert(newDto);
}
}
private void Recover(IEventWrapper <IInstrumentPricingPublished> wrapper)
{
var e = wrapper.Content;
if (!_pricings.TryGetValue(e.AsOfDate, out var pricing))
{
_pricings.Add(e.AsOfDate, wrapper);
}
else if (pricing.Timestamp < wrapper.Timestamp)
{
_pricings[e.AsOfDate] = wrapper;
}
}
public void Recover(IEventWrapper <IInstrumentPricingPublished> wrapper)
{
var e = wrapper.Content;
if (!_pricings.TryGetValue(e.InstrumentId, out var pricing))
{
_pricings.Add(e.InstrumentId, wrapper);
}
else if (Date.FromString(pricing.Content.AsOfDate) < Date.FromString(e.AsOfDate) || (pricing.Content.AsOfDate == e.AsOfDate && pricing.Timestamp < wrapper.Timestamp))
{
_pricings[e.InstrumentId] = wrapper;
}
}
public Task Handle(IEventWrapper <IInstrumentCreated> wrapper, CancellationToken cancellationToken)
{
var @event = wrapper.Content;
_db.Add(new Instrument
{
Id = wrapper.AggregateId,
Description = @event.Description,
Vendor = @event.Vendor
});
return(Task.CompletedTask);
}
public Task Handle(IEventWrapper <IInstrumentCreated> wrapper, CancellationToken cancellationToken)
{
var @event = wrapper.Content;
var instrument = new InstrumentDto
{
Id = wrapper.AggregateId,
Name = @event.Description,
Vendor = @event.Vendor
};
return(_instrumentRepo.Insert(instrument));
}
public Task Handle(IEventWrapper <ICurveRecipeCreated> @event, CancellationToken cancellationToken)
{
return(_marketCurveRepository
.Get(@event.Content.MarketCurveId.NonEmpty())
.IfNotNull(curve =>
{
var dto = new Dto
{
Id = @event.AggregateId,
Name = GenerateName(@event.Content, curve)
};
return _readModelRepository.Insert(dto);
}));
}
private static Either <Error, CurveRecipe> TryMap(IEventWrapper <ICurveRecipeCreated> wrapper)
{
var e = wrapper.Content;
var lastLiquidTenorR = e.LastLiquidTenor.TryParseEnum <Tenor>();
var dccR = e.DayCountConvention.TryParseEnum <DayCountConvention>();
var interR = e.Interpolation.TryParseEnum <Interpolation>();
var exShortR = e.ExtrapolationShort.TryParseEnum <ExtrapolationShort>();
var exLongR = e.ExtrapolationLong.TryParseEnum <ExtrapolationLong>();
var outSeriesR = e.OutputSeries.TryParseEnum <OutputSeries>();
var outTypeR = e.OutputType.TryParseEnum <OutputType>();
return(lastLiquidTenorR.MapRight(dccR, interR, exShortR, exLongR, outSeriesR, outTypeR,
(lastLiquidTenor, dcc, inter, exShort, exLong, outSeries, outType)
=> new CurveRecipe(wrapper.AggregateId, lastLiquidTenor, dcc, inter, exShort, exLong, new OutputFrequency(outSeries, new Maturity(e.MaximumMaturity)), outType)));
}
public async Task Handle(IEventWrapper <ICurveCalculated> @event, CancellationToken cancellationToken)
{
var asOfDate = @event.Content.AsOfDate;
var existingDto = await _readModelRepository.Single(x => x.AsOfDate == asOfDate);
if (existingDto != null)
{
var dto = new Dto
{
Id = NonEmpty.Guid(),
AsOfDate = asOfDate
};
await _readModelRepository.Insert(dto);
}
}
public async Task Send(IEventWrapper eventParent, IReadOnlyCollection <IAction> actions)
{
var wrappedActions = actions
.Select(c => c.Wrap())
.ToArray();
if (eventParent.IsLinkToJob)
{
await _jobHandler.Associate(eventParent, wrappedActions);
}
await _commandStore.Save(wrappedActions);
foreach (var wrappedAction in wrappedActions)
{
await _commandQueue.Send(wrappedAction);
}
}
public async Task Handle(IEventWrapper <ICurvePointAdded> wrapper, CancellationToken cancellationToken)
{
var dto = await _usedValues.Get(wrapper.AggregateId);
if (dto == null)
{
dto = new UsedValues
{
Id = wrapper.AggregateId
};
await _usedValues.Insert(dto);
}
dto.Instruments.Add(wrapper.Content.InstrumentId);
dto.Tenors.Add(wrapper.Content.Tenor);
await _usedValues.Update(dto);
}
