/// <summary>
/// To create a rule for the event of order fully matching.
/// </summary>
/// <param name="order">The order to be traced for the fully matching event.</param>
/// <param name="provider">The transactional provider.</param>
/// <returns>Rule.</returns>
public static MarketRule <Order, Order> WhenMatched(this Order order, ITransactionProvider provider)
{
return(new ChangedOrNewOrderRule(order, provider, o => o.IsMatched())
{
Name = LocalizedStrings.Str1038
}.Once());
}
/// <summary>
/// Begins the transaction with the specified isolation level and timeout in seconds.
/// </summary>
/// <param name="isolationLevel">The isolation level.</param>
/// <param name="timeout">The timeout in seconds.</param>
public static void Begin(IsolationLevel isolationLevel, TimeSpan timeout)
{
if (IsActive)
{
throw new InvalidOperationException(); // Transaction is already Active (Parallel transactions msg..).
}
ITransactionProvider tran = null;
try
{
tran = CommonComponents.TransactionFactory?.CreateTransaction();
if (tran == null)
{
// Transactions are not supported at the current provider.
_notSupported = true;
return;
}
tran.Begin(isolationLevel, timeout);
}
catch // rethrow
{
if (tran != null)
{
tran.Dispose();
}
throw;
}
SnTrace.Database.Write("Transaction BEGIN: {0}.", tran.Id);
ContextHandler.SetTransaction(tran);
OnBeginTransaction(tran, EventArgs.Empty);
}
static IEnumerable<Transaction> ReadAllTransactionsFromDirectory(string directory)
{
var dataProviders = new ITransactionProvider[] {
new BoACreditCsvDataProvider(),
new BoADebitCsvDataProvider(),
new ChaseCreditCsvDataProvider()
};
var transactions = new List<Transaction>();
var fileUniqueness = new FileContentUniqueness();
foreach (var file in Directory.EnumerateFiles(directory, "*.csv"))
{
var fileContent = File.ReadAllText(file);
if (!fileUniqueness.IsUnique(fileContent))
{
throw new Exception($"{file} has same content as some other file");
}
var dataProvider = dataProviders.First(provider => provider.FormatSupported(fileContent));
transactions.AddRange(dataProvider.GetTransactions(fileContent));
}
return transactions;
}
public AdoNetDatabaseProvider(IConnectionProvider connectionProvider, ITransactionProvider transactionProvider,
IConfiguration configuration)
{
_configuration = configuration;
_connectionProvider = connectionProvider;
_transactionProvider = transactionProvider;
}
public CommandDeleteMission(TreeView trv, Engine engine, ITransactionProvider transactionProvider)
{
//_getCurrentNodeFunc = getCurrentNodeFunc;
//_trv = trv;
_engine = engine;
_transactionProvider = transactionProvider;
}
/// <summary>
/// Commits the transaction.
/// </summary>
public static void Commit()
{
if (_notSupported)
{
return;
}
ITransactionProvider tran = ContextHandler.GetTransaction();
if (tran == null) // !IsActive
{
throw new InvalidOperationException(); // Transaction is not Active.
}
try
{
tran.Commit();
var queue = ContextHandler.GetTransactionQueue();
if (queue != null)
{
queue.Commit();
}
OnCommitTransaction(tran, EventArgs.Empty);
}
finally
{
ContextHandler.SetTransaction(null);
ContextHandler.SetTransactionQueue(null);
tran.Dispose();
}
}
public ProductController(ITransactionProvider transactionProvider, IMapper mapper, IProductService service, IProductInfoService productInfoService)
{
this._transactionProvider = transactionProvider;
this._mapper = mapper;
this._service = service;
this._productInfoService = productInfoService;
}
/// <summary>
/// Commits the transaction.
/// </summary>
public static void Commit()
{
if (_notSupported)
{
return;
}
ITransactionProvider tran = ContextHandler.GetTransaction();
if (tran == null) // !IsActive
{
throw new InvalidOperationException(); // Transaction is not Active.
}
try
{
tran.Commit();
var queue = ContextHandler.GetTransactionQueue();
if (queue != null)
{
queue.Commit();
}
OnCommitTransaction(tran, EventArgs.Empty);
}
finally
{
Logger.WriteVerbose("Transaction: " + tran.Id + " COMMIT. Running time: " + (DateTime.UtcNow - tran.Started));
ContextHandler.SetTransaction(null);
ContextHandler.SetTransactionQueue(null);
tran.Dispose();
}
}
/// <summary>
/// Begins the transaction with the specified isolation level.
/// </summary>
/// <param name="isolationLevel">The isolation level.</param>
public static void Begin(IsolationLevel isolationLevel)
{
if (IsActive)
{
throw new InvalidOperationException(); // Transaction is already Active (Parallel transactions msg..).
}
ITransactionProvider tran = null;
try
{
tran = DataProvider.Current.CreateTransaction();
if (tran == null)
{
// Transactions are not supported at the current provider.
_notSupported = true;
return;
}
tran.Begin(isolationLevel);
}
catch //rethrow
{
if (tran != null)
{
tran.Dispose();
}
throw;
}
Logger.WriteVerbose("Transaction: " + tran.Id + " BEGIN.");
ContextHandler.SetTransaction(tran);
OnBeginTransaction(tran, EventArgs.Empty);
}
static Program()
{
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
var config = new ConfigurationBuilder()
.AddJsonFile("network-config.json")
.Build();
var settings = new RpcSettings()
{
Url = config["url"],
User = config["user"],
Password = config["password"]
};
var options = new ApplicationSettings <RpcSettings>()
{
Value = settings
};
_client = new Client(settings, _logger);
_transactionProvider = new TransactionProvider(options, _logger);
}
public CategoryController(ITransactionProvider transactionProvider, IMapper mapper,
ICategoryService service)
{
_transactionProvider = transactionProvider;
_mapper = mapper;
_service = service;
}
public RecipeController(ITransactionProvider transactionProvider, IMapper mapper,
IRecipeService service, IProductService productService)
{
_transactionProvider = transactionProvider;
_mapper = mapper;
_service = service;
_productService = productService;
}
public PresenterA(IDao<Movie> movieDao,
IDao<Book> bookDao,
ITransactionProvider transactionProvider)
{
_movieDao = movieDao;
_bookDao = bookDao;
_transactionProvider = transactionProvider;
}
public Migrator(IScriptProvider scriptProvider, IScriptApplicator scriptApplicator,
IMetadataProvider metadataProvider, ITransactionProvider transactionProvider)
{
_scriptProvider = scriptProvider;
_scriptApplicator = scriptApplicator;
_metadataProvider = metadataProvider;
_transactionProvider = transactionProvider;
}
public static void ExecuteInTransaction(this ITransactionProvider transactionProvider, Action action)
{
using (ITransaction transaction = transactionProvider.BeginTransaction())
{
action();
transaction.Commit();
}
}
public QuestionsRepository(
NpgsqlConnection connection,
ITransactionProvider transactionProvider,
SchemaProvider schemaProvider)
{
_connection = connection;
_transactionProvider = transactionProvider;
_schemaProvider = schemaProvider;
}
public MigrationRunner(IMigrationFactoryChooser migrationFactoryChooser, IMigrationInitializer migrationInitializer,
ISchemaStateManager schemaStateManager, IConfiguration configuration, ITransactionProvider transactionProvider)
{
_schemaStateManager = schemaStateManager;
_transactionProvider = transactionProvider;
_configuration = configuration;
_migrationInitializer = migrationInitializer;
_migrationFactoryChooser = migrationFactoryChooser;
}
public ChangedOrNewOrderRule(Order order, ITransactionProvider provider, Func <Order, bool> condition)
: base(order, provider)
{
_condition = condition ?? throw new ArgumentNullException(nameof(condition));
Name = LocalizedStrings.Str1031;
TrySubscribe();
}
public InstallService(IOptionService optionService, IUserService userService, iBlogsContext blogsContext, ITransactionProvider transactionProvider, IContentsService contentsService, IMetasService metasService)
{
_optionService = optionService;
_userService = userService;
_blogsContext = blogsContext;
_transactionProvider = transactionProvider;
_contentsService = contentsService;
_metasService = metasService;
}
public MigrationRunner(IMigrationFactoryChooser migrationFactoryChooser, IMigrationInitializer migrationInitializer,
ISchemaStateManager schemaStateManager, IConfiguration configuration, ITransactionProvider transactionProvider)
{
_schemaStateManager = schemaStateManager;
_transactionProvider = transactionProvider;
_configuration = configuration;
_migrationInitializer = migrationInitializer;
_migrationFactoryChooser = migrationFactoryChooser;
}
public DatabaseInitializer(
NpgsqlConnection connection,
ITransactionProvider transactionProvider,
SchemaProvider schemaProvider)
{
_connection = connection;
_transactionProvider = transactionProvider;
_schemaProvider = schemaProvider;
}
public TransactionCrawler(ITransactionProvider transactionProvider,
Repository <Transaction> transactionRepository,
Repository <TransactionMetadata> transactionMetadataRepository)
{
_transactionProvider = transactionProvider;
_transactionRepository = transactionRepository;
_transactionDownloader = new TransactionDownloader(transactionProvider, _transactionRepository);
_transactionDiscoverer = new TransactionDiscoverer(Inbox);
_transactionMetadataDownloader = new TransactionMetadataDownloader(transactionMetadataRepository);
}
public TransactionViewModelBuilder(
ITransactionRequestBuilder transactionRequestBuilder,
ITransactionProvider transactionProvider)
{
Condition.Requires(transactionRequestBuilder, nameof(transactionRequestBuilder)).IsNotNull();
Condition.Requires(transactionProvider, nameof(transactionProvider)).IsNotNull();
_transactionRequestBuilder = transactionRequestBuilder;
_transactionProvider = transactionProvider;
}
public RoleProcessingService(IMapper mapper, IRoleService roleService, ITransactionProvider transactionProvider, IRepository <UserRole> userRoleRepository, IUserRoleService userRoleService, INotificationService notificationService, IEventPublisher eventPublisher)
{
_mapper = mapper;
_roleService = roleService;
_transactionProvider = transactionProvider;
_userRoleRepository = userRoleRepository;
_userRoleService = userRoleService;
_notificationService = notificationService;
_eventPublisher = eventPublisher;
}
public ProductController(ITransactionProvider transactionProvider, IMapper mapper,
IProductService service,
ICategoryService categoryService,
IResourceService resourceService)
{
_transactionProvider = transactionProvider;
_mapper = mapper;
_service = service;
_resourceService = resourceService;
_categoryService = categoryService;
}
public BlockAdapter(ITransactionProvider transactionProvider)
{
_transactionProvider = transactionProvider;
var settings = new BitcoinNinjaSettings()
{
Network = AppSettings.Network,
UrlMain = AppSettings.SqlNinjaUrlMain,
UrlTest = AppSettings.SqlNinjaUrlTest
};
_client = new BitcoinNinjaClient(settings);
}
/// <summary>
/// To create a rule for the event of successful order registration on exchange.
/// </summary>
/// <param name="order">The order to be traced for the event of successful registration.</param>
/// <param name="provider">The transactional provider.</param>
/// <returns>Rule.</returns>
public static MarketRule <Order, Order> WhenRegistered(this Order order, ITransactionProvider provider)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
return(new ChangedOrNewOrderRule(order, provider, o => o.State == OrderStates.Active || o.State == OrderStates.Done)
{
Name = LocalizedStrings.Str1034
}.Once());
}
/// <summary>
/// Reregister the order.
/// </summary>
/// <param name="provider">The transactional provider.</param>
/// <param name="oldOrder">Changing order.</param>
/// <param name="price">Price of the new order.</param>
/// <param name="volume">Volume of the new order.</param>
/// <returns>New order.</returns>
public static Order ReRegisterOrder(this ITransactionProvider provider, Order oldOrder, decimal price, decimal volume)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
var newOrder = oldOrder.ReRegisterClone(price, volume);
provider.ReRegisterOrder(oldOrder, newOrder);
return(newOrder);
}
public ActiveDirectoryBll(IBaseDal <SUBJEKTU_ASMENYS> subjektuAsmenysDal, IBaseDal <AD_DOMAINS> adDomainsDal, IBaseDal <SUBJEKTAI> subjektaiDal,
IBaseDal <SUBJEKTU_ASMENU_ISTORIJA> subjektuAsmenuIstorijaDal, ITransactionProvider transactionProvider, IDabartinisNaudotojasBll dabartinisNaudotojasBll,
ITerminuNustatymaiBll terminuNustatymaiBll)
{
_subjektuAsmenysDal = subjektuAsmenysDal;
_adDomainsDal = adDomainsDal;
_subjektaiDal = subjektaiDal;
_subjektuAsmenuIstorijaDal = subjektuAsmenuIstorijaDal;
_transactionProvider = transactionProvider;
_dabartinisNaudotojasBll = dabartinisNaudotojasBll;
_terminuNustatymaiBll = terminuNustatymaiBll;
}
public CreateBudgetTransaction(IBudgetPlannerService budgetPlannerService,
IMapperProvider mapperProvider,
ITransactionService transactionService,
ITransactionProvider transactionProvider,
ITransactionLedgerService transactionLedgerService)
{
_budgetPlannerService = budgetPlannerService;
_mapperProvider = mapperProvider;
_transactionService = transactionService;
_transactionProvider = transactionProvider;
_transactionLedgerService = transactionLedgerService;
}
public ChainProvider(ITransactionProvider transactionProvider,
IBlockProvider blockProvider,
IAddressProvider addressProvider,
IInfoAdapter infoAdapter,
ILoggerFactory loggerFactory)
{
_transactionProvider = transactionProvider;
_blockProvider = blockProvider;
_addressProvider = addressProvider;
_infoAdapter = infoAdapter;
_log = loggerFactory.CreateLogger(GetType());
}
protected BaseService(BaseServiceDependencies dependencies)
{
if (dependencies == null)
{
throw new ArgumentNullException("dependencies", "Dependencies should be resolved");
}
dependencies.EnsureIsResolved();
_objectFactory = dependencies.ObjectFactory;
_operationProvider = dependencies.OperationProvider;
_bus = dependencies.ServiceBus;
_unitOfWork = dependencies.UnitOfWork;
_transactionProvider = dependencies.TransactionProvider;
_settings = dependencies.Settings;
}
public ResourceRepository(ITransactionProvider transactionProvider, IDatabaseProvider databaseProvider) : base(
transactionProvider, databaseProvider)
{
var options = new CreateIndexOptions()
{
Unique = true
};
var field = new StringFieldDefinition <Resource>("ProductName");
var indexDefinition = new IndexKeysDefinitionBuilder <Resource>().Ascending(field);
var indexModel = new CreateIndexModel <Resource>(indexDefinition, options);
GetCollection <Resource>("resource").Indexes.CreateOneAsync(indexModel);
}
public VaBankContext(IConnectionProvider connectionProvider, ITransactionProvider transactionProvider)
: base(connectionProvider.Connection, true)
{
if (transactionProvider == null)
{
throw new ArgumentNullException("transactionProvider", "Transaction provider is null");
}
if (transactionProvider.HasCurrentTransaction)
{
Database.UseTransaction(transactionProvider.CurrentTransaction);
}
_transactionProvider = transactionProvider;
transactionProvider.TransactionStarted += OnTransactionStarted;
Database.SetInitializer(new NullDatabaseInitializer<VaBankContext>());
}
//
public AccountController(IUserLogic userLogic, ITransactionProvider transactionProvider)
{
_userLogic = userLogic;
_transactionProvider = transactionProvider;
}
public TriggeredEventController(IEventLogic eventLogic, ITransactionProvider transactionProvider)
{
_eventLogic = eventLogic;
_transactionProvider = transactionProvider;
}
internal static void SetTransaction(ITransactionProvider transaction)
{
SetObject(TransactionIdent, transaction);
}
