public static ITransaction ToTransaction(ITransactionFactory transactionFactory, IQuickTransaction quickTransaction)
{
var result = transactionFactory.CreateTransaction(quickTransaction.Account, quickTransaction.Category,
quickTransaction.Name, quickTransaction.Total, DateTime.Now, 0, quickTransaction.Weight, null, null);
return(result);
}
public DbTransactionCommandHandlerDecorator(DecoratorContext decoratorContext, ITransactionFactory <TDbContext> transactionFactory, ICommandHandler <TCommand, TResult> decoratee)
{
_decoratee = decoratee;
_transactionFactory = transactionFactory;
_transactionType = decoratorContext.ImplementationType
.GetCustomAttribute <TransactionAttribute>(true)?.TransactionType;
}
protected AppService(
IUnitOfWorkFactory unitOfWorkFactory,
ITransactionFactory transactionFactory)
{
UnitOfWorkFactory = unitOfWorkFactory;
TransactionFactory = transactionFactory;
}
public AccountService(
ITransactionFactory transactionFactory,
ITransactionRepository transactionRepository)
{
_transactionFactory = transactionFactory;
_transactionRepository = transactionRepository;
}
public CoinFlipService
(
IHashService hashService,
IRandomService randomService,
IRepoServiceFactory repoServiceFactory,
ITransactionFactory transactionFactory,
IBetService betService,
IItemService itemService,
IMongoJackpotRepoService mongoJackpotRepoService,
ICoinFlipHubConnections coinFlipHubConnections,
IMongoPreHashRepoService preHashRepoService,
IDiscordService discordService
)
{
_hashService = hashService;
_randomService = randomService;
_repoServiceFactory = repoServiceFactory;
_transactionFactory = transactionFactory;
_betService = betService;
_itemService = itemService;
_mongoJackpotRepoService = mongoJackpotRepoService;
_coinFlipHubConnections = coinFlipHubConnections;
_preHashRepoService = preHashRepoService;
_discordService = discordService;
}
public DynamicCommand(ITransactionFactory transactionFactory,
IExceptionHandler exceptionHandler, IEnumerable <IDynamicCommandProvider> commandProviders,
ExecutionContext executionContext, ICommandResultVisualizer commandResultVisualizer) : base(
transactionFactory, exceptionHandler, executionContext, commandResultVisualizer)
{
this.commandProviders = commandProviders;
}
public UpdateCliCommand(ITransactionFactory transactionFactory, IExceptionHandler exceptionHandler, ExecutionContext executionContext, ICommandResultVisualizer commandResultVisualizer, ICliUpdater cliUpdater, IFileSystem fileSystem, IProgressVisualizer progressVisualizer, IUserInterface userInterface) : base(transactionFactory, exceptionHandler, executionContext, commandResultVisualizer)
{
this.cliUpdater = cliUpdater;
this.fileSystem = fileSystem;
this.progressVisualizer = progressVisualizer;
this.userInterface = userInterface;
}
/// <summary>
/// Initializes a new instance of the <see cref="DoesJobExistQueryHandler{TConnection, TTransaction}" /> class.
/// </summary>
/// <param name="commandCache">The command cache.</param>
/// <param name="connectionInformation">The connection information.</param>
/// <param name="tableExists">The table exists.</param>
/// <param name="tableNameHelper">The table name helper.</param>
/// <param name="dbConnectionFactory">The database connection factory.</param>
/// <param name="transactionFactory">The transaction factory.</param>
/// <param name="prepareQuery">The prepare query.</param>
/// <param name="readColumn">The read column.</param>
public DoesJobExistQueryHandler(CommandStringCache commandCache,
IConnectionInformation connectionInformation,
IQueryHandler <GetTableExistsQuery, bool> tableExists,
ITableNameHelper tableNameHelper,
IDbConnectionFactory dbConnectionFactory,
ITransactionFactory transactionFactory,
IPrepareQueryHandler <DoesJobExistQuery <TConnection, TTransaction>, QueueStatuses> prepareQuery,
IReadColumn readColumn)
{
Guard.NotNull(() => commandCache, commandCache);
Guard.NotNull(() => connectionInformation, connectionInformation);
Guard.NotNull(() => tableExists, tableExists);
Guard.NotNull(() => tableNameHelper, tableNameHelper);
Guard.NotNull(() => dbConnectionFactory, dbConnectionFactory);
Guard.NotNull(() => transactionFactory, transactionFactory);
Guard.NotNull(() => prepareQuery, prepareQuery);
Guard.NotNull(() => readColumn, readColumn);
_commandCache = commandCache;
_connectionInformation = connectionInformation;
_tableExists = tableExists;
_tableNameHelper = tableNameHelper;
_dbConnectionFactory = dbConnectionFactory;
_transactionFactory = transactionFactory;
_prepareQuery = prepareQuery;
_readColumn = readColumn;
}
public ApproveService(IPublishedProviderStatusUpdateService publishedProviderStatusUpdateService,
IPublishedFundingDataService publishedFundingDataService,
IPublishedProviderIndexerService publishedProviderIndexerService,
IPublishingResiliencePolicies publishingResiliencePolicies,
IPrerequisiteCheckerLocator prerequisiteCheckerLocator,
IJobManagement jobManagement,
ILogger logger,
ITransactionFactory transactionFactory,
IPublishedProviderVersionService publishedProviderVersionService,
IGeneratePublishedFundingCsvJobsCreationLocator generateCsvJobsLocator) : base(jobManagement, logger)
{
Guard.ArgumentNotNull(generateCsvJobsLocator, nameof(generateCsvJobsLocator));
Guard.ArgumentNotNull(prerequisiteCheckerLocator, nameof(prerequisiteCheckerLocator));
Guard.ArgumentNotNull(publishedProviderStatusUpdateService, nameof(publishedProviderStatusUpdateService));
Guard.ArgumentNotNull(publishedFundingDataService, nameof(publishedFundingDataService));
Guard.ArgumentNotNull(publishedProviderIndexerService, nameof(publishedProviderIndexerService));
Guard.ArgumentNotNull(publishingResiliencePolicies, nameof(publishingResiliencePolicies));
Guard.ArgumentNotNull(logger, nameof(logger));
Guard.ArgumentNotNull(transactionFactory, nameof(transactionFactory));
Guard.ArgumentNotNull(publishedProviderVersionService, nameof(publishedProviderVersionService));
_publishedProviderStatusUpdateService = publishedProviderStatusUpdateService;
_publishedFundingDataService = publishedFundingDataService;
_publishedProviderIndexerService = publishedProviderIndexerService;
_prerequisiteCheckerLocator = prerequisiteCheckerLocator;
_logger = logger;
_generateCsvJobsLocator = generateCsvJobsLocator;
_transactionFactory = transactionFactory;
_publishedProviderVersionService = publishedProviderVersionService;
}
public void SetUp()
{
threadingPolicy = new SingleThreadingPolicy();
transactionFactory = new TransactionFactory(threadingPolicy);
layer = MockRepository.GenerateMock<ILayer>();
serverManager = MockRepository.GenerateMock<IServerManager>();
serverManagerFactory = MockRepository.GenerateMock<IServerManagerFactory>();
operationFactory = new OperationFactory(layer, serverManagerFactory);
sut = new Deployer(transactionFactory, operationFactory);
project = new Project
{
Name = "Search.API",
Source = @"\\ystage01.ywebfarm.lcl\e$\ServiceArtifacts\Yoox.API\Search.API\1.1_new",
Path = @"Test\Yoox.API\Search.API\1.0",
Application = "Search.API",
Site = "Yoox.API",
Servers = new[] { @"\\serverA\", @"\\serverB\" },
};
}
public GetTargetsCommand(ITransactionFactory transactionFactory, IExceptionHandler exceptionHandler, ExecutionContext executionContext, ICommandResultVisualizer commandResultVisualizer, IEntityFactory entityFactory, ITargetParser targetParser, ISdkRepository sdkRepository, IUserInterface userInterface) : base(transactionFactory, exceptionHandler, executionContext, commandResultVisualizer, true)
{
this.entityFactory = entityFactory;
this.targetParser = targetParser;
this.sdkRepository = sdkRepository;
this.userInterface = userInterface;
}
/// <summary>
/// Initializes a new instance of the <see cref="MoveRecordToErrorQueueCommandHandler{TConnection, TTransaction, TCommand}" /> class.
/// </summary>
/// <param name="options">The options.</param>
/// <param name="deleteMetaCommandHandler">The delete meta command handler.</param>
/// <param name="setStatusCommandHandler">The set status command handler.</param>
/// <param name="dbConnectionFactory">The database connection factory.</param>
/// <param name="transactionFactory">The transaction factory.</param>
/// <param name="prepareCommand">The prepare command.</param>
/// <param name="headers">The headers.</param>
/// <param name="setCommandHandler">The set command handler.</param>
public MoveRecordToErrorQueueCommandHandler(
ITransportOptionsFactory options,
ICommandHandler <DeleteMetaDataCommand> deleteMetaCommandHandler,
ICommandHandler <SetStatusTableStatusTransactionCommand> setStatusCommandHandler,
IDbConnectionFactory dbConnectionFactory,
ITransactionFactory transactionFactory,
IPrepareCommandHandler <MoveRecordToErrorQueueCommand <long> > prepareCommand,
IConnectionHeader <TConnection, TTransaction, TCommand> headers,
ICommandHandler <SetStatusTableStatusCommand <long> > setCommandHandler)
{
Guard.NotNull(() => options, options);
Guard.NotNull(() => transactionFactory, transactionFactory);
Guard.NotNull(() => headers, headers);
Guard.NotNull(() => prepareCommand, prepareCommand);
Guard.NotNull(() => dbConnectionFactory, dbConnectionFactory);
Guard.NotNull(() => deleteMetaCommandHandler, deleteMetaCommandHandler);
Guard.NotNull(() => setStatusCommandHandler, setStatusCommandHandler);
Guard.NotNull(() => setCommandHandler, setCommandHandler);
_options = new Lazy <ITransportOptions>(options.Create);
_deleteMetaCommandHandler = deleteMetaCommandHandler;
_setStatusCommandHandler = setStatusCommandHandler;
_dbConnectionFactory = dbConnectionFactory;
_transactionFactory = transactionFactory;
_prepareCommand = prepareCommand;
_headers = headers;
_setStatusNoTransactionCommandHandler = setCommandHandler;
}
public void Setup()
{
var connectionFactory = Substitute.For <IGRPCConnectionFactory>();
transactionFactory = Substitute.For <ITransactionFactory>();
client = new DgraphClient(connectionFactory, transactionFactory);
}
public AccountService(IRepository <ITransaction> transactionRepo,
IRepository <IAccount> accoutRepo,
ITransactionFactory transactionFactory,
IAccountFactory accountFactory,
IPrincipal principal)
{
if (transactionRepo == null)
{
throw new ArgumentNullException("transactionRepo");
}
if (accoutRepo == null)
{
throw new ArgumentNullException("accoutRepo");
}
if (transactionFactory == null)
{
throw new ArgumentNullException("transactionFactory");
}
if (accountFactory == null)
{
throw new ArgumentNullException("accountFactory");
}
if (principal == null)
{
throw new ArgumentNullException("principal");
}
_transactionRepo = transactionRepo;
_accoutRepo = accoutRepo;
_transactionFactory = transactionFactory;
_accountFactory = accountFactory;
_username = principal.Identity.Name;
}
private Settings BuildSettings(SessionElement sessionElement)
{
Settings settings = new Settings();
IConnectionProvider connectionProvider = ConnectionProviderFactory.NewConnectionProvider(sessionElement);
ITransactionFactory transactionFactory = CreateTransactionFactory(sessionElement);
string releaseModeName = sessionElement.ConnectionReleaseMode;
ConnectionReleaseMode releaseMode = "auto".Equals(releaseModeName) ? ConnectionReleaseMode.AfterTransaction : ParseConnectionReleaseMode(releaseModeName);
settings.SessionFactoryName = sessionElement.Name;
settings.ConnectionReleaseMode = releaseMode;
// settings.DefaultBatchFetchSize = sessionElement.DefaultBatchFetchSize;
settings.BatchSize = sessionElement.BatchSize;
settings.BatcherFactory = new BatcherFactory();// CreateBatcherFactory(sessionElement, settings.BatchSize, connectionProvider);
string isolationString = sessionElement.IsolationString;
IsolationLevel isolation = IsolationLevel.Unspecified;
if (isolationString.Length > 0)
{
try
{
isolation = (IsolationLevel)Enum.Parse(typeof(IsolationLevel), isolationString);
}
catch
{
throw new Exception("The isolation level of " + isolationString + " is not a valid IsolationLevel. Please use one of the Member Names from the IsolationLevel.");
}
}
settings.IsolationLevel = isolation;
settings.ConnectionProvider = connectionProvider;
settings.TransactionFactory = transactionFactory;
return(settings);
}
public SqLiteTransactionStorage(ITransactionFactory transactionFactory,
IAccountStorage accountStorage,
ICategoryStorage categoryStorage) : base(transactionFactory)
{
_accountStorage = accountStorage;
_categoryStorage = categoryStorage;
}
private static async Task TransactionAsync(SqlDb dbTx, ITransactionFactory txFactory)
{
try
{
await txFactory.ExecuteAsync(async() => {
await dbTx.DeleteAsync <Order>((o, s) => o.Id > 0);
await dbTx.DeleteAsync <Custom>((c, s) => c.Id > 0);
throw new Exception("Rollback");
});
}
catch
{
//ignore Exception
}
var tx = txFactory.Create();//Create(IsolationLevel)
await dbTx.DeleteAsync <Order>((o, s) => o.Id > 0);
await dbTx.DeleteAsync <Custom>((c, s) => c.Id > 0);
//tx.Commit();
tx.Rollback();
var count = await dbTx.SelectAsync <Order, int>((o, s) => s.Count(), null);
Console.WriteLine(count);
}
protected static void BeginInit(string dbName)
{
try
{
if (TransactionFactory == null)
{
var logRepository = LogManager.GetRepository(Assembly.GetEntryAssembly());
log4net.Config.XmlConfigurator.Configure(logRepository, new FileInfo("log4net.config"));
LogManager.GetLogger(TestClass).Info("Starting in-memory database for unit tests");
TransactionFactory = new DefaultTransactionFactory(
() => new SQLiteConnection(
"Data Source=:memory:;Version=3;New=True;Pooling=True;Max Pool Size=1;foreign_keys = ON"),
DefaultTransactionFactory.DbSqllite);
}
var transaction = TransactionFactory.CreateTransaction();
Assert.IsNotNull(transaction);
Connection = transaction.Connection;
Assert.IsNotNull(Connection);
}
catch (System.Exception ex)
{
LogManager.GetLogger(TestClass).Fatal(string.Format("Exception during database {0} startup.", dbName), ex);
}
}
public CreateRootTransactionMode(bool autoCommit, ITransactionFactory transactionFactory)
{
ArgumentUtility.CheckNotNull("transactionFactory", transactionFactory);
_autoCommit = autoCommit;
_transactionFactory = transactionFactory;
}
private static IReliableDispatcher <object> CreateReliableDispatcher(
IReliableQueue <object> reliableQueue = null,
ITransactionFactory transactionFactory = null)
{
return(new ReliableDispatcher <object>(
new Lazy <IReliableQueue <object> >(() => reliableQueue ?? Substitute.For <IReliableQueue <object> >()),
transactionFactory ?? Substitute.For <ITransactionFactory>()));
}
public AccountServiceShould()
{
_transactionRepository = Substitute.For<ITransactionRepository>();
_transactionFactory = Substitute.For<ITransactionFactory>();
_statementPrinter = Substitute.For<IStatementPrinter>();
_accountService = new AccountService(_transactionRepository, _transactionFactory, _statementPrinter);
}
public ReservationService(IProductRepository productRepository,
IBasketRepository basketRepository,
ITransactionFactory transactionFactory)
{
_productRepository = productRepository;
_basketRepository = basketRepository;
_transactionFactory = transactionFactory;
}
public OrderService(IBasketRepository basketRepository,
IOrderRepository orderRepository,
ITransactionFactory transactionFactory)
{
_basketRepository = basketRepository;
_orderRepository = orderRepository;
_transactionFactory = transactionFactory;
}
public Transaction(ITransactionFactory factory, IDbTransaction transaction)
{
this._transactionId = Guid.NewGuid();
this._factory = factory;
this._transaction = transaction;
this._connection = transaction.Connection;
this._dbGate = factory.DbGate;
}
public AccountServiceShould()
{
_transactionRepository = Substitute.For <ITransactionRepository>();
_transactionFactory = Substitute.For <ITransactionFactory>();
_statementPrinter = Substitute.For <IStatementPrinter>();
_accountService = new AccountService(_transactionRepository, _transactionFactory, _statementPrinter);
}
public AuthenticationService(
ISettings settings,
ITransactionFactory transactionFactory,
IUnitOfWorkFactory unitOfWorkFactory)
: base(unitOfWorkFactory, transactionFactory)
{
_settings = settings;
}
public ReliableDispatcher(Lazy <IReliableQueue <T> > reliableQueue, ITransactionFactory transactionFactory)
{
Requires.IsNotNull(reliableQueue, nameof(reliableQueue));
Requires.IsNotNull(transactionFactory, nameof(transactionFactory));
_reliableQueue = reliableQueue;
_transactionFactory = transactionFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="UndoManager"/> class.
/// </summary>
/// <param name="transactionFactory">The transaction factory.</param>
/// <exception cref="ArgumentNullException"><paramref name="transactionFactory"/> is a <see langword="null"/> reference.</exception>
public UndoManager(ITransactionFactory transactionFactory)
{
if (transactionFactory == null)
{
throw new ArgumentNullException("transactionFactory");
}
this.transactionFactory = transactionFactory;
}
public AccountService(
ITransactionRepository transactionRepository,
ITransactionFactory transactionFactory,
IStatementPrinter statementPrinter)
{
_transactionRepository = transactionRepository;
_transactionFactory = transactionFactory;
_statementPrinter = statementPrinter;
}
public AccountServiceShould()
{
transactionFactory = A.Fake <ITransactionFactory>();
transactionRepository = A.Fake <ITransactionRepository>();
accountService = new AccountService(
transactionFactory,
transactionRepository
);
}
public OrderShipper(ITransactionFactory factory)
{
if (factory == null)
{
throw new ArgumentNullException("factory");
}
_transactionFactory = factory;
}
public AccountService(
ITransactionRepository transactionRepository,
ITransactionFactory transactionFactory,
IStatementPrinter statementPrinter)
{
_transactionRepository = transactionRepository;
_transactionFactory = transactionFactory;
_statementPrinter = statementPrinter;
}
public TransactionHandler(
IEntityRepository<IEndowmentEntity> entityRepository,
ITransactionRepository transactionRepository,
ITransactionFactory transactionFactory)
{
_entityRepository = entityRepository;
_transactionRepository = transactionRepository;
_transactionFactory = transactionFactory;
}
public GetProjectInformationCommand(ITransactionFactory transactionFactory,
IExceptionHandler exceptionHandler,
ExecutionContext executionContext,
ICommandResultVisualizer commandResultVisualizer,
IEntityFactory entityFactory, IProjectPropertiesProvider propertiesProvider)
: base(transactionFactory, exceptionHandler, executionContext, commandResultVisualizer, true)
{
this.entityFactory = entityFactory;
this.propertiesProvider = propertiesProvider;
}
public void Setup()
{
mapper = AutoMapperFactory.CreateMapper();
recipeRepository = A.Fake <IRecipeRepository>();
transactionFactory = A.Fake <ITransactionFactory>();
transaction = A.Fake <IDbTransaction>();
A.CallTo(() => transactionFactory.BeginTransaction()).Returns(transaction);
sut = new RecipeService(recipeRepository, mapper, transactionFactory);
}
public async Task ShouldCreateANewTransaction(
[Frozen, Substitute] ITransactionFactory transactionFactory,
[Target] DefaultRequestWorker worker,
CancellationToken cancellationToken
)
{
await worker.Run(cancellationToken);
transactionFactory.Received().CreateTransaction();
}
public ConnectionsService(ICommandsTransportResource resource,
ITransactionFactory transactionFactory,
IUserRepository userRepository,
ICommandSerializer serializer)
: base(transactionFactory)
{
_userRepository = userRepository;
_serializer = serializer;
resource.Received += _resource_OnReceived;
_timer = new Timer(OnTimerTick, null, TimerInterval);
}
public ProfileService(
IUnitOfWorkFactory unitOfWorkFactory,
IFileStorage fileStorage,
ISessionManager sessionManager,
ProfileChangesNotificator profileChangesNotificator,
ITransactionFactory transactionFactory)
: base(unitOfWorkFactory, transactionFactory)
{
_fileStorage = fileStorage;
_sessionManager = sessionManager;
_profileChangesNotificator = profileChangesNotificator;
}
public ChatService(
ISessionManager sessionManager,
ISettings settings,
ProfileChangesNotificator profileChangesNotificator,
ITransactionFactory transactionFactory,
IUnitOfWorkFactory unitOfWorkFactory,
IPushNotificator pushNotificator)
: base(unitOfWorkFactory, transactionFactory)
{
_sessionManager = sessionManager;
_settings = settings;
_profileChangesNotificator = profileChangesNotificator;
_pushNotificator = pushNotificator;
_sessionManager.AuthenticatedUserConnected += SessionManagerOnAuthenticatedUserConnected;
_sessionManager.AuthenticatedUserDisconnected += SessionManagerOnAuthenticatedUserDisconnected;
}
public BlacklistService(IUnitOfWorkFactory unitOfWorkFactory,
ITransactionFactory transactionFactory)
: base(unitOfWorkFactory, transactionFactory)
{
}
public static void Withdrawal(IBank localBank, IInputOutput io, ITransactionFactory transactionFactory)
{
throw new NotImplementedException();
}
public RegistrationService(
ITransactionFactory transactionFactory,
IUnitOfWorkFactory unitOfWorkFactory) : base(unitOfWorkFactory, transactionFactory)
{
}
public UsersSearchService(IUnitOfWorkFactory unitOfWorkFactory,
ITransactionFactory transactionFactory)
: base(unitOfWorkFactory, transactionFactory)
{
}
public FriendsService(IUnitOfWorkFactory unitOfWorkFactory,
ITransactionFactory transactionFactory)
: base(unitOfWorkFactory, transactionFactory)
{
}
public Deployer(ITransactionFactory transactionFactory, IOperationFactory operationFactory)
{
this.transactionFactory = transactionFactory;
this.operationFactory = operationFactory;
}
public Bank(ITransactionFactory transactionFactory, IAccountFactory accountFactory)
{
throw new System.NotImplementedException();
}
//public IUnitOfWorkFactory UnitOfWorkFactory { get; set; }
protected AppService(ITransactionFactory transactionFactory)
{
TransactionFactory = transactionFactory;
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultTransactionManager"/> class.
/// </summary>
/// <param name="transactionFactory">The transaction factory.</param>
public DefaultTransactionManager(ITransactionFactory transactionFactory)
{
Contract.Require.That(transactionFactory, Is.Not.Null).When("retrieving transactionFactory session in DefaultTransactionManager constructor.");
this.transactionFactory = transactionFactory;
}
