public ModelApplier(
ChangingBt.ChangesetApplier btChangesetApplier,
ChangingBt.ModelToChangesetTransformer btModelTransformer,
ChangingPsto.ChangesetApplier pstoChangesetApplier,
ChangingPsto.ModelToChangesetTransformer pstoModelTransformer,
ChangingTtbbv.ChangesetApplier ttbbvChangesetApplier,
ChangingTtbbv.ModelToChangesetTransformer ttbbvModelTransformer,
ChangingTtbpt.ChangesetApplier ttbptChangesetApplier,
ChangingTtbpt.ModelToChangesetTransformer ttbptModelTransformer,
ModelValidator modelValidator,
IDataManagerFactory dataManagerFactory,
ManagingCalculations.CalculationRequester calculationRequester
)
{
this.btChangesetApplier = btChangesetApplier;
this.btModelTransformer = btModelTransformer;
this.pstoChangesetApplier = pstoChangesetApplier;
this.pstoModelTransformer = pstoModelTransformer;
this.ttbbvChangesetApplier = ttbbvChangesetApplier;
this.ttbbvModelTransformer = ttbbvModelTransformer;
this.ttbptChangesetApplier = ttbptChangesetApplier;
this.ttbptModelTransformer = ttbptModelTransformer;
this.modelValidator = modelValidator;
this.dataManagerFactory = dataManagerFactory;
this.calculationRequester = calculationRequester;
}
public static void WithDataManager(this IDataManagerFactory factory, Action <IDataManager> func, IsolationLevel?level = null)
{
factory.WithDataManager(manager =>
{
func(manager);
return(true);
}, level);
}
public static void WithTransaction(this IDataManagerFactory factory, Action <ITransactionDataManager> func, IsolationLevel level = IsolationLevel.ReadCommitted)
{
factory.WithTransaction(manager =>
{
func(manager);
return(true);
}, level);
}
public ChangesetApplier(
IDataManagerFactory manageFactory,
ModelToTaxonomyTransformer modelTransformer
)
{
this.managerFactory = manageFactory;
this.modelTransformer = modelTransformer;
}
public static T WithTransaction <T>(this IDataManagerFactory factory, Func <ITransactionDataManager, T> func, IsolationLevel level = IsolationLevel.ReadCommitted)
{
using (var manager = factory.GetTransactionManager(level))
{
var result = func(manager);
manager.Commit();
return(result);
}
}
public Deserializer(
ISqlConnectionFactory connectionFactory,
IDataManagerFactory <TDataManager> dataManagerFactory,
RepositoryManager repositoryManager
)
{
this.connectionFactory = connectionFactory;
this.dataManagerFactory = dataManagerFactory;
this.repositoryManager = repositoryManager;
}
public void RecalculateRootModel(
RootModel root,
ISqlConnectionFactory connectionFactory,
IDataManagerFactory dataManagerFactory,
CalculationTicket ticket
)
{
// everything is recalculated automatically but overlays in case they were changed
#warning it's a big question whether overlays need to be recalculated every time
#warning we need to see if somebody has changed PST composition since we opened for editing but haven't yet saved
SecurityRepository securityRepository;
PortfolioRepository portfolioRepository;
ManagingPst.PortfolioSecurityTargetRepository portfolioSecurityTargetRepository;
using (var ondemandManager = new OnDemandDataManager(connectionFactory, dataManagerFactory))
{
securityRepository = this.repositoryManager.ClaimSecurityRepository(ondemandManager);
portfolioRepository = this.repositoryManager.ClaimPortfolioRepository(ondemandManager);
portfolioSecurityTargetRepository = this.repositoryManager.ClaimPortfolioSecurityTargetRepository(
root.LatestPstChangeset,
ondemandManager.Claim()
);
// in order to proceed we need to make sure all missing countries are there
IEnumerable <BenchmarkSumByIsoInfo> benchmarks = new BenchmarkSumByIsoInfo[] { };
var computations = this.modelBuilder.CreateComputations(root.Globe, this.Traverser);
var countryRepository = this.repositoryManager.ClaimCountryRepository(ondemandManager);
var targetingTypeRepository = this.repositoryManager.ClaimTargetingTypeRepository(ondemandManager);
var targetingType = targetingTypeRepository.GetTargetingType(root.TargetingType.Id);
this.RegisterMissingCountriesIfAny(
root,
computations,
countryRepository,
targetingType,
securityRepository,
portfolioRepository,
portfolioSecurityTargetRepository,
benchmarks
);
}
this.InitializeOverlay(
root,
securityRepository,
portfolioRepository,
portfolioSecurityTargetRepository
);
// required to inject problems to base values
// we are not interested in the result of validation
this.modelApplier.ValidateModel(root, ticket);
}
public Deserializer(
ISqlConnectionFactory connectionFactory,
IDataManagerFactory dataManagerFactory,
TopDown.Core.RepositoryManager repositoryManager
)
: base(connectionFactory, dataManagerFactory, repositoryManager)
{
this.connectionFactory = connectionFactory;
this.dataManagerFactory = dataManagerFactory;
this.repositoryManager = repositoryManager;
}
public ModelManager(
ISqlConnectionFactory connectionFactory,
IDataManagerFactory dataManagerFactory,
RepositoryManager repositoryManager,
ModelBuilder modelBuilder
)
{
this.connectionFactory = connectionFactory;
this.dataManagerFactory = dataManagerFactory;
this.repositoryManager = repositoryManager;
this.modelBuilder = modelBuilder;
}
public static T WithDataManager <T>(this IDataManagerFactory factory, Func <IDataManager, T> func, IsolationLevel?level = null)
{
using (var manager = level == null ? factory.GetManager() : factory.GetTransactionManager(level.Value))
{
var result = func(manager);
var transaction = manager as IUnitOfWork;
if (transaction != null)
{
transaction.Commit();
}
return(result);
}
}
public Facade(
Core.ModelManager modelManager,
Aims.Data.Server.Serializer commonSerializer,
Serializer serializer,
Deserializer deserializer,
ISqlConnectionFactory connectionFactory,
IDataManagerFactory dataManagerFactory,
RepositoryManager repositoryManager
)
{
this.modelManager = modelManager;
this.serializer = serializer;
this.connectionFactory = connectionFactory;
this.dataManagerFactory = dataManagerFactory;
this.RepositoryManager = repositoryManager;
this.commonSerializer = commonSerializer;
this.deserializer = deserializer;
}
public ModelApplier(
IDataManagerFactory dataManagerFactory,
ChangingTtgbsbv.ChangesetApplier ttgbsbvChangesetApplier,
ChangingTtgbsbv.ModelToChangesetTransformer ttgbsbvModelTransformer,
ChangingBpst.PortfolioTargetChangesetApplier bpstChangesetApplier,
ChangingBpst.ModelToChangesetTransformter bpstModelTransformter,
ManagingCalculations.CalculationRequester calculationRequester,
ModelValidator modelValidator,
RepositoryManager repositoryManager
)
{
this.dataManagerFactory = dataManagerFactory;
this.bpstChangesetApplier = bpstChangesetApplier;
this.ttgbsbvChangesetApplier = ttgbsbvChangesetApplier;
this.ttgbsbvModelTransformer = ttgbsbvModelTransformer;
this.bpstModelTransformter = bpstModelTransformter;
this.calculationRequester = calculationRequester;
this.modelValidator = modelValidator;
this.repositoryManager = repositoryManager;
}
public Facade(
ISqlConnectionFactory connectionFactory,
ISqlConnectionFactory usersConnectionFactory,
IDataManagerFactory dataManagerFactory,
IUsersDataManagerFactory dataUsersManagerFactory,
RepositoryManager repositoryManager,
ManagingBpt.ModelManager bptManager,
ExpressionPicker expressionPicker,
CommonParts commonParts,
PstManager pstManager,
BasketManager basketManager,
ProtfolioPickerManager protfolioPickerManager,
Gadgets.BasketPicker.ModelManager basketPickerManager,
ManagingBpst.ModelManager bpstModelManager,
ManagingPortfolios.PortfolioManager portfolioManager,
ManagingCalculations.Hopper hopper,
ManagingComments.CommentManager commentsManager
)
{
this.usersConnectionFactory = usersConnectionFactory;
this.connectionFactory = connectionFactory;
this.dataManagerFactory = dataManagerFactory;
this.dataUsersManagerFactory = dataUsersManagerFactory;
this.RepositoryManager = repositoryManager;
this.BptManager = bptManager;
this.ExpressionPicker = expressionPicker;
this.CommonParts = commonParts;
this.PstManager = pstManager;
this.BasketManager = basketManager;
this.PortfiolioPickerManager = protfolioPickerManager;
this.BasketPickerManager = basketPickerManager;
this.BpstManager = bpstModelManager;
this.PortfolioManager = portfolioManager;
this.hopper = hopper;
this.commentManager = commentsManager;
}
public PstManager(
ChangesetApplier applier,
ModelValidator modelValidator,
ModelToChangesetTransformer transformer,
ModelFromJsonDeserializer modelDeserializer,
ModelBuilder modelBuilder,
RepositoryManager repositoryManager,
ModelChangeDetector modelChangeDetector,
IDataManagerFactory dataManagerFactory,
ManagingCalculations.CalculationRequester calculationRequester,
ModelToJsonSerializer modelSerializer
)
{
this.applier = applier;
this.modelValidator = modelValidator;
this.transformer = transformer;
this.modelDeserializer = modelDeserializer;
this.modelBuilder = modelBuilder;
this.repositoryManager = repositoryManager;
this.modelChangeDetector = modelChangeDetector;
this.dataManagerFactory = dataManagerFactory;
this.calculationRequester = calculationRequester;
this.modelSerializer = modelSerializer;
}
/// <param name="factory">Factory used to instantinate data access tolls</param>
public DataManager(IDataManagerFactory factory)
{
_factory = factory;
}
public ProjectXSQLConnectionManager(IDataManagerFactory factory)
{
_factory = factory;
}
public OnDemandDataManager(SqlConnection connection, IDataManagerFactory dataManagerFactory)
: base(connection, dataManagerFactory)
{
}
public OnDemandDataManager(ISqlConnectionFactory connectionFactory, IDataManagerFactory dataManagerFactory)
: base(connectionFactory, dataManagerFactory)
{
}
public ChatDb(IDataManagerFactory dataManagerFactory)
{
_dataManagerFactory = dataManagerFactory;
}
public OnDemandDataManager(ISqlConnectionFactory connectionFactory, IDataManagerFactory <TDataManager> dataManagerFactory)
{
this.connectionFactory = connectionFactory;
this.dataManagerFactory = dataManagerFactory;
}
public static void WithRepository <TRepo>(this IDataManagerFactory factory, Action <TRepo> func, IsolationLevel?level = null) where TRepo : class
{
factory.WithDataManager(manager => manager.WithRepository(func), level);
}
public static T WithRepository <TRepo, T>(this IDataManagerFactory factory, Func <TRepo, T> func, IsolationLevel?level = null) where TRepo : class
{
return(factory.WithDataManager(manager => manager.WithRepository(func), level));
}
public UserFacade(IDataManagerFactory factory, HashAlgorithm algorithm)
{
this.factory = factory;
this.algorithm = algorithm;
}
public DataManagerFactoryLazyDecorator(IDataManagerFactory factory)
{
_factory = factory;
}
public OfferFacade(IDataManagerFactory factory)
{
this.factory = factory;
}
public LazyDataGetter(IDataGetter <TEntity> getter, IDataManagerFactory lazyFactory)
{
_getter = getter;
_lazyFactory = lazyFactory;
_mainEntityInfo = _lazyFactory.InfoAbout <TEntity>();
}
public OfferFacade(IDataManagerFactory factory)
{
this.factory = factory;
}
public UserFacade(IDataManagerFactory factory, HashAlgorithm algorithm)
{
this.factory = factory;
this.algorithm = algorithm;
}
static DALConfigurationManager()
{
connectionManager = new ProjectXSQLConnectionManager(new ProjectXSQLDataManagerFactory(new DefaultConnectionManager(sharedConnectionString)));
sqlFactory = new ProjectXSQLDataManagerFactory(connectionManager);
sqlcacheFactory = new ProjectXSQLDataManagerFactory(connectionManager);
}
public OnDemandDataManager(SqlConnection connection, IDataManagerFactory <TDataManager> dataManagerFactory)
{
this.connection = connection;
this.dataManagerFactory = dataManagerFactory;
}
