public async Task <IResultCursor> RunAsync(Query query)
{
if (query?.Parameters?.Count > 0)
{
var parameters = query.Parameters;
var modifications = new Dictionary <string, object>();
foreach (var entry in parameters.Keys)
{
if (parameters[entry] is JObject valueJObject)
{
//we need to convert this to dictionary so it can be understood by the driver.
//otherwise, the driver would assume the JObject is a List,
//because JObject inherits from JContainer which in turn inherits from IList<JToken>.
modifications[entry] = valueJObject.ToObject <Dictionary <string, object> >();
}
}
foreach (var entry in modifications)
{
parameters[entry.Key] = entry.Value;
}
}
return(SessionWrapper.GetResultCursor(await WrappedItem.RunAsync(query)));
}
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
if (WrappedItem != null)
{
WrappedItem.Dispose();
WrappedItem = null;
}
}
}
//-----------------------------------------------------------------------
public override void Paste()
{
if (WrappedItem != null)
{
WrappedItem.Paste();
}
else
{
GraphNodeDefinition chosen = null;
foreach (var def in ReferenceDef.Definitions.Values)
{
if (Clipboard.ContainsData(def.CopyKey))
{
var flat = Clipboard.GetData(def.CopyKey) as string;
var root = XElement.Parse(flat);
if (root.Name == def.Name)
{
chosen = def;
break;
}
}
}
if (chosen == null)
{
return;
}
GraphNodeItem item = null;
using (UndoRedo.DisableUndoScope())
{
item = chosen.CreateData(UndoRedo) as GraphNodeItem;
if (item is GraphStructItem && item.Children.Count == 0)
{
(item.Definition as GraphStructDefinition).CreateChildren(item as GraphStructItem, UndoRedo);
}
item.Paste();
}
UndoRedo.ApplyDoUndo(delegate
{
ChosenDefinition = chosen;
WrappedItem = item;
},
delegate
{
ChosenDefinition = null;
WrappedItem = null;
},
"Paste Item " + item.Name);
}
}
//-----------------------------------------------------------------------
public override void ResetToDefault()
{
var refDef = Definition as GraphReferenceDefinition;
if (refDef.Keys.Count > 0)
{
Clear();
}
else
{
WrappedItem.ResetToDefault();
}
}
public async Task <TValue> GetOrAdd <TValue>(string key, Func <Task <TValue> > getter)
{
var rawValue = (WrappedItem)_memoryCache.Get(key);
if (rawValue == null)
{
rawValue = new WrappedItem(await getter().Caf());
_memoryCache.Add(new CacheItem(key, rawValue), new CacheItemPolicy {
SlidingExpiration = _expirationTime
});
}
return((TValue)rawValue.Value);
}
public Task WriteTransactionAsync(Func <IAsyncTransaction, Task> work, Action <TransactionConfigBuilder> action)
{
return(WrappedItem.WriteTransactionAsync(tx => work(GetAsyncTransaction(tx)), action));
}
public Task WriteTransactionAsync(Func <IAsyncTransaction, Task> work)
{
return(WrappedItem.WriteTransactionAsync(tx => work(GetAsyncTransaction(tx))));
}
public Task <bool> SupportsMultiDbAsync()
{
return(WrappedItem.SupportsMultiDbAsync());
}
public Task CloseAsync()
{
return(WrappedItem.CloseAsync());
}
public IAsyncSession AsyncSession()
{
return(GetSession(WrappedItem.AsyncSession()));
}
//-----------------------------------------------------------------------
public override void ResetToDefault()
{
WrappedItem.ResetToDefault();
}
//-----------------------------------------------------------------------
public override void Copy()
{
WrappedItem.Copy();
}
public async Task <IResultCursor> RunAsync(string query, Action <TransactionConfigBuilder> action)
{
return(GetResultCursor(await WrappedItem.RunAsync(query, action)));
}
public string Compile(string source, params object[] args)
{
return(WrappedItem.Compile(source, args));
}
public Task <bool> FetchAsync()
{
return(WrappedItem.FetchAsync());
}
public async Task <IRecord> PeekAsync()
{
return(GetRecord(await WrappedItem.PeekAsync()));
}
public Task <IResultSummary> ConsumeAsync()
{
return(WrappedItem.ConsumeAsync());
}
public Task <string[]> KeysAsync()
{
return(WrappedItem.KeysAsync());
}
public async Task <IResultCursor> RunAsync(string query, IDictionary <string, object> parameters,
Action <TransactionConfigBuilder> action)
{
return(GetResultCursor(await WrappedItem.RunAsync(query, parameters, action)));
}
public async Task <IResultCursor> RunAsync(string query, IDictionary <string, object> parameters)
{
return(GetResultCursor(await WrappedItem.RunAsync(query, parameters)));
}
//-----------------------------------------------------------------------
public override void Paste()
{
WrappedItem.Paste();
}
public async Task <IResultCursor> RunAsync(Query query)
{
return(GetResultCursor(await WrappedItem.RunAsync(query)));
}
public string Compile(string path, IList <string> dependentFileList = null)
{
return(WrappedItem.Compile(path, dependentFileList));
}
public Task <IAsyncTransaction> BeginTransactionAsync()
{
return(WrappedItem.BeginTransactionAsync());
}
public IAsyncSession AsyncSession(Action <SessionConfigBuilder> action)
{
return(GetSession(WrappedItem.AsyncSession(action)));
}
public Task <IAsyncTransaction> BeginTransactionAsync(Action <TransactionConfigBuilder> action)
{
return(WrappedItem.BeginTransactionAsync(action));
}
public Task VerifyConnectivityAsync()
{
return(WrappedItem.VerifyConnectivityAsync());
}
public Task <T> ReadTransactionAsync <T>(Func <IAsyncTransaction, Task <T> > work)
{
return(WrappedItem.ReadTransactionAsync(tx => work(GetAsyncTransaction(tx))));
}
public void Dispose()
{
WrappedItem.Dispose();
}
public Task <T> ReadTransactionAsync <T>(Func <IAsyncTransaction, Task <T> > work,
Action <TransactionConfigBuilder> action)
{
return(WrappedItem.ReadTransactionAsync(tx => work(GetAsyncTransaction(tx)), action));
}
