public void Initialize(
RootModel root,
SecurityRepository securityRepository,
PortfolioRepository portfolioRepository,
ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository
)
{
var allFlatTargets = new List <BuPortfolioSecurityTargetInfo>();
foreach (var overlayItem in root.Factors.Items)
{
var factor = overlayItem.OverlayFactor.EditedValue;
if (!factor.HasValue)
{
continue;
}
var flatTargets = this.targetsFlattener.Flatten(
overlayItem.BottomUpPortfolio.Id,
factor.Value,
portfolioSecurityTargetRepository,
portfolioRepository
).ToArray();
allFlatTargets.AddRange(flatTargets);
var s = allFlatTargets.Sum(a => a.Target);
}
var resolver = new IsoCodeToOverlayTargetValueResolver(securityRepository, allFlatTargets);
this.Initialize(root, resolver);
}
public IEnumerable <String> ExtractCodes(
SecurityRepository securityRepository,
String portfolioId,
ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository,
ISecurityIdToPortfolioIdResolver securityToPortfolioResolver
)
{
var traverser = new TargetsTraverser <Object>(
(whatever, target) => target, // we don't change targets
(whaterer, target) => whaterer // we don't change the state
);
var flatTargets = traverser.Traverse(
portfolioId,
portfolioSecurityTargetRepository,
new Object(),
new HashSet <String>(),
securityToPortfolioResolver
);
var results = flatTargets.GroupBy(x => securityRepository
.GetSecurity(x.SecurityId)
.AsCompanySecurity() // <---- at this level (very bottom) all securities have to be company securities (there must be no funds at this level)
.Country.IsoCode
).Select(x => x.Key).ToArray();
return(results);
}
protected void InitializeOverlay(
RootModel root,
SecurityRepository securityRepository,
PortfolioRepository portfolioRepository,
ManagingPst.PortfolioSecurityTargetRepository bottomUpPortfolioSecurityTargetRepository
)
{
this.overlayInitializer.Initialize(
root,
securityRepository,
portfolioRepository,
bottomUpPortfolioSecurityTargetRepository
);
}
public IEnumerable <BuPortfolioSecurityTargetInfo> Flatten(
String portfolioId,
Decimal target,
ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository,
ISecurityIdToPortfolioIdResolver portfolioRepository
)
{
return(this.traverser.Traverse(
portfolioId,
portfolioSecurityTargetRepository,
new State {
ScaleFactor = target
},
new HashSet <String>(),
portfolioRepository
));
}
public IEnumerable <BuPortfolioSecurityTargetInfo> Traverse(
String portfolioId,
ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository,
TState state,
HashSet <String> processedPortfolioIds,
ISecurityIdToPortfolioIdResolver portfolioRepository
)
{
// in order not to process the same portfolio infinitely many times we have to save it
processedPortfolioIds.Add(portfolioId);
// get only targets related to the portfolo in question
var targets = portfolioSecurityTargetRepository.GetTargets(portfolioId, true);
foreach (var target in targets)
{
var nestedPortfolioIdOpt = portfolioRepository.TryResolveToPortfolioId(target.SecurityId);
if (nestedPortfolioIdOpt == null)
{
var convertedTarget = this.targetFlattener(state, target);
yield return(convertedTarget);
}
else if (processedPortfolioIds.Contains(nestedPortfolioIdOpt))
{
throw new ApplicationException("Cannot unwrap portfolio/security composition for the overlay column due to getting into a infinite loop: portfolio \"" + nestedPortfolioIdOpt + "\" has already been processed.");
}
else
{
var nestedTargets = this.Traverse(
nestedPortfolioIdOpt,
portfolioSecurityTargetRepository,
stateDriller(state, target),
processedPortfolioIds,
portfolioRepository
);
foreach (var nestedTarget in nestedTargets)
{
yield return(nestedTarget);
}
}
}
}
public IEnumerable <String> ExtractCodes(
IEnumerable <String> portfolioIdList,
ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository,
ISecurityIdToPortfolioIdResolver securityToPortfolioResolver,
SecurityRepository securityRepository)
{
var allIsoCodes = new List <String>();
foreach (var portfolioId in portfolioIdList)
{
var isoCodes = this.extractor.ExtractCodes(
securityRepository,
portfolioId,
portfolioSecurityTargetRepository,
securityToPortfolioResolver
);
allIsoCodes.AddRange(isoCodes);
}
var result = allIsoCodes.Distinct().ToArray();
return(result);
}
protected void RegisterMissingCountriesIfAny(ManagingBpt.RootModel result, Computations computations, CountryRepository countryRepository, TargetingType targetingType, SecurityRepository securityRepository, PortfolioRepository portfolioRepository, ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository, IEnumerable <BenchmarkSumByIsoInfo> benchmarks)
{
// figuring out missing ISO country codes (if any) from benchmarks and overlays
var missingCountriesIsoCodes = this.countriesDetector.FindMissingCountries(
targetingType.Taxonomy,
benchmarks,
result.Factors.Items.Where(x => x.OverlayFactor.EditedValue.HasValue).Select(x => x.BottomUpPortfolio.Name),
portfolioSecurityTargetRepository,
portfolioRepository,
securityRepository
);
if (missingCountriesIsoCodes.Any())
{
List <string> clearedMissingCountriesIsoCode;
var traverser = new GlobeTraverser();
var otherModel = traverser.TraverseGlobe(result.Globe).Where(m => m.TryAsOther() != null).FirstOrDefault();
if (otherModel != null)
{
clearedMissingCountriesIsoCode = new List <string>();
var codesInModel = otherModel.TryAsOther().UnsavedBasketCountries.Select(b => b.Country.IsoCode).Union(otherModel.TryAsOther().BasketCountries.Select(b => b.Basket.Country.IsoCode));
clearedMissingCountriesIsoCode.AddRange(codesInModel.Except(missingCountriesIsoCodes));
}
else
{
clearedMissingCountriesIsoCode = new List <string>(missingCountriesIsoCodes);
}
if (clearedMissingCountriesIsoCode.Any())
{
// there are some missing ISO country codes
// we need to resolve them to countries
// and put these countries to the taxonomy
var missingCountries = clearedMissingCountriesIsoCode.Select(x => countryRepository.GetCountry(x));
this.RegisterMissingCountries(result, missingCountries, computations);
}
}
}
