/// <summary>
/// This does the actual execution of the <see cref="ITransactional"/> object to the DB.
/// This is an injection point to handle alternate persistance options for the <see cref="ITransactional"/> object.
/// For example, an alternate <see cref="ITransactional"/> object type for bulk operations could be handled here using some
/// other mechanism than the <see cref="ITransactionalDB"/>.<see cref="ITransactionalDB.GetPersistSql"/> being executed on the DB.
/// </summary>
/// <param name="transactional">The <see cref="ITransactional"/> object to execute to the DB</param>
/// <returns>True if the transaction was executed, or False if it could not be executed.</returns>
protected virtual bool ExecuteTransactionToDB(ITransactional transactional)
{
var transactionDB = (ITransactionalDB)transactional;
var transactionalBusinessObjectDB = transactional as TransactionalBusinessObjectDB;
if (transactionalBusinessObjectDB != null)
{
var businessObject = transactionalBusinessObjectDB.BusinessObject;
if (businessObject.Status.IsDeleted)
{
DeleteRelatedChildren(businessObject);
DereferenceRelatedChildren(businessObject);
}
}
var sql = transactionDB.GetPersistSql();
if (sql == null)
{
return(false);
}
var databaseConnection = _databaseConnection;
databaseConnection.ExecuteSql(sql, _dbTransaction);
return(true);
}
/// <summary>
/// Commits the transaction to the In Memory data Store.
/// </summary>
/// <param name="transaction"></param>
protected internal override void ExecuteTransactionToDataSource(ITransactional transaction)
{
string transactionID = transaction.TransactionID();
if (_transactionsExecutingToDataSource.ContainsKey(transactionID))
{
return;
}
_transactionsExecutingToDataSource.Add(transactionID, transaction);
if (transaction is TransactionalBusinessObject)
{
IBusinessObject businessObject = ((TransactionalBusinessObject)transaction).BusinessObject;
if (!_dataStoreInMemory.AllObjects.ContainsKey(businessObject.ID.ObjectID))
{
_dataStoreInMemory.Add(businessObject);
if (businessObject.Props.HasAutoIncrementingField)
{
SupportsAutoIncrementingFieldBO supportsAutoIncrementingFieldBO = new SupportsAutoIncrementingFieldBO(businessObject);
long autoIncrementingNumber = _dataStoreInMemory.GetNextAutoIncrementingNumber(businessObject.ClassDef);
supportsAutoIncrementingFieldBO.SetAutoIncrementingFieldValue(autoIncrementingNumber);
}
}
else if (businessObject.Status.IsDeleted)
{
DeleteRelatedChildren(businessObject);
DereferenceRelatedChildren(businessObject);
_dataStoreInMemory.Remove(businessObject);
}
}
base.ExecuteTransactionToDataSource(transaction);
}
/// <inheritdoc cref="IConsumerTransactionManager.Enlist" />
public void Enlist(ITransactional transactionalService)
{
Check.NotNull(transactionalService, nameof(transactionalService));
if (IsCompleted)
{
throw new InvalidOperationException("The transaction already completed.");
}
// ReSharper disable once InconsistentlySynchronizedField
if (_transactionalServices.Contains(transactionalService))
{
return;
}
lock (_transactionalServices)
{
if (_transactionalServices.Contains(transactionalService))
{
return;
}
_transactionalServices.Add(transactionalService);
}
}
public void AddTransaction(ITransactional transaction)
{
if (_myDataAccessor == null)
{
_myDataAccessor = _defaultDataAccessor;
_transactionCommitter = _myDataAccessor.CreateTransactionCommitter();
}
_transactionCommitter.AddTransaction(transaction);
}
///<summary>
/// This method adds an <see cref="ITransactional"/> to the list of transactions.
///</summary>
///<param name="transaction">The transaction to add to the <see cref="ITransactionCommitter"/>.</param>
public void AddTransaction(ITransactional transaction)
{
if (_myDataAccessor == null)
{
_myDataAccessor = _defaultDataAccessor;
_transactionCommitter = _myDataAccessor.CreateTransactionCommitter();
}
_transactionCommitter.AddTransaction(transaction);
}
private bool InsertTransactionInternal(ITransactional transaction)
{
if (!AddToTransactionsByKey(transaction))
{
return(false);
}
_originalTransactions.Insert(0, transaction);
return(true);
}
public StickerPackController(
StickerPackService stickerPackService,
CurrentAdminProvider currentAdminProvider,
ITransactional transactional,
TelegramBot tgBot
)
{
_stickerPackService = stickerPackService;
_currentAdminProvider = currentAdminProvider;
_transactional = transactional;
_tgBot = tgBot;
}
public void Commit()
{
foreach (KeyValuePair <Type, IDisposable> uow in Uows)
{
ITransactional transactional = uow.Value as ITransactional;
if (transactional != null)
{
transactional.Commit();
}
}
_transactionScope.Complete();
}
private bool AddToTransactionsByKey(ITransactional transaction)
{
var transactionID = transaction.TransactionID();
// NOTE: The sole purpose of the dictionary is to optimise the performance of a this check on TransactionID.
// The original transactions list is still maintained because the transactions must be in the order they were added.
if (_originalTransactionsByKey.ContainsKey(transactionID))
{
return(false);
}
_originalTransactionsByKey.Add(transactionID, transaction);
return(true);
}
/// <summary>
/// Transmits a message.
/// </summary>
/// <param name="msg">The message to transmit.</param>
public void TransmitMessage(MultiPartMessage msg)
{
if (_isDisposed)
{
throw new ObjectDisposedException(this.GetType().Name);
}
if (!_isRunning)
{
throw new InvalidOperationException("Message Engine is not running.");
}
CheckMetadata(msg);
AdapterBase adapter = AdapterProxy.GetAdapterById(msg.Metadata.ReadAsString("SendAdapterId"));
ComponentPipeline pipeline = _sendPipelineDictionary[adapter];
Collection <MultiPartMessage> resultCollection = pipeline.Execute(msg);
if (resultCollection != null)
{
//Check if message should be part of a transaction
if (TransactionScope.Current != null)
{
if (adapter is ITransactional)
{
ITransactional transactionalAdapter = adapter as ITransactional;
AdapterTransaction transaction = transactionalAdapter.StartTransaction(resultCollection[0]);
transaction.State = TransactionState.Started;
TransactionScope.Current.EnlistTransaction(transaction);
transactionalAdapter.TransmitMessage(resultCollection[0], transaction);
}
else
{
throw new AdapterException("Adapter: \"" + adapter.AdapterId + "\" is not transactional.");
}
}
else
{
adapter.TransmitMessage(resultCollection[0]);
}
}
}
/// <summary>
/// Tries to execute an individual transaction against the datasource.
/// 1'st phase of a 2 phase database commit.
/// </summary>
protected override void ExecuteTransactionToDataSource(ITransactional transaction)
{
var transactionID = transaction.TransactionID();
if (_transactionsExecutingToDataSource.ContainsKey(transactionID))
{
return;
}
_transactionsExecutingToDataSource.Add(transactionID, transaction);
if (!ExecuteTransactionToDB(transaction))
{
return;
}
base.ExecuteTransactionToDataSource(transaction);
}
/// <summary>
/// Registers a work item.
/// </summary>
/// <param name="t">The type of work item that is registered.</param>
/// <param name="item">The item that is added to this unit of work.</param>
public void RegisterWorkItem(Type t, ITransactional item)
{
if (_items == null)
{
_items = new List <ITransactional>();
}
if (_itemsByType == null)
{
_itemsByType = new Dictionary <string, List <ITransactional> >();
}
_items.Add(item);
string typeName = t.FullName;
if (!_itemsByType.ContainsKey(typeName))
{
_itemsByType.Add(typeName, new List <ITransactional>());
}
_itemsByType[typeName].Add(item);
}
/// <summary>
/// Retrieves a database manager for executing database commands. If a unit of work is not specified, a new database manager is created and returned by this method.
/// If a unit of work is specified, this method looks to see if a database manager exists for the specified unit of work. If one does exist, this is returned. Otherwise
/// a new database manager is created, associated with the unit of work and returned.
/// </summary>
/// <param name="unitOfWork">Unit of work (null if no unit of work).</param>
/// <returns>A database manager.</returns>
public IDatabaseManager GetDatabaseManager(IUnitOfWork unitOfWork = null)
{
// No unit of work
if (unitOfWork == null)
{
return(new DatabaseManager(ConnectionString, false));
}
// Unit of work specified, so try to find any active database managers already registered as tasks
ITransactional workItem = unitOfWork.FindWorkItem(typeof(IDatabaseManager));
if (workItem != null)
{
return((IDatabaseManager)workItem);
}
// If database manager not found, create one and associate it with the unit of work
IDatabaseManager databaseManager = new DatabaseManager(ConnectionString, true);
unitOfWork.RegisterWorkItem(typeof(IDatabaseManager), databaseManager);
return(databaseManager);
}
protected override void ExecuteTransactionToDataSource(ITransactional transaction)
{
TransactionalBusinessObjectDB transactionDB = (TransactionalBusinessObjectDB)transaction;
transactionDB.GetPersistSql();
}
/// <summary>
/// Tries to execute an individual transaction against the datasource.
/// 1'st phase of a 2 phase database commit.
/// </summary>
protected internal virtual void ExecuteTransactionToDataSource(ITransactional transaction)
{
_executedTransactions.Add(transaction);
}
protected override void ExecuteTransactionToDataSource(ITransactional transaction)
{
TransactionalBusinessObjectDB transactionDB = (TransactionalBusinessObjectDB)transaction;
transactionDB.GetPersistSql();
}
public TagController(ITransactional transactional, TagService tagService)
{
_transactional = transactional;
_tagService = tagService;
}
public AuthorizationController(ITransactional transactional, AuthorizationService authorizationService)
{
_transactional = transactional;
_authorizationService = authorizationService;
}
public DonationController(DonationService donationService, ITransactional transactional)
{
_donationService = donationService;
_transactional = transactional;
}
public void AddTransaction(ITransactional transaction)
{
_remoteTransactionCommitter.AddTransaction(transaction);
}
///<summary>
/// This method adds an <see cref="ITransactional"/> to the list of transactions.
///</summary>
///<param name="transaction">The transaction to add to the <see cref="ITransactionCommitter"/>.</param>
public void AddTransaction(ITransactional transaction)
{
AddTransactionInternal(transaction);
}
