public TargetingTypeGroupRepository ClaimTargetingTypeGroupRepository(IOnDemand <IDataManager> ondemandManager, Func <TargetingTypeRepository> ondemandTargetingTypeRepository)
{
return(this.targetingTypeGroupRepositoryStorage.Claim(TargetingTypeGroupRepositoryStorageKey, delegate
{
return this.CreateTargetingTypeGroupRepository(ondemandManager.Claim(), ondemandTargetingTypeRepository());
}));
}
public RootModel DeserializeFromJson(
String bpstModelAsJson,
SecurityRepository securityRepository,
TargetingTypeGroupRepository targetingTypeGroupRepository,
BasketRepository basketRepository,
PortfolioRepository portfolioRepository,
IOnDemand <IDataManager> ondemandManager
)
{
using (var reader = new JsonReader(new Newtonsoft.Json.JsonTextReader(new StringReader(bpstModelAsJson))))
{
var result = reader.Read(delegate
{
return(this.modelDeserializer.DeserializeRoot(
reader,
securityRepository,
targetingTypeGroupRepository,
basketRepository,
portfolioRepository,
this.repositoryManager,
ondemandManager
));
});
return(result);
}
}
public CountryRepository ClaimCountryRepository(IOnDemand <IDataManager> ondemandManager)
{
return(this.countryRepositoryStorage.Claim(CountryRepositoryStorageKey, delegate
{
var manager = ondemandManager.Claim();
return this.CreateCountryRepository(manager);
}));
}
public ManagingBaskets.BasketRepository ClaimBasketRepository(IOnDemand <IDataManager> ondemandManager)
{
return(this.basketManager.ClaimBasketRepository(ondemandManager, delegate
{
return this.ClaimCountryRepository(ondemandManager);
},
monitor));
}
public IssuerRepository ClaimIssuerRepository(IOnDemand <IDataManager> ondemandManager)
{
return(this.issuerRepositoryStorage.Claim(IssuerRepositoryStorageKey, delegate
{
var manager = ondemandManager.Claim();
return this.CreateIssuerRepository(manager);
}));
}
public TaxonomyRepository ClaimTaxonomyRepository(
IOnDemand <IDataManager> ondemandManager,
BasketRepository basketRepository,
CountryRepository countryRepository
)
{
return(this.taxonomyRepositoryStorage.Claim(TaxonomyRepositoryStorageKey, delegate
{
return this.CreateTaxonomyRepository(ondemandManager.Claim(), basketRepository, countryRepository);
}));
}
public ManagingTaxonomies.TaxonomyRepository ClaimTaxonomyRepository(IOnDemand <IDataManager> ondemandManager)
{
return(this.taxonomyManager.ClaimTaxonomyRepository(ondemandManager, delegate
{
return this.ClaimBasketRepository(ondemandManager);
},
delegate
{
return this.ClaimCountryRepository(ondemandManager);
}));
}
public SecurityRepository ClaimSecurityRepository(
IOnDemand <IDataManager> ondemandManager,
Func <CountryRepository> ondemandCountryRepository
)
{
return(this.securityRepositoryStorage.Claim(SecurityManagerCacheKey, delegate
{
var securities = ondemandManager.Claim().GetAllSecurities();
var repository = this.CreateSecurityRepository(ondemandCountryRepository, securities);
return repository;
}));
}
public TargetingTypeRepository ClaimTargetingTypeRepository(
IOnDemand <IDataManager> ondemandManager,
TaxonomyRepository taxonomyRepository,
PortfolioRepository portfolioRepository
)
{
return(this.targetingTypeRepositoryStorage.Claim(TargetingTypeRepositoryStorageKey, delegate
{
return this.CreateTargetingTypeRepository(
ondemandManager.Claim(),
taxonomyRepository,
portfolioRepository
);
}));
}
public BasketRepository ClaimBasketRepository(
IOnDemand <IDataManager> ondemandManager,
Func <CountryRepository> ondemandCountryRepository,
IMonitor monitor
)
{
return(this.basketRepositoryStorage.Claim(BasketRepositoryStorageKey, delegate
{
return this.CreateBasketRepository(
ondemandManager.Claim(),
ondemandCountryRepository(),
monitor
);
}));
}
public TaxonomyRepository ClaimTaxonomyRepository(
IOnDemand <IDataManager> ondemandManager,
Func <BasketRepository> ondemandBasketRepository,
Func <CountryRepository> ondemandCountryRepository
)
{
return(this.taxonomyRepositoryStorage.Claim(TaxonomyRepositoryStorageKey, delegate
{
return this.CreateTaxonomyRepository(
ondemandManager.Claim(),
ondemandBasketRepository(),
ondemandCountryRepository()
);
}));
}
public PortfolioRepository ClaimPortfolioRepository(
IOnDemand <IDataManager> ondemandManager,
Func <SecurityRepository> ondemandSecurityRepository
)
{
return(this.portfolioRepositoryStorage.Claim(PortfolioRepositoryStorageKey, delegate
{
var manager = ondemandManager.Claim();
var portfolioInfos = manager.GetAllPortfolios();
var result = new PortfolioRepository(
portfolioInfos,
ondemandSecurityRepository()
);
return result;
}));
}
public BasketRepository ClaimBasketRepository(
IOnDemand <IDataManager> ondemandManager,
CountryRepository countryRepository,
IMonitor monitor
)
{
return(this.basketRepositoryStorage.Claim(BasketRepositoryStorageKey, delegate
{
var manager = ondemandManager.Claim();
return this.CreateBasketRepository(
manager,
countryRepository,
monitor
);
}));
}
public BenchmarkRepository ClaimBenchmarkRepository(IOnDemand <IDataManager> ondemandManager, DateTime timestamp)
{
var stored = this.benchmarkRepositoryStorage[BenchmarkManagerCacheKey];
if (stored == null)
{
stored = new BenchmarkRepository(timestamp, ondemandManager.Claim());
this.benchmarkRepositoryStorage[BenchmarkManagerCacheKey] = stored;
}
else if (stored.Timestamp == timestamp)
{
// do nothing
}
else
{
stored = new BenchmarkRepository(timestamp, ondemandManager.Claim());
this.benchmarkRepositoryStorage[BenchmarkManagerCacheKey] = stored;
}
return(stored);
}
public ManagingBenchmarks.BenchmarkRepository ClaimBenchmarkRepository(IOnDemand <IDataManager> ondemandManager, DateTime benchmarkDate)
{
return(this.benchmarkManager.ClaimBenchmarkRepository(ondemandManager, benchmarkDate));
}
public ManagingTargetingTypes.TargetingTypeRepository ClaimTargetingTypeRepository(IOnDemand <IDataManager> ondemandManager)
{
return(this.targetingTypeManager.ClaimTargetingTypeRepository(ondemandManager, delegate
{
return this.ClaimTaxonomyRepository(ondemandManager);
},
delegate
{
return this.ClaimPortfolioRepository(ondemandManager);
}));
}
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);
}
