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);
}
