public StandardTransaction(TransactionDelegate onTransactionCommitted, TransactionDelegate onTransactionRolledback, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) : this(transactionMode, isolationMode, distributedTransaction) { this.onTransactionCommitted = onTransactionCommitted; this.onTransactionRolledback = onTransactionRolledback; }
/// <summary> /// Processes the Authorize and AuthorizeAndCapture transactions /// </summary> /// <param name="invoice">The <see cref="IInvoice" /> to be paid</param> /// <param name="payment">The <see cref="IPayment" /> record</param> /// <param name="transactionMode">Authorize or AuthorizeAndCapture</param> /// <param name="amount">The money amount to be processed</param> /// <returns>The <see cref="IPaymentResult" /></returns> public IPaymentResult ProcessPayment(IInvoice invoice, IPayment payment, TransactionMode transactionMode, decimal amount) { if (!IsValidCurrencyCode(invoice.CurrencyCode())) return new PaymentResult(Attempt<IPayment>.Fail(payment, new Exception(string.Format("Invalid currency. Invoice Currency: '{0}'", invoice.CurrencyCode()))), invoice, false); if (transactionMode == TransactionMode.Authorize) { //var paymentId = payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.QuickpayPaymentId); var currency = payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.PaymentCurrency); var amountAuthorizedMinorString = payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.PaymentAmount); var amountAuthorized = decimal.Parse(amountAuthorizedMinorString) / (IsZeroDecimalCurrency(currency) ? 100 : 1); if (invoice.CurrencyCode() != currency) { return new PaymentResult(Attempt<IPayment>.Fail(payment, new Exception(string.Format("Currency mismatch. Invoice Currency: {0}, Payment Currency: {1}", invoice.CurrencyCode(), currency))), invoice, false); } if (invoice.Total > amountAuthorized) { return new PaymentResult(Attempt<IPayment>.Fail(payment, new Exception(string.Format("Amount mismatch. Invoice Amount: {0}, Payment Amount: {1}", invoice.Total.ToString("F2"), amountAuthorized.ToString("F2")))), invoice, false); } payment.Authorized = true; return new PaymentResult(Attempt<IPayment>.Succeed(payment), invoice, invoice.ShippingLineItems().Any()); } return new PaymentResult(Attempt<IPayment>.Fail(payment, new Exception(string.Format("{0}", "QuickPay Payment AuthorizeAndCapture Not Implemented Yet"))), invoice, false); }
private IPaymentResult ProcessPayment(IInvoice invoice, TransactionMode transactionMode, decimal amount, ProcessorArgumentCollection args) { var po = args.AsPurchaseOrderFormData(); var payment = GatewayProviderService.CreatePayment(PaymentMethodType.PurchaseOrder, invoice.Total, PaymentMethod.Key); payment.CustomerKey = invoice.CustomerKey; payment.Authorized = false; payment.Collected = false; payment.PaymentMethodName = "Purchase Order"; var result = _processor.ProcessPayment(invoice, payment, amount, po); GatewayProviderService.Save(payment); if (!result.Payment.Success) { GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, result.Payment.Exception.Message, 0); } else { MerchelloContext.Current.Services.InvoiceService.Save(invoice, false); GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.AuthorizationTransactionResult) + (transactionMode == TransactionMode.AuthorizeAndCapture ? string.Empty : " to show record of Authorization"), transactionMode == TransactionMode.AuthorizeAndCapture ? invoice.Total : 0); } return result; }
private IPaymentResult ProcessPayment(IInvoice invoice, TransactionMode transactionMode, decimal amount, ProcessorArgumentCollection args) { var cc = args.AsCreditCardFormData(); var payment = GatewayProviderService.CreatePayment(PaymentMethodType.CreditCard, invoice.Total, PaymentMethod.Key); payment.CustomerKey = invoice.CustomerKey; payment.Authorized = false; payment.Collected = false; payment.PaymentMethodName = string.Format("{0} Stripe Credit Card", cc.CreditCardType); payment.ExtendedData.SetValue(Constants.ExtendedDataKeys.CcLastFour, cc.CardNumber.Substring(cc.CardNumber.Length - 4, 4).EncryptWithMachineKey()); var result = _processor.ProcessPayment(invoice, payment, transactionMode, amount, cc); GatewayProviderService.Save(payment); if (!result.Payment.Success) { GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Denied, result.Payment.Exception.Message, 0); } else { GatewayProviderService.ApplyPaymentToInvoice(payment.Key, invoice.Key, AppliedPaymentType.Debit, //payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.AuthorizationTransactionResult) + (transactionMode == TransactionMode.AuthorizeAndCapture ? string.Empty : " to show record of Authorization"), transactionMode == TransactionMode.AuthorizeAndCapture ? invoice.Total : 0); } return result; }
public int Hurl(string storedProcedureName, System.Collections.Generic.List<dynamic> objects, TransactionMode transMode) { // This has slightly different logic because we need to scope the transaction differently. int numberOfRecordsAffected = 0; SqlTransaction transaction = null; using (SqlConnection dbConn = new SqlConnection(this.ConnectionString)) { using (SqlCommand dbComm = new SqlCommand(storedProcedureName, dbConn) { CommandType = System.Data.CommandType.StoredProcedure }) { if (transMode == TransactionMode.On) { transaction = dbConn.BeginTransaction(); } foreach (dynamic obj in objects) { dbComm.Parameters.Clear(); string jsonString = JsonConvert.SerializeObject(obj); dbComm.Parameters.AddRange(jsonString.DeserializeJsonIntoSqlParameters()); if (dbConn.State != System.Data.ConnectionState.Open) { dbConn.Open(); } numberOfRecordsAffected += dbComm.ExecuteNonQuery(); } if (transaction != null) { transaction.Commit(); } } } return numberOfRecordsAffected; }
private void OnNewTransaction(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) { if (!transaction.DistributedTransaction) { transaction.Enlist(new RhinoTransactionResourceAdapter(transactionMode)); } }
protected TransactionBase(string name, TransactionMode mode, IsolationMode isolationMode) { theName = name ?? string.Empty; _TransactionMode = mode; _IsolationMode = isolationMode; Status = TransactionStatus.NoTransaction; Context = new Hashtable(); }
public ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) { _current = new MockTransaction(); _transactions++; return _current; }
public ITransaction BeginTransaction(IsolationLevel isolationLevel, TransactionMode mode) { Guard.Against<InvalidOperationException>(Transaction != null, "There is a active transcation, cannot begin a new transaction."); var scope = TransactionScopeHelper.CreateScope(isolationLevel, mode); var transaction = new UnitOfWorkTransaction(this, scope); return transaction; }
///<summary> /// Create a new <typeparamref name="TransactionScope"/> using the supplied parameters. ///</summary> ///<param name="isolationLevel"></param> ///<param name="txMode"></param> ///<returns></returns> ///<exception cref="NotImplementedException"></exception> public static TransactionScope CreateScope(IsolationLevel isolationLevel, TransactionMode txMode) { if (txMode == TransactionMode.New) { Logger.Debug(x => x("Creating a new TransactionScope with TransactionScopeOption.RequiresNew")); return new TransactionScope(TransactionScopeOption.RequiresNew, new TransactionOptions { IsolationLevel = isolationLevel }); } if (txMode == TransactionMode.Supress) { Logger.Debug(x => x("Creating a new TransactionScope with TransactionScopeOption.Supress")); return new TransactionScope(TransactionScopeOption.Suppress); } Logger.Debug(x => x("Creating a new TransactionScope with TransactionScopeOption.Required")); return new TransactionScope(TransactionScopeOption.Required, new TransactionOptions { IsolationLevel = isolationLevel }); }
public ITransaction CreateTransaction(TransactionMode txMode, IsolationMode iMode, bool isAmbient, bool isReadOnly) { txMode = ObtainDefaultTransactionMode(txMode); AssertModeSupported(txMode); if (CurrentTransaction == null && (txMode == TransactionMode.Supported || txMode == TransactionMode.NotSupported)) { return null; } TransactionBase transaction = null; if (CurrentTransaction != null) { if (txMode == TransactionMode.Requires || txMode == TransactionMode.Supported) { transaction = ((TransactionBase)CurrentTransaction).CreateChildTransaction(); logger.DebugFormat("Child transaction \"{0}\" created with mode '{1}'.", transaction.Name, txMode); } } if (transaction == null) { transaction = InstantiateTransaction(txMode, iMode, isAmbient, isReadOnly); if (isAmbient) { #if MONO throw new NotSupportedException("Distributed transactions are not supported on Mono"); #else transaction.CreateAmbientTransaction(); #endif } logger.DebugFormat("Transaction \"{0}\" created. ", transaction.Name); } activityManager.CurrentActivity.Push(transaction); if (transaction.IsChildTransaction) ChildTransactionCreated.Fire(this, new TransactionEventArgs(transaction)); else TransactionCreated.Fire(this, new TransactionEventArgs(transaction)); return transaction; }
internal static string BeginTransactionWithMode(TransactionMode mode) { switch (mode) { case TransactionMode.Deferred: return "BEGIN DEFERRED TRANSACTION"; case TransactionMode.Exclusive: return "BEGIN EXCLUSIVE TRANSACTION"; case TransactionMode.Immediate: return "BEGIN IMMEDIATE TRANSACTION"; default: throw new ArgumentException("Not a valid TransactionMode"); } }
public override void BeginThreadTransaction(TransactionMode mode) { if (mode != TransactionMode.ReplicationSlave) { throw new ArgumentException("Illegal transaction mode"); } lck.SharedLock(); Page pg = pool.getPage(0); header.unpack(pg.data); pool.unfix(pg); currIndex = 1 - header.curr; currIndexSize = header.root[1 - currIndex].indexUsed; committedIndexSize = currIndexSize; usedSize = header.root[currIndex].size; }
public AbstractTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction, string name) : this() { this.transactionMode = transactionMode; this.isolationMode = isolationMode; this.distributedTransaction = distributedTransaction; if (String.IsNullOrEmpty(name)) { this.name = ObtainName(); } else { this.name = name; } }
public FileBasedPersistentSource(string basePath, string prefix, TransactionMode transactionMode) { SyncLock = new object(); this.basePath = basePath; this.prefix = prefix; this.transactionMode = transactionMode; dataPath = Path.Combine(basePath, prefix + ".data"); logPath = Path.Combine(basePath, prefix + ".log"); RecoverFromFailedRename(dataPath); RecoverFromFailedRename(logPath); CreatedNew = File.Exists(logPath) == false; OpenFiles(); }
/// <summary> /// Creates a context with an optionally open database and SMTP connection. /// </summary> /// <param name="openConnection">True if a database connection should be opened.</param> /// <param name="beginTransaction">True if a transaction is required.</param> /// <param name="openSmtp">True if an SMTP connection should be opened.</param> /// <returns>A valid connection.</returns> public Context CreateContext(ConnectionMode connectionMode, TransactionMode transactionMode) { var context = new Context() { ConnectionString = connectionString, ConnectionMode = connectionMode, TransactionMode = transactionMode, UserGuid = userGuid, UserName = userName, }; context.ClusterProperty.Name = clusterName; context.DomainProperty.Name = domainName; context.FederationProperty.Name = federationName; return context; }
/// <summary> /// Processes the Authorize and AuthorizeAndCapture transactions /// </summary> /// <param name="invoice">The <see cref="IInvoice" /> to be paid</param> /// <param name="payment">The <see cref="IPayment" /> record</param> /// <param name="transactionMode">Authorize or AuthorizeAndCapture</param> /// <param name="amount">The money amount to be processed</param> /// <param name="creditCard">The <see cref="CreditCardFormData" /></param> /// <returns>The <see cref="IPaymentResult" /></returns> public IPaymentResult ProcessPayment(IInvoice invoice, IPayment payment, TransactionMode transactionMode, decimal amount, CreditCardFormData creditCard) { if (!IsValidCurrencyCode(invoice.CurrencyCode())) return new PaymentResult(Attempt<IPayment>.Fail(payment, new Exception("Invalid currency")), invoice, false); // The minimum amount is $0.50 (or equivalent in charge currency). // Test that the payment meets the minimum amount (for USD only). if (invoice.CurrencyCode() == "USD") { if (amount < 0.5m) return new PaymentResult( Attempt<IPayment>.Fail(payment, new Exception("Invalid amount (less than 0.50 USD)")), invoice, false); } else { if (amount < 1) return new PaymentResult( Attempt<IPayment>.Fail(payment, new Exception("Invalid amount (less than 1 " + invoice.CurrencyCode() + ")")), invoice, false); } var requestParams = StripeHelper.PreparePostDataForProcessPayment(invoice.GetBillingAddress(), transactionMode, ConvertAmount(invoice, amount), invoice.CurrencyCode(), creditCard, invoice.PrefixedInvoiceNumber(), string.Format("Full invoice #{0}", invoice.PrefixedInvoiceNumber())); // https://stripe.com/docs/api#create_charge try { var response = StripeHelper.MakeStripeApiRequest("https://api.stripe.com/v1/charges", "POST", requestParams, _settings); return GetProcessPaymentResult(invoice, payment, response); } catch (WebException ex) { return GetProcessPaymentResult(invoice, payment, (HttpWebResponse) ex.Response); } }
/// <summary> /// Enlists a <see cref="UnitOfWorkScope"/> instance with the transaction manager, /// with the specified transaction mode. /// </summary> /// <param name="scope">The <see cref="IUnitOfWorkScope"/> to register.</param> /// <param name="mode">A <see cref="TransactionMode"/> enum specifying the transaciton /// mode of the unit of work.</param> public void EnlistScope(IUnitOfWorkScope scope, TransactionMode mode) { _logger.Info(string.Format("Enlisting scope {0} with transaction manager {1} with transaction mode {2}", scope.ScopeId, _transactionManagerId, mode)); var uowFactory = ServiceLocator.Current.GetInstance<IUnitOfWorkFactory>(); if (_transactions.Count == 0 || mode == TransactionMode.New || mode == TransactionMode.Supress) { _logger.Debug(string.Format("Enlisting scope {0} with mode {1} requires a new TransactionScope to be created.", scope.ScopeId, mode)); var txScope = TransactionScopeHelper.CreateScope(UnitOfWorkSettings.DefaultIsolation, mode); var unitOfWork = uowFactory.Create(); var transaction = new UnitOfWorkTransaction(unitOfWork, txScope); transaction.TransactionDisposing += OnTransactionDisposing; transaction.EnlistScope(scope); _transactions.AddFirst(transaction); return; } CurrentTransaction.EnlistScope(scope); }
/// <summary> /// Initializes a new instance of the <see cref="TransactionScope"/> class. /// </summary> public TransactionScope( TransactionMode mode = TransactionMode.New, IsolationLevel isolation = IsolationLevel.Unspecified, OnDispose ondispose = OnDispose.Commit, ISessionScope parent = null, ISessionFactoryHolder holder = null, IThreadScopeInfo scopeinfo = null ) : base(FlushAction.Config, isolation, ondispose, parent, holder, scopeinfo) { this.mode = mode; parentTransactionScope = ParentScope as TransactionScope; if (mode == TransactionMode.New) { if (parentTransactionScope != null) { parentTransactionScope = null; ParentScope = null; } else { parentTransactionScope = null; } } }
public int Hurl(string storedProcedureName, string jsonData, TransactionMode transMode) { int numberOfRecordsAffected = 0; SqlTransaction transaction = null; using (SqlConnection dbConn = new SqlConnection(this.ConnectionString)) { using (SqlCommand dbComm = new SqlCommand(storedProcedureName, dbConn) { CommandType = System.Data.CommandType.StoredProcedure }) { if (transMode == TransactionMode.On) { transaction = dbConn.BeginTransaction(); } dbComm.Parameters.AddRange(jsonData.DeserializeJsonIntoSqlParameters()); dbConn.Open(); numberOfRecordsAffected = dbComm.ExecuteNonQuery(); if (transaction != null) { transaction.Commit(); } } } return numberOfRecordsAffected; }
public async Task <int> HurlAsync(string storedProcedureName, string jsonData, TransactionMode transMode) { int numberOfRecordsAffected = 0; SqlTransaction transaction = null; using (SqlConnection dbConn = new SqlConnection(this.ConnectionString)) { using (SqlCommand dbComm = new SqlCommand(storedProcedureName, dbConn) { CommandType = System.Data.CommandType.StoredProcedure }) { if (transMode == TransactionMode.On) { transaction = dbConn.BeginTransaction(); } dbComm.Parameters.AddRange(jsonData.DeserializeJsonIntoSqlParameters()); dbConn.Open(); numberOfRecordsAffected = await dbComm.ExecuteNonQueryAsync(); if (transaction != null) { transaction.Commit(); } } } return(numberOfRecordsAffected); }
public async Task <int> HurlAsync(string storedProcedureName, System.Collections.Generic.List <dynamic> objects, TransactionMode transMode) { // This has slightly different logic because we need to scope the transaction differently. int numberOfRecordsAffected = 0; SqlTransaction transaction = null; using (SqlConnection dbConn = new SqlConnection(this.ConnectionString)) { using (SqlCommand dbComm = new SqlCommand(storedProcedureName, dbConn) { CommandType = System.Data.CommandType.StoredProcedure }) { if (transMode == TransactionMode.On) { transaction = dbConn.BeginTransaction(); } foreach (dynamic obj in objects) { dbComm.Parameters.Clear(); string jsonString = JsonConvert.SerializeObject(obj); dbComm.Parameters.AddRange(jsonString.DeserializeJsonIntoSqlParameters()); if (dbConn.State != System.Data.ConnectionState.Open) { dbConn.Open(); } numberOfRecordsAffected += await dbComm.ExecuteNonQueryAsync(); } if (transaction != null) { transaction.Commit(); } } } return(numberOfRecordsAffected); }
private void btnCancel_Click(object sender, EventArgs e) { //if transaction is cancelled, transaction mode should return to view mode Mode = TransactionMode.View; }
public int Hurl(string storedProcedureName, dynamic obj, TransactionMode transMode) { throw new NotImplementedException(); }
public async Task <int> HurlAsync(string storedProcedureName, dynamic obj, TransactionMode transMode) { return(await HurlAsync(storedProcedureName, JsonConvert.SerializeObject(obj), transMode)); }
public TalkactiveTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool isAmbient, bool isReadOnly) : base(null, transactionMode, isolationMode) { _IsAmbient = isAmbient; _IsReadOnly = isReadOnly; }
/// <summary> /// Insert the specified data. /// </summary> /// <param name="data">Data.</param> public virtual TData Insert(TData data, TransactionMode mode, IPrincipal principal) { if (data == null) { throw new ArgumentNullException(nameof(data)); } DataPersistingEventArgs <TData> preArgs = new DataPersistingEventArgs <TData>(data, mode, principal); this.Inserting?.Invoke(this, preArgs); if (preArgs.Cancel) { this.m_tracer.TraceWarning("Pre-Event handler indicates abort insert for {0}", data); return(data); } #if PERFMON Stopwatch sw = new Stopwatch(); sw.Start(); #endif // Persist objectel using (var context = this.CreateConnection(principal)) try { using (context.LockConnection()) { try { // Does this object already exist? if (data.Key.HasValue && this.Get(context, data.Key.Value) != null) { throw new DuplicateKeyException($"Object {typeof(TData).Name} with key {data.Key} already exists"); } this.m_tracer.TraceVerbose("INSERT {0}", data); context.Connection.BeginTransaction(); data = this.Insert(context, data); if (mode == TransactionMode.Commit) { context.Connection.Commit(); } else { context.Connection.Rollback(); } // Remove from the cache foreach (var itm in context.CacheOnCommit.AsParallel()) { ApplicationContext.Current.GetService <IDataCachingService>().Add(itm); } } catch (Exception e) { this.m_tracer.TraceError("Error : {0}", e); context.Connection.Rollback(); throw new LocalPersistenceException(SynchronizationOperationType.Insert, data, e); } } this.Inserted?.Invoke(this, new DataPersistedEventArgs <TData>(data, mode, principal)); return(data); } catch (SQLiteException e) { this.m_tracer.TraceError("Error inserting data {1} : {0}", e, context.Connection); throw new DataPersistenceException($"Database error inserting {data}", e); } catch (Exception e) { throw new DataPersistenceException($"Error inserting {data}", e); } #if PERFMON finally { sw.Stop(); ApplicationContext.Current.PerformanceLog(typeof(TData).Name, nameof(Insert), "Complete", sw.Elapsed); } #endif }
/// <summary> /// Create a resource /// </summary> public Resource Create(Resource target, TransactionMode mode) { throw new NotImplementedException(); }
/// <summary> /// Delete a resource /// </summary> public Resource Delete(string id, TransactionMode mode) { throw new NotImplementedException(); }
/// <summary> /// Constructs a new container instance using the given string as the name /// or connection string for the database to which a connection will be made. /// </summary> /// <param name="nameOrConnectionString"> /// Either the database name or a connection string. /// </param> /// <param name="transactionMode">The transaction behavior.</param> public EFUsersDomainContainer(string nameOrConnectionString, TransactionMode transactionMode) : base(nameOrConnectionString, transactionMode) { }
/// <summary> /// Constructs a new container instance using a given connection. /// </summary> /// <param name="connection">The connection to use.</param> /// <param name="ownTheConnection">If true, hand over connection ownership to the container.</param> /// <param name="transactionMode">The transaction behavior.</param> public EFUsersDomainContainer(System.Data.Common.DbConnection connection, bool ownTheConnection, TransactionMode transactionMode) : base(connection, ownTheConnection, transactionMode) { }
/// <summary> /// Constructs a new container instance using conventions to /// create the name of the database to which a connection will be made. /// The by-convention name is the full name (namespace + class name) /// of the derived container class. /// </summary> /// <param name="transactionMode">The transaction behavior.</param> public EFUsersDomainContainer(TransactionMode transactionMode) : base(transactionMode) { }
private void btnEdit_Click(object sender, EventArgs e) { //same with others Mode = TransactionMode.Edit; }
private void btnNew_Click(object sender, EventArgs e) { //upon clicking new the mode is in new hehe Mode = TransactionMode.New; }
/// <summary> /// Obsolete the specified identified data /// </summary> /// <param name="data">Data.</param> public virtual TData Obsolete(TData data, TransactionMode mode, IPrincipal principal) { if (data == null) { throw new ArgumentNullException(nameof(data)); } else if (!data.Key.HasValue || data.Key == Guid.Empty) { throw new InvalidOperationException("Data missing key"); } #if PERFMON Stopwatch sw = new Stopwatch(); sw.Start(); #endif DataPersistingEventArgs <TData> preArgs = new DataPersistingEventArgs <TData>(data, mode, principal); this.Obsoleting?.Invoke(this, preArgs); if (preArgs.Cancel) { this.m_tracer.TraceWarning("Pre-Event handler indicates abort for {0}", data); return(data); } // Obsolete object using (var context = this.CreateConnection(principal)) try { using (context.LockConnection()) { try { this.m_tracer.TraceVerbose("OBSOLETE {0}", data); context.Connection.BeginTransaction(); data = this.Obsolete(context, data); if (mode == TransactionMode.Commit) { context.Connection.Commit(); } else { context.Connection.Rollback(); } // Remove from the cache foreach (var itm in context.CacheOnCommit.AsParallel()) { ApplicationContext.Current.GetService <IDataCachingService>().Remove(itm.Key.Value); } } catch (Exception e) { this.m_tracer.TraceError("Error : {0}", e); context.Connection.Rollback(); throw new LocalPersistenceException(SynchronizationOperationType.Obsolete, data, e); } } this.Obsoleted?.Invoke(this, new DataPersistedEventArgs <TData>(data, mode, principal)); return(data); } catch (SQLiteException e) { this.m_tracer.TraceError("Error obsoleting data {1} : {0}", e, context.Connection); throw new DataPersistenceException($"Database error obsoleting {data}", e); } catch (Exception e) { throw new DataPersistenceException($"Error obsoleting {data}", e); } #if PERFMON finally { sw.Stop(); ApplicationContext.Current.PerformanceLog(typeof(TData).Name, nameof(Obsolete), "Complete", sw.Elapsed); } #endif }
/// <summary> /// Declares both the transaction mode and isolation /// desired for this method. The transaction manager should /// obey the declaration. /// </summary> /// <param name="transactionMode"></param> /// <param name="isolationMode"></param> public TransactionAttribute(TransactionMode transactionMode, IsolationMode isolationMode) { _transactionMode = transactionMode; _isolationMode = isolationMode; }
public OrderMarketRequest(string token, OrderStateCommand requestCommand, List <int> itemList, TransactionMode transactionMode) : base(token, requestCommand, itemList, transactionMode) { }
public RhinoTransactionResourceAdapter(TransactionMode transactionMode) { this.transactionMode = transactionMode; }
public void RunInTransaction(Action <IDatabaseConnection> action, TransactionMode mode) { _db.RunInTransaction(action, mode); }
public async Task <int> HurlAsync(string storedProcedureName, List <dynamic> objects, TransactionMode transMode) { throw new NotImplementedException(); }
/// <summary> /// Overloaded Constructor. /// Creates a new instance of the <see cref="UnitOfWorkScope"/> class. /// </summary> /// <param name="mode">A <see cref="TransactionMode"/> enum specifying the transation mode /// of the unit of work.</param> public UnitOfWorkScope(TransactionMode mode) { UnitOfWorkManager.CurrentTransactionManager.EnlistScope(this, mode); }
/// <summary> /// Factory method for creating a transaction. /// </summary> /// <param name="transactionMode">The transaction mode.</param> /// <param name="isolationMode">The isolation mode.</param> /// <param name="distributedTransaction">if set to <c>true</c>, the TM will create a distributed transaction.</param> /// <returns>A transaction</returns> protected virtual AbstractTransaction InstantiateTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) { return new StandardTransaction( new TransactionDelegate(RaiseTransactionCommitted), new TransactionDelegate(RaiseTransactionRolledback), new TransactionErrorDelegate(RaiseTransactionFailed), transactionMode, isolationMode, distributedTransaction); }
public int Hurl(string storedProcedureName, string jsonData, TransactionMode transMode) { throw new NotImplementedException(); }
protected virtual TransactionMode ObtainDefaultTransactionMode(TransactionMode transactionMode) { return TransactionMode.Requires; }
public int Hurl(string storedProcedureName, dynamic obj, TransactionMode transMode) { return(Hurl(storedProcedureName, JsonConvert.SerializeObject(obj), transMode)); }
/// <summary> /// Creates a transaction. /// </summary> /// <param name="transactionMode">The transaction mode.</param> /// <param name="isolationMode">The isolation mode.</param> /// <returns></returns> public virtual ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode) { return CreateTransaction(transactionMode, isolationMode, false); }
/// <summary> /// <see cref="ITransactionManager.CreateTransaction(Castle.Services.Transaction.TransactionMode,Castle.Services.Transaction.IsolationMode)"/>. /// </summary> public ITransaction CreateTransaction(TransactionMode txMode, IsolationMode isolationMode) { return CreateTransaction(txMode, isolationMode, false); }
public async Task <int> HurlAsync(string storedProcedureName, string jsonData, TransactionMode transMode) { throw new NotImplementedException(); }
public SendOptions WithTransactionMode(TransactionMode transactionMode) { this.SetApplicationProperty(MessageBrokers.ApplicationProperties.TransactionMode, (byte)transactionMode); return(this); }
/// <summary> /// Creates an object that contains contextual information about the message broker transaction /// </summary> /// <param name="transactionReceiver">The message broker receiver</param> /// <param name="transactionMode">The transaction mode</param> public TransactionContext(string transactionReceiver, TransactionMode transactionMode) { TransactionReceiver = transactionReceiver; TransactionMode = transactionMode; }
/// <summary> /// Creates a transaction. /// </summary> /// <param name="transactionMode">The transaction mode.</param> /// <param name="isolationMode">The isolation mode.</param> /// <param name="distributedTransaction">if set to <c>true</c>, the TM will create a distributed transaction.</param> /// <returns></returns> public virtual ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) { if (transactionMode == TransactionMode.Unspecified) { transactionMode = ObtainDefaultTransactionMode(transactionMode); } CheckNotSupportedTransaction(transactionMode); if (CurrentTransaction == null && (transactionMode == TransactionMode.Supported || transactionMode == TransactionMode.NotSupported)) { return null; } AbstractTransaction transaction = null; if (CurrentTransaction != null) { if (transactionMode == TransactionMode.Requires || transactionMode == TransactionMode.Supported) { transaction = ((StandardTransaction) CurrentTransaction).CreateChildTransaction(); RaiseChildTransactionCreated(transaction, transactionMode, isolationMode, distributedTransaction); logger.DebugFormat("Child Transaction {0} created", transaction.GetHashCode()); } } if (transaction == null) { transaction = InstantiateTransaction(transactionMode, isolationMode, distributedTransaction); if (distributedTransaction) { #if MONO throw new TransactionException("Distributed transactions are not supported on Mono"); #else transaction.Enlist(new TransactionScopeResourceAdapter(transactionMode, isolationMode)); #endif } RaiseTransactionCreated(transaction, transactionMode, isolationMode, distributedTransaction); logger.DebugFormat("Transaction {0} created", transaction.GetHashCode()); } transaction.Logger = logger.CreateChildLogger(transaction.GetType().FullName); activityManager.CurrentActivity.Push(transaction); return transaction; }
protected virtual TransactionMode ObtainDefaultTransactionMode(TransactionMode transactionMode) { return(TransactionMode.Requires); }
protected void RaiseChildTransactionCreated(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode, bool distributedTransaction) { TransactionCreationInfoDelegate eventDelegate = (TransactionCreationInfoDelegate) events[ChildTransactionCreatedEvent]; if (eventDelegate != null) { eventDelegate(transaction, transactionMode, isolationMode, distributedTransaction); } }
/// <summary> /// Gets the default transaction mode, i.e. the mode which is the current mode when /// <see cref="TransactionMode.Unspecified"/> is passed to <see cref="CreateTransaction(Castle.Services.Transaction.TransactionMode,Castle.Services.Transaction.IsolationMode)"/>. /// </summary> /// <param name="mode">The mode which was passed.</param> /// <returns> /// Requires <- mode = Unspecified /// mode <- otherwise /// </returns> protected virtual TransactionMode ObtainDefaultTransactionMode(TransactionMode mode) { return(mode == TransactionMode.Unspecified ? TransactionMode.Requires : mode); }
private void CheckNotSupportedTransaction(TransactionMode transactionMode) { if (transactionMode == TransactionMode.NotSupported && CurrentTransaction != null && CurrentTransaction.Status == TransactionStatus.Active) { String message = "There is a transaction active and the transaction mode " + "explicit says that no transaction is supported for this context"; logger.Error(message); throw new TransactionException(message); } }
/// <summary> /// <see cref="ITransactionManager.CreateTransaction(Castle.Services.Transaction.TransactionMode,Castle.Services.Transaction.IsolationMode)"/>. /// </summary> public ITransaction CreateTransaction(TransactionMode txMode, IsolationMode isolationMode) { return(CreateTransaction(txMode, isolationMode, false, false)); }
/// <summary> /// Update a resource /// </summary> public Resource Update(string id, Resource target, TransactionMode mode) { throw new NotImplementedException(); }
public TalkativeTransaction(TransactionMode transactionMode, IsolationMode isolationMode, bool isAmbient) : base(null, transactionMode, isolationMode) { _IsAmbient = isAmbient; }
/// <summary> /// Declares the transaction mode, but omits the isolation, /// which means that the transaction manager should use the /// default value for it. /// </summary> /// <param name="transactionMode"></param> public TransactionAttribute(TransactionMode transactionMode) : this(transactionMode, IsolationMode.Unspecified) { }
/// <summary> /// 根据指定的TransactionMode,创建一个ConnectionScope对象 /// <remarks> /// <list type="bullet"> /// <item><description>事务行为由<see cref="TransactionMode"/>枚举决定;</description></item> /// </list> /// </remarks> /// </summary> /// <param name="mode">事务模式</param> public ConnectionScope(TransactionMode mode) { Init(mode, null, null); }