public void Init() { _session = _sessionFactory.OpenSession(); foreach (var killType in new[] { typeof(ContentTypeDefinitionRecord), typeof(ContentPartDefinitionRecord), typeof(ContentFieldDefinitionRecord) }) { foreach (var killRecord in _session.CreateCriteria(killType).List()) { _session.Delete(killRecord); } } _session.Flush(); _session.Close(); _session.Dispose(); _session = _sessionFactory.OpenSession(); var builder = new ContainerBuilder(); builder.RegisterAutoMocking(); builder.RegisterType<ContentDefinitionManager>().As<IContentDefinitionManager>(); builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)); builder.RegisterType(typeof(SettingsFormatter)).As(typeof(ISettingsFormatter)); builder.RegisterType<Signals>().As<ISignals>(); builder.RegisterType<StubCacheManager>().As<ICacheManager>(); builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>(); _session = _sessionFactory.OpenSession(); builder.RegisterInstance(_transactionManager = new TestTransactionManager(_session)).As<ITransactionManager>(); _container = builder.Build(); }
public MembershipService(IWebsite website, IMemberDao memberDao, IRoleDao roleDao, ITransactionManager transactionManager) { this._website = website; this._memberDao = memberDao; this._roleDao = roleDao; this._transactionManager = transactionManager; }
internal DatabaseSession(IDatabaseCommandFactory databaseCommandFactory, ITransactionManager transactionManager, IDatabaseReaderFactory databaseReaderFactory, IConnectionHandler connectionHandler) { _databaseCommandFactory = databaseCommandFactory; _transactionManager = transactionManager; _databaseReaderFactory = databaseReaderFactory; _connectionHandler = connectionHandler; }
public RepoTimelineProvider(IIdGenerator generator, ITransactionManager trans, IRepository<TimelineItem> repoTi, IRepository<TimelineItemHistory> repoTih) { this.generator = generator; this.trans = trans; this.repoTi = repoTi; this.repoTih = repoTih; }
public DataRecipeHandler(IOrchardServices orchardServices, ITransactionManager transactionManager, IRecipeJournal recipeJournal) { _orchardServices = orchardServices; _transactionManager = transactionManager; _recipeJournal = recipeJournal; Logger = NullLogger.Instance; T = NullLocalizer.Instance; }
public PerTransactionLifestyleManagerBase(ITransactionManager manager) { Contract.Requires(manager != null); Contract.Ensures(_Manager != null); _Logger.Debug("created"); _Manager = manager; }
public PageProvider(ITransactionManager trans, IRepository<SubSite> repoSite, IRepository<WebPage> repoPage, IRepository<WebPageWidget> repoControl) { this.trans = trans; this.repoSite = repoSite; this.repoPage = repoPage; this.repoControl = repoControl; }
public SagePayService(ITransactionManager transactionManager, ICartSessionManager cartSessionManager, IGetUserGuid getUserGuid, ICartGuidResetter cartGuidResetter) { _transactionManager = transactionManager; _cartSessionManager = cartSessionManager; _getUserGuid = getUserGuid; _cartGuidResetter = cartGuidResetter; }
public ImageService(IWebsite website, IImageStorage imageStorage, IImageRepository imageRepository, ITransactionManager transactionManager) { this._website = website; this._imageStorage = imageStorage; this._imageRepository = imageRepository; this._transactionManager = transactionManager; }
public void Setup() { _Tm = new Services.Transaction.TransactionManager(new TransientActivityManager()); _DirPath = "."; _FilePath = _DirPath.Combine("test.txt"); }
public SessionLocator( ISessionFactoryHolder sessionFactoryHolder, ITransactionManager transactionManager) { _sessionFactoryHolder = sessionFactoryHolder; _transactionManager = transactionManager; Logger = NullLogger.Instance; }
public TestObject(ILifecycleManager lifecycleManager, IObjectPersistor persistor, INakedObjectAdapter nakedObjectAdapter, ITestObjectFactory factory, ITransactionManager transactionManager) : base(factory) { this.lifecycleManager = lifecycleManager; this.persistor = persistor; this.transactionManager = transactionManager; NakedObject = nakedObjectAdapter; }
public FileManagerService(IWebsite website, IFileStorage fileStorage, IStorageItemRepository storageItemRepository, ITransactionManager transactionManager) { this._fileStorage = fileStorage; this._website = website; this._transactionManager = transactionManager; this._storageItemRepository = storageItemRepository; }
public SpamFilterPartHandler( IRepository<SpamFilterPartRecord> repository, ITransactionManager transactionManager, ISpamService spamService ) { _transactionManager = transactionManager; _spamService = spamService; Filters.Add(StorageFilter.For(repository)); OnCreating<SpamFilterPart>((context, part) => { part.Status = _spamService.CheckForSpam(part); }); OnPublishing<SpamFilterPart>((context, part) => { if (part.Status == SpamStatus.Spam) { if (part.Settings.GetModel<SpamFilterPartSettings>().DeleteSpam) { _transactionManager.Cancel(); } context.Cancel = true; } }); }
public override void Init() { base.Init(); _distributedLockService = _container.Resolve<DistributedLockService>(); _applicationEnvironment = (StubApplicationEnvironment)_container.Resolve<IApplicationEnvironment>(); _distributedLockRepository = _container.Resolve<IRepository<DistributedLockRecord>>(); _transactionManager = _container.Resolve<ITransactionManager>(); }
public DataRecipeHandler(ICoeveryServices coeveryServices, ITransactionManager transactionManager) { _coeveryServices = coeveryServices; _transactionManager = transactionManager; Logger = NullLogger.Instance; T = NullLocalizer.Instance; }
public void Init(IEnumerable<Type> dataMigrations) { var builder = new ContainerBuilder(); _folders = new StubFolders(); var contentDefinitionManager = new Mock<IContentDefinitionManager>().Object; builder.RegisterInstance(new ShellSettings { DataTablePrefix = "TEST_"}); builder.RegisterType<SqlServerDataServicesProvider>().As<IDataServicesProvider>(); builder.RegisterType<DataServicesProviderFactory>().As<IDataServicesProviderFactory>(); builder.RegisterType<NullInterpreter>().As<IDataMigrationInterpreter>(); builder.RegisterInstance(_folders).As<IExtensionFolders>(); builder.RegisterInstance(contentDefinitionManager).As<IContentDefinitionManager>(); builder.RegisterType<ExtensionManager>().As<IExtensionManager>(); builder.RegisterType<DataMigrationManager>().As<IDataMigrationManager>(); builder.RegisterGeneric(typeof(Repository<>)).As(typeof(IRepository<>)); builder.RegisterType<StubCacheManager>().As<ICacheManager>(); builder.RegisterType<StubParallelCacheContext>().As<IParallelCacheContext>(); builder.RegisterType<StubAsyncTokenProvider>().As<IAsyncTokenProvider>(); _session = _sessionFactory.OpenSession(); builder.RegisterInstance(new DefaultContentManagerTests.TestSessionLocator(_session)).As<ISessionLocator>().As<ITransactionManager>(); foreach(var type in dataMigrations) { builder.RegisterType(type).As<IDataMigration>(); } _container = builder.Build(); _container.Resolve<IExtensionManager>(); _dataMigrationManager = _container.Resolve<IDataMigrationManager>(); _repository = _container.Resolve<IRepository<DataMigrationRecord>>(); _transactionManager = _container.Resolve<ITransactionManager>(); InitDb(); }
public ImmediateCommandDispatcher(IEnumerable<ICommandHandler> commandHandlers, IEnumerable<ICommandValidator> commandValidators, ITransactionManager transactionManager, ILogger logger) { _commandHandlers = commandHandlers; _commandValidators = commandValidators; _transactionManager = transactionManager; _logger = logger; }
/// <summary> /// </summary> /// <param name="channel"></param> /// <param name="transactionManager"> /// Must be unique for this client. i.e. the transaction ids used in this client is not /// globally unique /// </param> public StompClient(ITcpChannel channel, ITransactionManager transactionManager) { if (channel == null) throw new ArgumentNullException("channel"); if (transactionManager == null) throw new ArgumentNullException("transactionManager"); Channel = channel; _transactionManager = transactionManager; }
public void SetUp() { var container = new WindsorContainer(); DependencyResolver.InitializeWith(new WindsorDependencyResolver(container)); container.AddComponent("transaction.manager", typeof(ITransactionManager), typeof(TestITransactionManager)); manager = DependencyResolver.Resolver.GetImplementationOf<ITransactionManager>(); attribute = new MvcTransactionAttribute(); }
public ThreadedService(Func<ISession> getSession, ITransactionManager manager) { Contract.Requires(manager != null); Contract.Requires(getSession != null); _GetSession = getSession; _Manager = manager; }
public UserController(ITransactionManager trans, IRepository<User> repoUser, IRepository<Role> repoRole, IRepository<UserRole> repoUr) : base() { this.trans = trans; this.repoUser = repoUser; this.repoRole = repoRole; this.repoUr = repoUr; }
public override void SetProperty(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter value, ITransactionManager transactionManager, ISession session, ILifecycleManager lifecycleManager) { try { property.SetValue(nakedObjectAdapter.GetDomainObject(), value.GetDomainObject(), null); } catch (TargetInvocationException e) { InvokeUtils.InvocationException("Exception executing " + property, e); } }
public RemoteImportService( ITransactionManager transactionManager, IContentManager contentManager, ILoggerFactory loggerFactory) { _transactionManager = transactionManager; _contentManager = contentManager; Logger = loggerFactory.CreateLogger(this.GetType()); }
public TransactionalConnectionFactory( ITransactionManager manager, String connectionString, Type dbConnectionType) { _manager = manager; _connectionString = connectionString; _dbConnectionType = dbConnectionType; }
public TransactionInterceptor(ITransactionManager transactionManager, IExceptionLogger exceptionLogger) { ParameterCheck.ParameterRequired(transactionManager, "transactionManager"); ParameterCheck.ParameterRequired(exceptionLogger, "exceptionLogger"); this.transactionManager = transactionManager; this.exceptionLogger = exceptionLogger; }
public void SetUp() { var container = new WindsorContainer(); DependencyResolver.SetResolver(new WindsorDependencyResolver(container)); container.Register(Component.For<ITransactionManager>().ImplementedBy<TestITransactionManager>().Named("transaction.manager")); manager = DependencyResolver.Current.GetService<ITransactionManager>(); attribute = new MvcTransactionAttribute(); }
public ProjectRepository(IReadOnlyRepository readOnlyRepository, IWriteableRepository writeableRepository, IBlingDispatcher dispatcher, ITransactionManager transactionManager) { _readOnlyRepository = readOnlyRepository; _writeableRepository = writeableRepository; _dispatcher = dispatcher; _transactionManager = transactionManager; }
/// <summary> /// Constructor. /// </summary> /// <param name = "getSession"></param> public SessionManager(Func<ISession> getSession, ITransactionManager transactionManager) { Contract.Requires(getSession != null); Contract.Ensures(this.getSession != null); this.getSession = getSession; this.transactionManager = transactionManager; }
public override INakedObjectAdapter Invoke(INakedObjectAdapter nakedObjectAdapter, INakedObjectAdapter[] parameters, int resultPage, ILifecycleManager lifecycleManager, IMetamodelManager manager, ISession session, INakedObjectManager nakedObjectManager, IMessageBroker messageBroker, ITransactionManager transactionManager) { profileManager.Begin(session, ProfileEvent.ActionInvocation, identifier.MemberName, nakedObjectAdapter, lifecycleManager); try { return underlyingFacet.Invoke(nakedObjectAdapter, parameters, resultPage, lifecycleManager, manager, session, nakedObjectManager, messageBroker, transactionManager); } finally { profileManager.End(session, ProfileEvent.ActionInvocation, identifier.MemberName, nakedObjectAdapter, lifecycleManager); } }
public PowerDNSController(ILogger <PowerDNSController> logger, IrqliteService rqliteService, ITransactionManager transactionManager, IConfiguration configRoot) { _logger = logger; _rqliteService = rqliteService; _transactionManager = transactionManager; _configRoot = configRoot; }
public OneToOneAssociationSpec(IOneToOneAssociationSpecImmutable association, INakedObjectsFramework framework) : base(association, framework) { this.transactionManager = framework.TransactionManager; }
protected virtual void PreInstallFixtures(ITransactionManager transactionManager) { fixtureServices = new FixtureServices(); }
public RecycleBin(ITransactionManager transactionManager, IContentManager contentManager) { _transactionManager = transactionManager; _contentManager = contentManager; }
protected virtual void InitialiseDefaultTransactionManager(string password) { TransactionManager = new ClientPersonalTransactionManager(Address, password); }
public Repository(ISession session, ITransactionManager transactionManager) { Session = session; TransactionManager = transactionManager; }
public ResourceCoordinatorInterceptor(IServiceProvider serviceProvider, ITransactionManager transactionManager) { _serviceProvider = serviceProvider; _transactionManager = transactionManager; }
public override void ClearProperty(INakedObject nakedObject, ITransactionManager transactionManager) { InvokeUtils.Invoke(method, nakedObject); }
public MyService(ITransactionManager manager) { Contract.Ensures(_Manager != null); _Manager = manager; }
internal PrivateManagedTransaction(ITransactionManager manager, IDbTransaction transaction) : base(manager, transaction) { }
public void SetUpContext() { this.SerialNumberTransactionRepository = Substitute.For <IRepository <SernosTrans, string> >(); this.TransactionManager = Substitute.For <ITransactionManager>(); this.Sut = new SernosTransactionService(this.SerialNumberTransactionRepository, this.TransactionManager); }
public DefaultToTransientLifeStyle(ITransactionManager transactionManager) { Contract.Requires(transactionManager != null); _TransactionManager = transactionManager; }
protected virtual void InitialiseDefaultTransactionManager(string password) { TransactionManager = new ManagedAccountTransactionManager(Address, password); }
public MakeController(ITransactionManager transactionManager) { this.transactionManager = transactionManager; }
public PortFacadeService( IRepository <Port, string> portRepository, ITransactionManager transactionManager) : base(portRepository, transactionManager) { }
public TransactionFilter(ITransactionManager transactionManager) { _transactionManager = transactionManager; }
public PostMatchDataPersister(ITransactionManager transactionManager, PostMatchData postMatchData) { _transactionManager = transactionManager; _postMatchData = postMatchData; }
public OneToOneAssociationSpec(IMetamodelManager metamodel, IOneToOneAssociationSpecImmutable association, ISession session, ILifecycleManager lifecycleManager, INakedObjectManager manager, IObjectPersistor persistor, ITransactionManager transactionManager) : base(metamodel, association, session, lifecycleManager, manager) { this.persistor = persistor; this.transactionManager = transactionManager; }
public override void SetProperty(INakedObjectAdapter inObjectAdapter, INakedObjectAdapter value, ITransactionManager transactionManager, ISession session, ILifecycleManager lifecycleManager) => methodDelegate(inObjectAdapter.GetDomainObject(), new[] { value.GetDomainObject() });
public BuildPlanService(IRepository <BuildPlan, string> repository, ITransactionManager transactionManager) : base(repository, transactionManager) { }
public EtherTransferService(ITransactionManager transactionManager) { _transactionManager = transactionManager; }
public TransactionsController(ITransactionManager manager, ILogger <TransactionsController> logger) { _manager = manager; _logger = logger; }
public DeployContract(ITransactionManager transactionManager) { TransactionManager = transactionManager; _deployContractTransactionBuilder = new DeployContractTransactionBuilder(); }
public TransactionManagerGrain(ITransactionManager transactionManager) { this.transactionManager = transactionManager; this.transactionManagerService = new TransactionManagerService(transactionManager); }
public ExportContactService(IContentManager contentManager, ITransactionManager transactionManager, ITaxonomyService taxonomyService) { _contentManager = contentManager; _transactionManager = transactionManager; _taxonomyService = taxonomyService; }
public DataSourceBackedConfigurationProvider(IDataSource dataSource, ITransactionManager transactionManager) { _dataSource = dataSource; _transactionManager = transactionManager; }
/// <summary> /// Creator: Robert Holmes /// Created: 04/29/2020 /// Approver: Jaeho Kim /// /// Default constructor, initializes class level variables. /// </summary> /// <remarks> /// Updater: /// Updated: /// Update: /// </remarks> public CartController() { _productManager = new ProductManager(); _transactionManager = new TransactionManager(); }
public Repository(ITransactionManager transactionManager) { _transactionManager = transactionManager; Logger = NullLogger.Instance; }
protected ContractTransactionHandlerBase(ITransactionManager transactionManager) { Client = transactionManager.Client; Account = transactionManager.Account; TransactionManager = transactionManager; }
RelativeBuilder(ITransactionManager transactionManager, bool iOSPadding) { _transactionManager = transactionManager; Init(iOSPadding); }