public TargetingTypeGroupBasketSecurityBaseValueRepository CreateRepository(TargetingTypeGroup targetingTypeGroup, IBasket basket, IDataManager manager)
{
var baseValues = manager.GetTargetingTypeGroupBasketSecurityBaseValues(targetingTypeGroup.Id, basket.Id);
var result = new TargetingTypeGroupBasketSecurityBaseValueRepository(baseValues);
return(result);
}
public TInfo TryGetBaseValue(TargetingTypeGroup targetingTypeGroup, IBasket basket, ISecurity security)
{
var foundOpt = this
.GetBaseValues(targetingTypeGroup, basket)
.Where(x => x.SecurityId == security.Id)
.FirstOrDefault();
return(foundOpt);
}
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);
}
public CoreModel GetCoreModel(
TargetingTypeGroup targetingTypeGroup,
IBasket basket,
SecurityRepository securityRepository,
TargetingTypeGroupBasketSecurityBaseValueRepository ttgbsbvRepository,
BasketSecurityPortfolioTargetRepository bpstRepository,
PortfolioRepository portfolioRepository
)
{
var bgaPortfolios = targetingTypeGroup.GetBgaPortfolios();
// both base values and target values can contribute to the list of securities
var securityIds = ttgbsbvRepository
.GetBaseValues(targetingTypeGroup, basket).Select(x => x.SecurityId)
.Union(bpstRepository.GetTargets(basket).Select(x => x.SecurityId));
var securityModels = new List <SecurityModel>();
foreach (var securityId in securityIds)
{
var security = securityRepository.GetSecurity(securityId);
var securityModel = this.CreateSecurity(
targetingTypeGroup,
basket,
security,
bgaPortfolios,
ttgbsbvRepository,
bpstRepository,
portfolioRepository
);
securityModels.Add(securityModel);
}
var portfolios = bgaPortfolios.Select(portfolio => {
return(new PortfolioModel(
portfolio,
this.modelBuilder.CreatePortfolioTargetTotalExpression(portfolio, securityModels)
));
}
).ToArray();
var baseTotalExpression = this.modelBuilder.CreateBaseTotalExpression(securityModels);
var benchmarkTotalExpression = this.modelBuilder.CreateBenchmarkTotalExpression(securityModels);
var baseActiveTotalExpression = this.modelBuilder.CreateBaseActiveTotalExpression(securityModels);
var core = new CoreModel(
targetingTypeGroup,
basket,
portfolios,
securityModels,
baseTotalExpression,
benchmarkTotalExpression,
baseActiveTotalExpression
);
return(core);
}
public TargetingTypeGroupModel SerializeTargetingTypeGroup(TargetingTypeGroup model)
{
var result = new TargetingTypeGroupModel(
model.Id,
model.Name,
model.BenchmarkIdOpt,
this.SerializeTargetingTypes(model.GetTargetingTypes())
);
return(result);
}
public TargetingGroupModel TransformToGroup(TargetingTypeGroup groupModel, IEnumerable <UsernameBasketInfo> baskets)
{
var result = new TargetingGroupModel(
groupModel.Id,
groupModel.Name,
groupModel.GetTargetingTypes()
.SelectMany(x => this.basketExtractor.ExtractBaskets(x))
.GroupBy(x => x.Id) // getting rid of the same baskets
.Select(x => new BasketModel(x.Key, this.basketRenderer.RenderBasketOnceResolved(x.First()))),
baskets);
return(result);
}
public ManagingBpst.TargetingTypeGroupBasketSecurityBaseValueRepository CreateTargetingTypeGroupBasketSecurityBaseValueRepository(
TargetingTypeGroup targetingTypeGroup,
IBasket basket,
IDataManager manager
)
{
var result = this.ttgbsbvrManager.CreateRepository(
targetingTypeGroup,
basket,
manager
);
return(result);
}
public IEnumerable <TInfo> GetBaseValues(TargetingTypeGroup targetingTypeGroup, IBasket basket)
{
Dictionary <Int32, IEnumerable <TInfo> > found;
if (!this.byTargetingTypeGroupByBasket.TryGetValue(targetingTypeGroup.Id, out found))
{
return(nothing);
}
IEnumerable <TInfo> result;
if (!found.TryGetValue(basket.Id, out result))
{
return(nothing);
}
return(result);
}
public CoreModel(
TargetingTypeGroup targetingTypeGroup,
IBasket basket,
IEnumerable <PortfolioModel> portfolios,
IEnumerable <SecurityModel> securities,
IExpression <Decimal?> baseTotalExpression,
IExpression <Decimal> benchmarkTotalExpression,
IExpression <Decimal?> baseActiveTotalExpression
)
{
this.TargetingTypeGroup = targetingTypeGroup;
this.Basket = basket;
this.Portfolios = portfolios.ToList();
this.Securities = securities.ToList();
this.BaseTotal = baseTotalExpression;
this.BenchmarkTotal = benchmarkTotalExpression;
this.BaseActiveTotal = baseActiveTotalExpression;
}
public IEnumerable <IBasket> ExtractBaskets(TargetingTypeGroup targetingTypeGroup)
{
return(targetingTypeGroup.GetTargetingTypes().SelectMany(x => this.ExtractBaskets(x)).Distinct());
}
