public BasketRegionModel CreateBasketRegionModel(
ManagingBaskets.RegionBasket basket,
IEnumerable <CountryModel> countries,
Computations computations,
EditableExpression baseExpression,
EditableExpression portfolioAdjustmentExpression
)
{
var result = new BasketRegionModel(
basket,
new SumExpression(
ValueNames.Benchmark,
countries.Select(x => x.Benchmark),
this.defaultValues.DefaultBenchmark,
this.commonParts.ValidateWhatever
),
baseExpression,
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.BaseActive,
self,
computations.BaseActiveFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
new SumExpression(
ValueNames.Overlay,
countries.Select(x => x.Overlay),
this.defaultValues.DefaultOverlay,
this.commonParts.ValidateWhatever
),
portfolioAdjustmentExpression,
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.PortfolioScaled,
self,
computations.PortfolioScaledFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.TrueExposure,
self,
computations.TrueExposureFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
self => new ModelFormulaExpression <IModel, Decimal?>(
ValueNames.TrueActive,
self,
computations.TrueActiveFormula,
this.commonParts.NullableDecimalValueAdapter,
this.commonParts.ValidateWhatever
),
countries
);
return(result);
}
protected void InitializeBasketRegion(
BasketRegionModel model,
Dictionary <Int32, TargetingTypeBasketPortfolioTargetInfo> dictionary)
{
TargetingTypeBasketPortfolioTargetInfo info;
if (dictionary.TryGetValue(model.Basket.Id, out info))
{
model.PortfolioAdjustment.InitialValue = info.Target;
}
}
protected void TraverseBasketRegion(BasketRegionModel model, List <IExpression> result)
{
result.Add(model.Base);
result.Add(model.BaseActive);
result.Add(model.Benchmark);
result.Add(model.Overlay);
result.Add(model.PortfolioAdjustment);
result.Add(model.PortfolioScaled);
result.Add(model.TrueActive);
result.Add(model.TrueExposure);
}
protected IEnumerable <IModel> TraverseBasketRegion(BasketRegionModel basketRegionModel)
{
yield return(basketRegionModel);
var countryModels = basketRegionModel.Countries;
foreach (var countryModel in countryModels)
{
var models = this.TraverseCountry(countryModel);
foreach (var model in models)
{
yield return(model);
}
}
}
protected IEnumerable <IValidationIssue> ValidateBasketRegion(BasketRegionModel model, CalculationTicket ticket)
{
return(base.ValidateScope(model.Basket.Name, issues =>
{
var overlay = model.Overlay.Value(ticket);
var baseValue = model.Base.Value(ticket);
if (baseValue.HasValue)
{
if (baseValue.Value < overlay)
{
model.Base.InjectProblems(new IValidationIssue[] { new WariningIssue("Base is less than overlay.") });
}
}
issues.AddRange(model.Base.Validate());
issues.AddRange(model.PortfolioAdjustment.Validate());
}));
}
protected void SerializeBasketRegion(IJsonWriter writer, BasketRegionModel model, String discriminator, CalculationTicket ticket)
{
this.AddDiscriminatorIfAny(writer, discriminator);
writer.Write(model.Basket.Id, JsonNames.BasketId);
writer.Write(model.Basket.Name, JsonNames.Name);
this.expressionWriter.SerializeOnceResolved(model.Benchmark, JsonNames.Benchmark, writer, ticket);
this.expressionWriter.SerializeOnceResolved(model.Base, JsonNames.Base, writer, ticket);
this.expressionWriter.SerializeOnceResolved(model.BaseActive, JsonNames.BaseActive, writer, ticket);
this.expressionWriter.SerializeOnceResolved(model.Overlay, JsonNames.Overlay, writer, ticket);
this.expressionWriter.SerializeOnceResolved(model.PortfolioAdjustment, JsonNames.PortfolioAdjustment, writer, ticket);
this.expressionWriter.SerializeOnceResolved(model.PortfolioScaled, JsonNames.PortfolioScaled, writer, ticket);
this.expressionWriter.SerializeOnceResolved(model.TrueExposure, JsonNames.TrueExposure, writer, ticket);
this.expressionWriter.SerializeOnceResolved(model.TrueActive, JsonNames.TrueActive, writer, ticket);
writer.WriteArray(model.Countries, JsonNames.Countries, country =>
{
writer.Write(delegate
{
this.SerializeCountry(writer, country.Country);
this.expressionWriter.SerializeOnceResolved(country.Benchmark, JsonNames.Benchmark, writer, ticket);
this.expressionWriter.SerializeOnceResolved(country.Overlay, JsonNames.Overlay, writer, ticket);
});
});
}
public void Resolve(BasketRegionModel model)
{
this.Result = model.Overlay;
}
public void Resolve(BasketRegionModel model)
{
this.ResultOpt = model.Base;
}
public void Resolve(BasketRegionModel model)
{
}
public void Resolve(BasketRegionModel model)
{
this.traverser.TraverseBasketRegion(model, this.result);
}
public void Resolve(BasketRegionModel model)
{
this.Result = this.builder.CreateBasketRegion(model);
}
public void Resolve(BasketRegionModel model)
{
this.Result = model.Benchmark;
}
public void Resolve(BasketRegionModel model)
{
this.ResultOpt = model.TrueExposure;
}
public void Resolve(BasketRegionModel model)
{
this.ResultOpt = model.PortfolioAdjustment;
}
public void Resolve(BasketRegionModel model)
{
this.Result = this.validator.ValidateBasketRegion(model, this.ticket);
}
public void Resolve(BasketRegionModel basketRegion)
{
this.parent.SerializeBasketRegion(this.writer, basketRegion, JsonNames.BasketRegion, this.ticket);
}
public void Resolve(BasketRegionModel model)
{
this.parent.SerializeBasketRegion(writer, model, JsonNames.BasketRegion, this.ticket);
}
public void Resolve(BasketRegionModel model)
{
this.ResultOpt = model.PortfolioScaled;
}
public void Resolve(BasketRegionModel model)
{
// do nothing (it is based on CountryIso)
}
public void Resolve(BasketRegionModel model)
{
this.ResultOpt = model.TrueActive;
}
public void Resolve(BasketRegionModel model)
{
this.initializer.InitializeBasketRegion(model, this.valuesByBasketId);
}
public void Resolve(BasketRegionModel model)
{
// do nothing
}
public BasketRegionNode CreateBasketRegion(BasketRegionModel model)
{
var result = new BasketRegionNode(model.Basket);
return(result);
}
