public IEnumerable <IValidationIssue> ValidateOnceResolved(IModel model, CalculationTicket ticket)
{
var resolver = new ValidateOnceResolved_IModelResolver(this, ticket);
model.Accept(resolver);
return(resolver.Result);
}
public IEnumerable <IValidationIssue> ValidateRoot(RootModel root, CalculationTicket ticket)
{
var result = new List <IValidationIssue>();
this.ValidateRoot(root, ticket, result);
return(result);
}
protected void RecalculateBasketCountry(
BasketCountryModel model,
TargetingType targetingType,
BroadGlobalActivePortfolio portfolio,
ICollection <BgaPortfolioSecurityTargetInfo> result,
IDataManager manager,
CalculationTicket ticket
)
{
var baseValue = model.Base.Value(ticket);
if (!baseValue.HasValue)
{
throw new ValidationException(new ErrorIssue("There is no base value defined for the \"" + model.Basket.Country.Name + "\" country (ISO: " + model.Basket.Country.IsoCode + ")."));
}
var portfolioScaledValue = model.PortfolioScaled.Value(ticket);
if (!portfolioScaledValue.HasValue)
{
throw new ValidationException(new ErrorIssue("There is no portfolio scaled value defined for the \"" + model.Basket.Country.Name + "\" country (ISO: " + model.Basket.Country.IsoCode + ")."));
}
this.RecalculateSecurityTargets(
portfolioScaledValue.Value,
model.Basket,
targetingType,
portfolio,
result,
manager,
ticket
);
}
public Decimal?Value(CalculationTicket ticket, ICalculationTracer tracer, String name)
{
var value = this.EditedValue;
tracer.WriteValue(name ?? this.Name, value);
return(value);
}
public IEnumerable <IValidationIssue> ApplyIfValid(
RootModel root,
String username,
String userEmail,
SqlConnection connection,
TargetingTypeRepository targetingTypeRepository,
SecurityRepository securityRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
CalculationTicket ticket,
ref CalculationInfo info
)
{
var targetingType = targetingTypeRepository.GetTargetingType(root.TargetingType.Id);
var issues = this.modelApplier.ApplyIfValid(
root,
targetingType.Taxonomy,
this.repositoryManager,
username,
userEmail,
connection,
securityRepository,
basketRepository,
portfolioRepository,
ticket,
ref info
);
return(issues);
}
public void SerializeRoot(RootModel root, CalculationTicket ticket, IJsonWriter writer)
{
writer.Write(JsonNames.LatestBaseChangeset, delegate
{
this.SerializeLatestBaseChangeset(root.LatestBaseChangeset, writer);
});
writer.Write(JsonNames.LatestPortfolioTargetChangeset, delegate
{
this.SerializeLatestPortfolioTargetChangeset(root.LatestPortfolioTargetChangeset, writer);
});
writer.Write(root.Core.TargetingTypeGroup.Id, JsonNames.TargetingTypeGroupId);
writer.Write(root.Core.Basket.Id, JsonNames.BasketId);
writer.Write(root.BenchmarkDate, JsonNames.BenchmarkDate);
writer.WriteArray(root.Core.Securities, JsonNames.Securities, security =>
{
writer.Write(delegate
{
this.SerializeItem(security, ticket, writer);
});
});
writer.WriteArray(root.Core.Portfolios, JsonNames.Portfolios, portfolio =>
{
writer.Write(delegate
{
this.SerializePortfolio(portfolio, writer, ticket);
});
});
this.expressionSerializer.SerializeOnceResolved(root.Core.BaseTotal, JsonNames.BaseTotal, writer, ticket);
}
public IEnumerable <IValidationIssue> ApplyIfValid(
RootModel model,
Taxonomy taxonomy,
RepositoryManager repositoryManager,
String username,
String userEmail,
SqlConnection connection,
SecurityRepository securityRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
CalculationTicket ticket,
ref CalculationInfo info
)
{
var issues = this.ValidateModelAndPermissions(model, username, ticket);
var traverser = new IssueTraverser();
var traversedIssues = traverser.TraverseAll(issues);
if (traversedIssues.Any(x => x is ErrorIssue))
{
return(issues);
}
try
{
this.Apply(model, taxonomy, repositoryManager, username, userEmail, connection,
securityRepository, basketRepository, portfolioRepository, ref info);
return(issues);
}
catch (ValidationException exception)
{
return(issues.Union(new IValidationIssue[] { exception.Issue }));
}
}
public Decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Add formula");
tracer.Indent();
var one = this.oneExpression.Value(ticket, tracer, No.ExpressionName);
var another = this.anotherExpression.Value(ticket, tracer, No.ExpressionName);
Decimal?result;
if (one.HasValue)
{
if (another.HasValue)
{
result = one.Value + another.Value;
}
else
{
result = one.Value;
}
}
else
{
if (another.HasValue)
{
result = another.Value;
}
else
{
result = null;
}
}
tracer.WriteValue("Sum", result);
tracer.Unindent();
return(result);
}
public Decimal?Calculate(IModel model, CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Base active formula");
tracer.Indent();
var baseExpressionOpt = picker.Base.TryPickExpression(model);
var benchmarkExpressionOpt = picker.Benchmark.TryPickExpression(model);
if (baseExpressionOpt == null || benchmarkExpressionOpt == null)
{
return(null);
}
var baseValue = baseExpressionOpt.Value(ticket, tracer, "Base");
var benchmarkValue = benchmarkExpressionOpt.Value(ticket, tracer, "Benchmark");
Decimal?result;
if (!baseValue.HasValue)
{
result = null;
}
else
{
result = baseValue.Value - benchmarkValue;
}
tracer.WriteValue("Base - Benchmark", result);
tracer.Unindent();
return(result);
}
public WriteOnceResolved_IExpressionResolver(ExpressionToJsonSerializer parent, String name, CalculationTicket ticket, IJsonWriter writer)
{
this.parent = parent;
this.name = name;
this.ticket = ticket;
this.writer = writer;
}
public String GetBreakdown(Int32 targetingId, String portfolioId, CalculationTicket ticket, String username)
{
var breakdown = this.facade.GetBptModel(targetingId, portfolioId, username);
var result = this.facade.BptManager.SerializeToJson(breakdown, ticket);
return(result);
}
public String RecalculateBreakdown(String bptAsJson, CalculationTicket ticket)
{
BasketRepository basketRepository;
SecurityRepository securityRepository;
PortfolioRepository portfolioRepository;
TargetingTypeRepository targetingTypeRepository;
using (var ondemandManager = this.facade.CreateOnDemandDataManager())
{
basketRepository = this.facade.RepositoryManager.ClaimBasketRepository(ondemandManager);
securityRepository = this.facade.RepositoryManager.ClaimSecurityRepository(ondemandManager);
portfolioRepository = this.facade.RepositoryManager.ClaimPortfolioRepository(ondemandManager);
targetingTypeRepository = this.facade.RepositoryManager.ClaimTargetingTypeRepository(ondemandManager);
}
var root = this.facade.BptManager.DeserializeFromJson(
bptAsJson,
basketRepository,
securityRepository,
portfolioRepository,
targetingTypeRepository
);
this.facade.RecalculateBptModel(root, ticket);
var result = this.facade.BptManager.SerializeToJson(root, ticket);
return(result);
}
public String RecalculateBpstModel(String bpstModelAsJson, CalculationTicket ticket)
{
SecurityRepository securityRepository;
TargetingTypeGroupRepository targetingTypeGroupRepository;
BasketRepository basketRepository;
PortfolioRepository portfolioRepository;
ManagingBpst.RootModel model;
using (var ondemandManager = this.facade.CreateOnDemandDataManager())
{
securityRepository = this.facade.RepositoryManager.ClaimSecurityRepository(ondemandManager);
targetingTypeGroupRepository = this.facade.RepositoryManager.ClaimTargetingTypeGroupRepository(ondemandManager);
basketRepository = this.facade.RepositoryManager.ClaimBasketRepository(ondemandManager);
portfolioRepository = this.facade.RepositoryManager.ClaimPortfolioRepository(ondemandManager);
model = this.facade.BpstManager.DeserializeFromJson(
bpstModelAsJson,
securityRepository,
targetingTypeGroupRepository,
basketRepository,
portfolioRepository,
ondemandManager
);
}
var json = this.facade.BpstManager.SerializeToJson(model, ticket);
return(json);
}
public String TryApplyBpstModel(String bpstAsJson, String username, CalculationTicket ticket)
{
SecurityRepository securityRepository;
TargetingTypeGroupRepository targetingTypeGroupRepository;
BasketRepository basketRepository;
PortfolioRepository portfolioRepository;
ManagingBpst.RootModel model;
using (var ondemandManager = this.facade.CreateOnDemandDataManager())
{
securityRepository = this.facade.RepositoryManager.ClaimSecurityRepository(ondemandManager);
targetingTypeGroupRepository = this.facade.RepositoryManager.ClaimTargetingTypeGroupRepository(ondemandManager);
basketRepository = this.facade.RepositoryManager.ClaimBasketRepository(ondemandManager);
portfolioRepository = this.facade.RepositoryManager.ClaimPortfolioRepository(ondemandManager);
model = this.facade.BpstManager.DeserializeFromJson(
bpstAsJson,
securityRepository,
targetingTypeGroupRepository,
basketRepository,
portfolioRepository,
ondemandManager
);
}
var issues = this.facade.ApplyBpstModelIfValid(model, username, ticket);
var issuesAsJson = this.validationManager.SerializeToJson(issues);
return(issuesAsJson);
}
public String TryApplyBptModel(String bptAsJson, String username, CalculationTicket ticket)
{
BasketRepository basketRepository;
SecurityRepository securityRepository;
PortfolioRepository portfolioRepository;
TargetingTypeRepository targetingTypeRepository;
using (var ondemandManager = this.facade.CreateOnDemandDataManager())
{
basketRepository = this.facade.RepositoryManager.ClaimBasketRepository(ondemandManager);
securityRepository = this.facade.RepositoryManager.ClaimSecurityRepository(ondemandManager);
portfolioRepository = this.facade.RepositoryManager.ClaimPortfolioRepository(ondemandManager);
targetingTypeRepository = this.facade.RepositoryManager.ClaimTargetingTypeRepository(ondemandManager);
}
var model = this.facade.BptManager.DeserializeFromJson(
bptAsJson,
basketRepository,
securityRepository,
portfolioRepository,
targetingTypeRepository
);
var issues = this.facade.ApplyBroadGlobalActiveModelIfValid(model, username, ticket);
var issuesAsJson = this.validationManager.SerializeToJson(issues);
return(issuesAsJson);
}
public String GetPstComposition(String portfolioId, CalculationTicket ticket)
{
var composition = this.facade.GetPstModel(portfolioId);
var result = this.facade.PstManager.SerializeToJson(composition, ticket);
return(result);
}
public Decimal?Calculate(IModel model, CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Base less overlay formula");
tracer.Indent();
var rescaledBaseValue = this.rescaledBaseForAdjustmentFormula.Calculate(model, ticket, tracer);
tracer.WriteValue("Rescaled base", rescaledBaseValue);
Decimal?result;
if (rescaledBaseValue.HasValue)
{
var overlayExpressionOpt = picker.Overlay.TryPickExpression(model);
if (overlayExpressionOpt == null)
{
throw new ApplicationException("There is no overlay expression.");
}
var overlayValue = overlayExpressionOpt.Value(ticket, tracer, "Overlay");
result = rescaledBaseValue.Value - overlayValue;
}
else
{
result = null;
}
tracer.WriteValue("Result", result);
tracer.Unindent();
return(result);
}
public Decimal?Value(CalculationTicket ticket, ICalculationTracer tracer, String name)
{
tracer.WriteLine("Nullable sum: " + (name ?? this.Name));
tracer.Indent();
var result = this.defaultValue;
foreach (var expressionOpt in this.expressions)
{
if (expressionOpt == null)
{
continue;
}
var value = expressionOpt.Value(ticket);
tracer.WriteValue("+", value);
if (value.HasValue)
{
if (result.HasValue)
{
result = result.Value + value.Value;
}
else
{
result = value.Value;
}
}
}
tracer.WriteValue("Total", result);
tracer.Unindent();
return(result);
}
public TValue Value(CalculationTicket ticket, ICalculationTracer tracer, String name)
{
var result = this.InitialValue;
tracer.WriteValue(name ?? this.Name, result, this.Adapter);
return(result);
}
public decimal?Calculate(CalculationTicket ticket, ICalculationTracer tracer)
{
tracer.WriteLine("Base less overlay positive total formula");
tracer.Indent();
Decimal?result = this.cashRescaledBase.Value(ticket, tracer, "Cash rescaled base");
tracer.WriteValue(" + Cash rescaled base", result);
foreach (var model in models)
{
var value = this.baseLessOverlayFormula.Calculate(model, ticket, tracer);
if (value.HasValue && value.Value > 0)
{
tracer.WriteValue("+ Base less overlay", value);
if (result.HasValue)
{
result = result.Value + value.Value;
}
else
{
result = value.Value;
}
}
}
tracer.WriteValue("Total", result);
tracer.Unindent();
return(result);
}
public BottomUp.RootModel GetBottomUpModel(String bottomUpPortfolioId)
{
var model = this.facade.GetPstModel(bottomUpPortfolioId);
var ticket = new CalculationTicket();
var serializeModel = this.buSerializer.SerializeRoot(model, ticket);
return(serializeModel);
}
public BottomUp.RootModel RecalculateBottomUp(BottomUp.RootModel model)
{
var deserializedModel = this.buDeserializer.DeserializerRoot(model);
var ticket = new CalculationTicket();
var serializedModel = this.buSerializer.SerializeRoot(deserializedModel, ticket);
return(serializedModel);
}
public BasketTargets.RootModel RecalculateBasketTargets(BasketTargets.RootModel model)
{
var deserializedModel = this.btDeserializer.DeserializeRoot(model);
var ticket = new CalculationTicket();
var serializedModel = this.btSerializer.SerializeRoot(deserializedModel, ticket);
return(serializedModel);
}
public BasketTargets.RootModel GetBasketTargets(Int32 targetingTypeGroupId, Int32 basketId)
{
var ticket = new CalculationTicket();
var model = this.facade.GetBpstModel(targetingTypeGroupId, basketId);
var serializedModel = this.btSerializer.SerializeRoot(model, ticket);
return(serializedModel);
}
public ExpressionModel SerializeExpression(IExpression <Decimal> expression, CalculationTicket ticket)
{
var value = expression.Value(ticket);
var issues = this.SerializeValidationIssues(expression.Validate(ticket));
var result = new ExpressionModel(value, issues);
return(result);
}
public BroadGlobalActive.RootModel GetBroadGlobalActive(Int32 targetingTypeId, String bgaPortfolioId, String username)
{
this.MakeSureRepositoriesAreDroppedIfNeeded();
var ticket = new CalculationTicket();
var model = this.facade.GetBptModel(targetingTypeId, bgaPortfolioId, username);
var result = this.bgaSerializer.SerializeRoot(model, ticket);
return(result);
}
public IEnumerable <IssueModel> SaveBroadGlobalActive(BroadGlobalActive.RootModel serializedModel, string username)
{
var ticket = new CalculationTicket();
var model = this.bgaDeserializer.DeserializeRoot(serializedModel);
var issues = this.facade.ApplyBroadGlobalActiveModelIfValid(model, username, ticket);
var serializedIssues = this.serializer.SerializeValidationIssues(issues);
return(serializedIssues);
}
public IEnumerable <IssueModel> SaveBottomUp(BottomUp.RootModel model, string username)
{
var deserializedModel = this.buDeserializer.DeserializerRoot(model);
var ticket = new CalculationTicket();
var issues = this.facade.ApplyPstModelIfValid(deserializedModel, username, ticket);
var serializedIssues = this.serializer.SerializeValidationIssues(issues);
return(serializedIssues);
}
public void RecalculateBptModel(ManagingBpt.RootModel root, CalculationTicket ticket)
{
this.BptManager.RecalculateRootModel(
root,
this.connectionFactory,
this.dataManagerFactory,
ticket
);
}
public IEnumerable <IValidationIssue> ValidateCore(CoreModel model, CalculationTicket ticket)
{
var issues = new List <IValidationIssue>();
issues.AddRange(model.BaseTotal.Validate(ticket));
model.Portfolios.ForEach(x => this.Validate(x, ticket, issues));
model.Securities.ForEach(x => this.Validate(x, issues));
return(issues);
}
