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)); }