private Core.SecurityModel DeserializeAdditionalSecurity(
IBasket basket,
Aims.Data.Server.SecurityModel securityModel,
TopDown.Core.ManagingTargetingTypes.TargetingTypeGroup targetingTypeGroup,
TopDown.Core.ManagingBenchmarks.BenchmarkRepository benchmarkRepository
)
{
var baseExpression = this.modelBuilder.CreateBaseExpression();
var benchmarkExpression = this.modelBuilder.CreateBenchmarkExpression();
var baseActiveExpression = this.modelBuilder.CreateBaseActiveExpression(baseExpression, benchmarkExpression);
var result = new Core.SecurityModel(
this.deserializer.DeserializeSecurity(securityModel),
baseExpression,
benchmarkExpression,
targetingTypeGroup.GetBgaPortfolios().Select(bgaPortfolio => new Core.PortfolioTargetModel(
bgaPortfolio,
this.modelBuilder.CreatePortfolioTargetExpression(bgaPortfolio.Name))
).ToList(),
baseActiveExpression
);
if (!String.IsNullOrWhiteSpace(targetingTypeGroup.BenchmarkIdOpt))
{
this.benchmarkInitializer.InitializeSecurity(basket, targetingTypeGroup.BenchmarkIdOpt, result, benchmarkRepository);
}
return(result);
}
public SecurityModel CreateSecurity(
TargetingTypeGroup targetingTypeGroup,
IBasket basket,
ISecurity security,
IEnumerable <BroadGlobalActivePortfolio> bgaPortfolios,
TargetingTypeGroupBasketSecurityBaseValueRepository ttgbsbvRepository,
BasketSecurityPortfolioTargetRepository bsptRepository,
PortfolioRepository portfolioRepository
)
{
var portfolioTargets = new List <PortfolioTargetModel>();
var targetsOfSecurity = bsptRepository.GetTargets(basket, security);
var targetsByPortfolio = targetsOfSecurity.ToDictionary(x => x.PortfolioId);
foreach (var bgaPortfolio in bgaPortfolios)
{
var portfolioTargetExpression = this.modelBuilder.CreatePortfolioTargetExpression(bgaPortfolio.Name);
var portfolioModel = new PortfolioTargetModel(bgaPortfolio, portfolioTargetExpression);
BasketPortfolioSecurityTargetInfo target;
if (targetsByPortfolio.TryGetValue(bgaPortfolio.Id, out target))
{
// there is a target for the given portfolio
portfolioModel.Target.InitialValue = target.Target;
}
portfolioTargets.Add(portfolioModel);
}
var baseExpression = this.modelBuilder.CreateBaseExpression();
var baseInfoOpt = ttgbsbvRepository.TryGetBaseValue(targetingTypeGroup, basket, security);
if (baseInfoOpt != null)
{
// there is a base value for this security already defined
baseExpression.InitialValue = baseInfoOpt.BaseValue;
}
else
{
// it will have a default base value which is null)
}
var benchmarkExpression = this.modelBuilder.CreateBenchmarkExpression();
var baseActiveExpression = this.modelBuilder.CreateBaseActiveExpression(baseExpression, benchmarkExpression);
var securityModel = new SecurityModel(
security,
baseExpression,
benchmarkExpression,
portfolioTargets,
baseActiveExpression
);
return(securityModel);
}
protected SecurityModel SerializeSecurity(Core.SecurityModel model, CalculationTicket ticket)
{
var result = new SecurityModel(
this.serializer.SerializeSecurityOnceResolved(model.Security),
this.serializer.SerializeEditableExpression(model.Base),
this.serializer.SerializeExpression(model.Benchmark, ticket),
this.SerializePortfolioTargets(model.PortfolioTargets, model.Base),
this.serializer.SerializeNullableExpression(model.BaseActive, ticket)
);
return(result);
}
public void SerializeItem(SecurityModel item, CalculationTicket ticket, IJsonWriter writer)
{
writer.Write("security", delegate
{
this.securitySerializer.SerializeSecurityOnceResolved(item.Security, writer);
});
this.expressionSerializer.SerializeEditable(item.Base, JsonNames.Base, writer);
this.expressionSerializer.Serialize(item.Benchmark, JsonNames.Benchmark, writer, ticket);
writer.WriteArray(item.PortfolioTargets, JsonNames.PortfolioTargets, portfolioTarget =>
{
writer.Write(delegate
{
this.SerializePortfolioTarget(item.Base, portfolioTarget, writer);
});
});
}
protected Core.SecurityModel DeserializeSecurity(SecurityModel model)
{
var baseExpression = this.modelBuilder.CreateBaseExpression();
this.deserializer.PopulateEditableExpression(baseExpression, model.Base);
var benchmarkExpression = this.modelBuilder.CreateBenchmarkExpression();
this.deserializer.PopulateUnchangableExpression(benchmarkExpression, model.Benchmark);
var portfolioTargets = this.DeserializePortfolioTargets(model.PortfolioTargets);
var baseActiveExpression = this.modelBuilder.CreateBaseActiveExpression(baseExpression, benchmarkExpression);
var result = new Core.SecurityModel(
this.deserializer.DeserializeSecurity(model.Security),
baseExpression,
benchmarkExpression,
portfolioTargets,
baseActiveExpression
);
return(result);
}
public SecurityModel DeserializeSecurity(
JsonReader reader,
SecurityRepository securityRepository,
PortfolioRepository portfolioRepository
)
{
var securityId = reader.ReadAsString(JsonNames.SecurityId);
var security = securityRepository.GetSecurity(securityId);
var baseExpression = this.modelBuilder.CreateBaseExpression();
reader.Read(JsonNames.Base, delegate
{
this.expressionDeserializer.PopulateEditableExpression(reader, baseExpression);
});
var benchmarkExpression = this.modelBuilder.CreateBenchmarkExpression();
reader.Read(JsonNames.Benchmark, delegate
{
this.expressionDeserializer.PopulateUnchangeableExpression(reader, benchmarkExpression);
});
var portfolioTargets = reader.ReadArray(JsonNames.PortfolioTargets, delegate
{
return(this.DeserializePortfolioTarget(reader, portfolioRepository));
});
var baseActiveExpression = this.modelBuilder.CreateBaseActiveExpression(baseExpression, benchmarkExpression);
var result = new SecurityModel(
security,
baseExpression,
benchmarkExpression,
portfolioTargets,
baseActiveExpression
);
return(result);
}
public void InitializeSecurity(
IBasket basket,
String benchmarkId,
SecurityModel security,
ManagingBenchmarks.BenchmarkRepository benchmarkRepository
)
{
var totalOpt = this.TryGetTotalByBasketOnceResolved(basket, benchmarkId, benchmarkRepository);
var benchmarks = benchmarkRepository.TryGetBySecurity(security.Security);
var benchmarkInfoOpt = benchmarks.FirstOrDefault(x => x.BenchmarkId == benchmarkId);
if (benchmarkInfoOpt != null && benchmarkInfoOpt.BenchmarkWeight.HasValue && benchmarkInfoOpt.BenchmarkId == benchmarkId)
{
if (totalOpt.HasValue)
{
security.Benchmark.InitialValue = benchmarkInfoOpt.BenchmarkWeight.Value / totalOpt.Value;
}
else
{
#warning When you have time think about this:
security.Benchmark.InitialValue = 0.0m;
}
}
}
protected void Validate(SecurityModel security, List <IValidationIssue> issues)
{
issues.AddRange(security.Base.Validate());
security.PortfolioTargets.ForEach(portfolioTarget => this.Validate(portfolioTarget, issues));
}
public RootModel DeserializeRoot(
JsonReader reader,
SecurityRepository securityRepository,
ManagingTargetingTypes.TargetingTypeGroupRepository targetingTypeGroupRepository,
ManagingBaskets.BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
RepositoryManager repositoryManager,
IOnDemand <IDataManager> ondemandManager
)
{
var latestBaseChangeset = reader.Read(JsonNames.LatestBaseChangeset, delegate
{
return(this.DeserializeLatestBaseChangeset(reader));
});
var latestPortfolioTargetChangeset = reader.Read(JsonNames.LatestPortfolioTargetChangeset, delegate
{
return(this.DeserializeLatestPortfolioTargetChangeset(reader));
});
var targetingTypeGroupId = reader.ReadAsInt32(JsonNames.TargetingTypeGroupId);
var targetingTypeGroup = targetingTypeGroupRepository.GetTargetingTypeGroup(targetingTypeGroupId);
var basketId = reader.ReadAsInt32(JsonNames.BasketId);
var basket = basketRepository.GetBasket(basketId);
var benchmarkDate = reader.ReadAsDatetime(JsonNames.BenchmarkDate);
var securityModels = reader.ReadArray("securities", delegate
{
var securityModel = this.DeserializeSecurity(
reader,
securityRepository,
portfolioRepository
);
return(securityModel);
}).ToList();
// adding a new security if any
var securityIdTobeAddedOpt = reader.ReadAsNullableString(JsonNames.SecurityIdTobeAdded);
if (securityIdTobeAddedOpt != null)
{
var broadGlobalActivePortfolios = targetingTypeGroup.GetBgaPortfolios();
var security = securityRepository.GetSecurity(securityIdTobeAddedOpt);
var baseExpression = this.modelBuilder.CreateBaseExpression();
var benchmarkExpression = this.modelBuilder.CreateBenchmarkExpression();
var baseActiveExpression = this.modelBuilder.CreateBaseActiveExpression(baseExpression, benchmarkExpression);
var securityModel = new SecurityModel(
security,
baseExpression,
benchmarkExpression,
broadGlobalActivePortfolios.Select(bgaPortfolio => new PortfolioTargetModel(
bgaPortfolio,
this.modelBuilder.CreatePortfolioTargetExpression(bgaPortfolio.Name)
)).ToArray(),
baseActiveExpression
);
if (!String.IsNullOrWhiteSpace(targetingTypeGroup.BenchmarkIdOpt))
{
var benchmarkRepository = this.repositoryManager.ClaimBenchmarkRepository(ondemandManager, benchmarkDate);
this.benchmarkInitializer.InitializeSecurity(basket, targetingTypeGroup.BenchmarkIdOpt, securityModel, benchmarkRepository);
}
securityModels.Add(securityModel);
}
var portfolios = reader.ReadArray(JsonNames.Portfolios, delegate
{
var portfolioId = reader.ReadAsString(JsonNames.Id);
var portfolio = portfolioRepository.GetBroadGlobalActivePortfolio(portfolioId);
var portfolioTargetTotalExpression = this.modelBuilder.CreatePortfolioTargetTotalExpression(
portfolio,
securityModels
);
return(new PortfolioModel(
portfolio,
portfolioTargetTotalExpression
));
});
var baseTotalExpression = this.modelBuilder.CreateBaseTotalExpression(securityModels);
var benchmarkTotalExpression = this.modelBuilder.CreateBenchmarkTotalExpression(securityModels);
var baseActiveTotalExpression = this.modelBuilder.CreateBaseActiveTotalExpression(securityModels);
//var targetingTypeGroup = targetingTypeGroupRepository.Get
var core = new CoreModel(
targetingTypeGroup,
basket,
portfolios,
securityModels,
baseTotalExpression,
benchmarkTotalExpression,
baseActiveTotalExpression
);
var result = new RootModel(
latestBaseChangeset,
latestPortfolioTargetChangeset,
core,
benchmarkDate
);
return(result);
}
