public IEngineRepository <TItem> GetRepository <TItem>(IDataTransaction transaction)
where TItem : class, new()
{
IList <TItem> list = GetList <TItem>();
return(new MemoryRepository <TItem>(list));
}
public FullEngineContext(IDataTransaction transaction, IEngineRepository <TItem> repository, [NotNull] IEngineSubContext <TItem> subContext)
{
Transaction = transaction;
Repository = repository;
_subContext = subContext;
}
public MyEntityUpdateContext(long id, Action <MyEntity> updateFunc, IMyEntityLoader loader, IDataTransaction dataTransaction)
{
Id = id;
UpdateFunc = updateFunc;
Loader = loader;
DataTransaction = dataTransaction;
}
public string Invoke(ref SearchContext searchContext)
{
string result = string.Empty;
try
{
/* Session Logic must be inserted here. (Need new table creation)*/
if (searchContext.MethodInformation != null)
{
Object[] data = null;
Object resultData = null;
Type type = ObjectResolver.Resolve(searchContext.MethodInformation.ObjectName, false);
//
using (IDataTransaction dataTransaction = Activator.CreateInstance(type) as IDataTransaction)
{
MethodInfo method = this.FindMethod(type, searchContext.MethodInformation.MethodName);
//
data = this.FindParameters(searchContext, method);
//
resultData = method.Invoke(dataTransaction, data);
result = Json.Serialize(resultData);
}
}
else
{
throw new ArgumentException("Missing Method Information.");
}
}
catch (Exception exception)
{
Errors.Extract(exception);
}
//
return(result);
}
public DataSet Search(ref SearchContext searchContext)
{
DataSet dataSet = new DataSet();
try
{
/* Session Logic must be inserted here. (Need new table creation)*/
if (searchContext.MethodInformation != null)
{
Object[] data = null;
Type type = ObjectResolver.Resolve(searchContext.MethodInformation.ObjectName, false);
//
using (IDataTransaction dataTransaction = Activator.CreateInstance(type) as IDataTransaction)
{
MethodInfo method = this.FindMethod(type, searchContext.MethodInformation.MethodName);
//
data = this.FindParameters(searchContext, method);
//
dataSet = method.Invoke(dataTransaction, data) as DataSet;
}
}
else
{
using (IDataTransaction dataTransaction = Activator.CreateInstance(ObjectResolver.Resolve(searchContext)) as IDataTransaction)
dataSet = dataTransaction.Search(ref searchContext);
}
}
catch (Exception exception)
{
searchContext.ErrorMessage = Errors.Extract(exception);
}
//
return(dataSet);
}
public async Task <bool> SaveAsync(IDataTransaction transaction)
{
var columns = new List <PropertyInfo>();
while (Dirty.TryTake(out var e))
{
columns.Add(e);
}
IDataTransaction tr = null;
try
{
tr = transaction ?? _data.GetTransaction();
if (Target is IEntity <int> ei && ei.Id < 0)
{
var t = await tr.AddAsync <T>(e => Target.CopyPrimitivesTo(e));
if (transaction == null)
{
tr.Done();
}
ei.Id = (int)t.Id;
return(true);
}
if (await tr.UpdateAsync(Target, columns.Select(GetColumnName)))
{
if (transaction == null)
{
tr.Done();
}
IsDirty = false;
return(true);
}
return(false);
}
catch (Exception ex)
{
foreach (var p in columns)
{
Dirty.Add(p);
}
throw new DataException("Save failure", ex);
}
finally
{
if (transaction == null)
{
tr?.Dispose();
}
}
}
public CreateAdminUserHandler(
IDataTransaction tx,
ICreateUserService create,
IPromoteUserService promote)
{
Transaction = tx;
Create = create;
Promote = promote;
}
public void PropagateParent(IDataTransaction parent)
{
Parent = parent;
object value = CurrentData;
if (DataTransactionHelper.IsDataTransactionObject(value))
{
DataTransactionHelper.PropagateParent(value, parent);
}
}
/// <summary>
/// Set active transaction on current data session
/// </summary>
/// <param name="dataTransaction">Data transaction</param>
public void SetActiveTransaction(IDataTransaction dataTransaction)
{
//Arguments validation
if (dataTransaction == null)
{
throw new ArgumentNullException(nameof(dataTransaction));
}
//Set transaction
Transaction = dataTransaction;
}
public void SetActiveTransaction(IDataTransaction dataTransaction)
{
//Validazione Argomenti
if (dataTransaction == null)
{
throw new ArgumentNullException(nameof(dataTransaction));
}
//Imposto la transazione
Transaction = dataTransaction;
}
public IRestResource GetFullResource(IDeferredItem <TItem> item, IDataTransaction dataTransaction)
{
IEngineRepository <TNav> navRepository = new NavigationCollectionRepository <TItem, TCollection, TNav>(item, _navTools.NavExpression, _navTools.Setter);
var eventWrapper = new DataEventWrapper <TNav>(dataTransaction, navRepository);
eventWrapper.TryWrapEvents(_navTools.RepoEvents);
var context = new FullEngineContext <TNav>(eventWrapper.Transaction, eventWrapper.Repository, _subContext);
return(new EngineRestCollection <TNav>(context));
}
public void Inject(
IDataTransaction transaction,
IMvvmService mvvm,
IIconService icon,
ILocalizationService localization)
{
IconService = icon;
LocalizationService = localization;
_mvvm = mvvm;
_transaction = transaction;
H.Initialize(this);
User = Acl.Connection.User;
}
public IEngineRepository <TEntity> GetRepository <TEntity>(IDataTransaction transaction)
where TEntity : class, new()
{
if (!(transaction is EntitiesDataTransaction <TDbContext> entitiesTransaction))
{
throw new ArgumentException("Entity Framework data source was given a transaction for the wrong data source type or context.");
}
TDbContext database = entitiesTransaction.DbContext;
DbSet <TEntity> repo = database.Set <TEntity>();
return(new EntitiesRepository <TEntity>(repo));
}
public virtual void ExecuteTransaction(Action work)
{
using (IDataTransaction tx = BeginTransaction()) {
try {
work.Invoke();
tx.Commit();
}
catch (Exception) {
tx.Rollback();
throw;
}
}
}
public virtual TEntity ExecuteTransaction <TEntity>(TEntity entity, Action <TEntity> work)
where TEntity : IEntity <TEntity>, IEquatable <TEntity>
{
using (IDataTransaction tx = BeginTransaction()) {
try {
work.Invoke(entity);
tx.Commit();
return(entity);
}
catch (Exception) {
tx.Rollback();
throw;
}
}
}
public IRestCollection GetRestCollection()
{
IDataTransaction transaction = _dataSource.CreateTransaction();
// TODO setup disposing of transaction
IEngineRepository <TItem> repository = _dataSource.GetRepository <TItem>(transaction);
var wrapper = new DataEventWrapper <TItem>(transaction, repository);
wrapper.TryWrapEvents(_events);
IEngineContext <TItem> context = new FullEngineContext <TItem>(wrapper.Transaction, wrapper.Repository, _subContext);
return(new EngineRestCollection <TItem>(context));
}
protected RepositoryBase(IConnectionProvider connectionProvider, DataBaseType dataBaseType, IDataTransaction dataTransaction = null)
{
DataBaseType = dataBaseType;
var connect = connectionProvider.ConnectionSchemas.FirstOrDefault(x => x.SourceType == SourceType.Database && x.DataBaseType == dataBaseType);
if (dataTransaction == null)
{
Conn = new DataBaseRepositoryInit().GetRepositoryInit(dataBaseType, connect).OpenConnection();
}
else
{
Conn = dataTransaction.Transaction.Connection;
Trans = dataTransaction.Transaction;
}
DataTransaction = dataTransaction;
}
public IRestResource GetFullResource(IDeferredItem <TItem> item, IDataTransaction dataTransaction)
{
//TNav navItem = _navTools.NavExpression.Compile().Invoke(item.LoadedItem);
//var itemRepository = new LoadedItemRepository<TNav>(navItem);
IQueryableSingle <TNav> navigationQuery = item.Query.Select(_navTools.NavExpression).SingleDefferred();
var itemRepository = new QueryableSingleRepository <TNav>(navigationQuery);
var eventWrapper = new DataEventWrapper <TNav>(dataTransaction, itemRepository);
eventWrapper.TryWrapEvents(_navTools.RepoEvents);
var context = new FullEngineContext <TNav>(eventWrapper.Transaction, eventWrapper.Repository, _engineSubContext);
var deferredNavItem = new RepositoryDeferredItem <TNav>(itemRepository);
return(new EngineRestItem <TNav>(context, deferredNavItem));
}
public IRestCollection GetRestCollection(Stem <TItem> stem)
{
IDataTransaction transaction = _dataSource.CreateTransaction();
stem.OnDispose += delegate { transaction.Dispose(); };
IEngineRepository <TItem> repository = _dataSource.GetRepository <TItem>(transaction);
var wrapper = new DataEventWrapper <TItem>(transaction, repository);
wrapper.TryWrapEvents(new StemDataChangeEvents <TItem>(stem));
var subContext = new StemsEngineSubContext <TItem>(stem);
var context = new FullEngineContext <TItem>(wrapper.Transaction, wrapper.Repository, subContext);
return(new EngineRestCollection <TItem>(context));
}
public static T Try <T>(
this IDataCommandScope scope,
Func <IDataConnection, T> execute)
{
Check.NotNull(nameof(scope), scope);
Check.NotNull(nameof(execute), execute);
IDataTransaction tx = null;
try
{
DataConnection c = null;
if (scope is DataTransaction transaction)
{
c = (DataConnection)transaction.Connection;
transaction.SetAutoCommit(true);
tx = transaction;
}
else if (scope is DataConnection connection)
{
c = connection;
}
if (c.State != ConnectionState.Open)
{
c.SetAutoClose(true);
c.Open();
}
return(execute(c));
}
catch
{
tx?.OnError(null);
scope.OnError(null);
throw;
}
finally
{
tx?.OnCompleted();
scope.OnCompleted();
}
}
public void BeginUpdate(IDataTransaction parent, params object[] ids)
{
Parent = parent;
object value = CurrentData;
if (DataTransactionHelper.IsDataTransactionObject(value))
{
DataTransactionHelper.BeginUpdate(value, parent, ids);
if (value is IList)
{
Backup(value);
}
State = DataTransactionState.Begin;
return;
}
Backup(value);
isUpdating = true;
State = DataTransactionState.Begin;
}
public InjectedEngineContext([NotNull] IDataTransaction transaction, [NotNull] IEngineRepository <TItem> repository,
[NotNull] IIdentifierProvider <TItem> identifiers, [NotNull] IFieldProvider <TItem> fields,
[NotNull] IAuthorizationChecker <TItem> authorizationChecker)
{
if (repository == null)
{
throw new ArgumentNullException(nameof(repository));
}
if (fields == null)
{
throw new ArgumentNullException(nameof(fields));
}
if (authorizationChecker == null)
{
throw new ArgumentNullException(nameof(authorizationChecker));
}
Repository = repository;
Identifiers = identifiers;
Fields = fields;
AuthorizationChecker = authorizationChecker;
Transaction = transaction;
}
public static void Use(
this IDataCommandScope scope,
Action <IDataConnection> execute)
{
Check.NotNull(nameof(scope), scope);
Check.NotNull(nameof(execute), execute);
IDataTransaction tx = null;
try
{
DataConnection c = null;
if (scope is DataTransaction transaction)
{
c = (DataConnection)transaction.Connection;
transaction.SetAutoCommit(true);
tx = transaction;
}
else if (scope is DataConnection connection)
{
c = connection;
}
execute(c);
}
catch
{
tx?.OnError(null);
scope.OnError(null);
throw;
}
finally
{
tx?.OnCompleted();
scope.OnCompleted();
}
}
public async Task SetValueAsync(IDeferredItem <TItem> item, object deserializedValue, IDataTransaction dataTransaction)
{
IEngineRepository <TNav> navRepository = new NavigationItemRepository <TItem, TNav>(item, _navTools.NavExpression, _navTools.Setter);
var itemData = new RestItemData(deserializedValue);
var navLocatorCreator = new NavigationItemLocatorCreator <TNav>(_subContext);
DeferredItemBase <TNav> deferredItem = await navLocatorCreator.LocateOrCreateItemAsync(navRepository, itemData, item.LoadAsync);
try
{
IDataTransaction transaction = new VoidTransaction(); // we commit the transaction in the parent. TODO optional save-as-you-go ?
var navContext = new FullEngineContext <TNav>(transaction, navRepository, _subContext);
var navEngineItem = new EngineRestItem <TNav>(navContext, deferredItem);
Acknowledgment acknowledgment = await navEngineItem.EditAsync(itemData);
}
catch (RestApiException ex)
{
throw new SubWriterException(ex, item);
}
}
public TestEngineContext(IDataTransaction transaction, IEngineRepository <Artist> repository)
{
Transaction = transaction;
Repository = repository;
}
public void SaveToDb(IDataTransaction dataTransaction)
{
dataTransaction.AddOrUpdate(Post);
}
public static Task SetValueAsync <TItem>(this IFieldWriter <TItem> writer, TItem item, object deserializedValue, IDataTransaction dataTransaction)
where TItem : class
{
var loadedItem = new LoadedItem <TItem>(item);
return(writer.SetValueAsync(loadedItem, deserializedValue, dataTransaction));
}
public QueryableFieldSetter([NotNull] IDataTransaction dataTransaction, [NotNull] IFieldProvider <TItem> fieldProvider, [NotNull] IAuthorizationChecker <TItem> authChecker)
{
_dataTransaction = dataTransaction ?? throw new ArgumentNullException(nameof(dataTransaction));
_fieldProvider = fieldProvider ?? throw new ArgumentNullException(nameof(fieldProvider));
_authChecker = authChecker ?? throw new ArgumentNullException(nameof(authChecker));
}
internal EventWrappedTransaction(IDataTransaction transaction, ITransactionEvents events)
{
_transaction = transaction;
_events = events;
}
public CreateUserHandler(IDataTransaction tx)
{
Transaction = tx;
}
