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); }