public IPromise<IEnumerable<Vault>> ReadPriority(bool async) { if (_readPriority == null) _readPriority = _child.ReadPriority(async); if (!async) _readPriority.Wait(); return _readPriority; }
public IPromise<IEnumerable<Vault>> WritePriority(bool async) { if (_writePriority == null) _writePriority = _child.WritePriority(async); if (!async) _writePriority.Wait(); return _writePriority; }
private IPromise<User> GetUserInfo(bool async) { if (_userInfo == null) { _userInfo = _conn.ItemByQuery(new Command("<Item type=\"User\" action=\"get\" select=\"default_vault\" expand=\"1\"><id>@0</id><Relationships><Item type=\"ReadPriority\" action=\"get\" select=\"priority, related_id\" expand=\"1\" orderBy=\"priority\"/></Relationships></Item>", _conn.UserId), async) .FailOver(() => _conn.ItemByQuery(new Command("<Item type=\"User\" action=\"get\" select=\"default_vault\" expand=\"1\"><id>@0</id></Item>", _conn.UserId), async)) .Convert<IReadOnlyItem, User>(i => { var result = new User(); result.Id = i.Id(); var vault = i.Property("default_vault").AsItem(); if (vault.Exists) result.DefaultVault = Vault.GetVault(vault); foreach (var rel in i.Relationships("ReadPriority")) { vault = rel.RelatedId().AsItem(); if (vault.Exists) { result.ReadPriority.Add(Vault.GetVault(vault)); } } return result; }) .Fail(ex => { ex.Rethrow(); }); } return _userInfo; }
public void getString(IPromise promise) { if (promise == null) { throw new ArgumentNullException(nameof(promise)); } RunOnDispatcher(async () => { try { var clip = _clipboard.GetContent(); if (clip == null) { promise.Resolve(""); } else if (clip.Contains(DataTransfer.StandardDataFormats.Text)) { var text = await clip.GetTextAsync().AsTask().ConfigureAwait(false); promise.Resolve(text); } else { promise.Resolve(""); } } catch (Exception ex) { promise.Reject(ex); } }); }
public async void canOpenURL(string url, IPromise promise) { if (url == null) { promise.Reject(new ArgumentNullException(nameof(url))); return; } var uri = default(Uri); if (!Uri.TryCreate(url, UriKind.Absolute, out uri)) { promise.Reject(new ArgumentException(Invariant($"URL argument '{uri}' is not valid."))); return; } try { var support = await Launcher.QueryUriSupportAsync(uri, LaunchQuerySupportType.Uri).AsTask().ConfigureAwait(false); promise.Resolve(support == LaunchQuerySupportStatus.Available); } catch (Exception ex) { promise.Reject(new InvalidOperationException( Invariant($"Could not check if URL '{url}' can be opened."), ex)); } }
public async void openURL(string url, IPromise promise) { if (url == null) { promise.Reject(new ArgumentNullException(nameof(url))); return; } var uri = default(Uri); if (!Uri.TryCreate(url, UriKind.Absolute, out uri)) { promise.Reject(new ArgumentException(Invariant($"URL argument '{uri}' is not valid."))); return; } try { await Launcher.LaunchUriAsync(uri).AsTask().ConfigureAwait(false); promise.Resolve(true); } catch (Exception ex) { promise.Reject(new InvalidOperationException( Invariant($"Could not open URL '{url}'."), ex)); } }
private void ProcessCommand(bool force) { _commands++; if ((force || _commands > this.Threshold) && _builder.Length > 5) { // Execute the query _builder.Append("</sql>"); WaitLastResult(); _lastQuery = _builder.ToString(); // Run either synchronously or asynchronously based on what's currently supported var asyncConn = _conn as IAsyncConnection; if (asyncConn == null) { _conn.Apply(new Command(_lastQuery).WithAction(CommandAction.ApplySQL)).AssertNoError(); } else { _lastResult = asyncConn.Process(new Command(_lastQuery).WithAction(CommandAction.ApplySQL), true); } // Reset the state _builder.Length = 0; _builder.Append("<sql>"); _commands = 0; } }
public void getScriptText(IPromise promise) { var map = new JObject { { "fullSourceMappingURL", _sourceMapUrl }, }; promise.Resolve(map); }
public void setup() { promise = new Promise(); promiseOneArg = new Promise<int>(); promiseTwoArg = new Promise<int, int>(); promiseThreeArg = new Promise<int, int, int>(); promiseFourArg = new Promise<int, int, int, int>(); value = 0; currentException = null; currentProgress = 0.0f; }
public void Push(CorrelationId correlation, IPromise promise, IEnumerable<MessageIdentifier> messageIdentifiers) { IDictionary<MessageIdentifier, IPromise> messageHandlers; if (handlers.TryGetValue(correlation, out messageHandlers)) { throw new DuplicatedKeyException($"Duplicated key: Correlation[{correlation.Value.GetString()}]"); } var delayedItem = expirationQueue.Delay(correlation, promise.ExpireAfter); ((Promise)promise).SetExpiration(delayedItem); handlers[correlation] = messageIdentifiers.ToDictionary(mp => mp, mp => promise); }
public void downloadUpdate(JObject updatePackage, bool notifyProgress, IPromise promise) { Action downloadAction = async () => { try { updatePackage[CodePushConstants.BinaryModifiedTimeKey] = "" + await _codePush.GetBinaryResourcesModifiedTime(); await _codePush.UpdateManager.DownloadPackage( updatePackage, _codePush.AssetsBundleFileName, new Progress<HttpProgress>( (HttpProgress progress) => { if (!notifyProgress) { return; } var downloadProgress = new JObject() { { "totalBytes", progress.TotalBytesToReceive }, { "receivedBytes", progress.BytesReceived } }; _reactContext .GetJavaScriptModule<RCTDeviceEventEmitter>() .emit(CodePushConstants.DownloadProgressEventName, downloadProgress); } ) ); JObject newPackage = await _codePush.UpdateManager.GetPackage((string)updatePackage[CodePushConstants.PackageHashKey]); promise.Resolve(newPackage); } catch (InvalidDataException e) { CodePushUtils.Log(e.ToString()); SettingsManager.SaveFailedUpdate(updatePackage); promise.Reject(e); } catch (Exception e) { CodePushUtils.Log(e.ToString()); promise.Reject(e); } }; Context.RunOnNativeModulesQueueThread(downloadAction); }
public void RandomUrls() { ServerConfig options = new ServerConfig { TimeoutSeconds=5 }; int outer = totalTests/simultaneousThreads; var list = GetRandomUrls(totalTests); List<string> successList = new List<string>(); List<string> failList = new List<string>(); int cur=0; for (int i = 0; i < outer; i++) { IPromise[] promises = new IPromise[simultaneousThreads]; List<string> active = new List<string>(); for (int j = 0; j < simultaneousThreads; j++) { string url = list[cur++]; active.Add(url); promises[j] = CQ.CreateFromUrlAsync(url, options).Then((success) => { successList.Add(FormatResult(success)); active.Remove(success.Url); },(fail) => { failList.Add(FormatResult(fail)); active.Remove(fail.Url); }); } if (!AsyncWebRequestManager.WaitForAsyncEvents(10000)) { AsyncWebRequestManager.CancelAsyncEvents(); foreach (var item in active) { failList.Add(item + ": aborted"); } } } Debug.WriteLine(FormatTestOutput(successList,failList)); }
public void getString(IPromise promise) { if (promise == null) { throw new ArgumentNullException(nameof(promise)); } if (_clipboard.ContainsText()) { var text = _clipboard.GetText(); promise.Resolve(text); } else { promise.Resolve(""); } }
public void getSize(string uriString, IPromise promise) { if (string.IsNullOrEmpty(uriString)) { promise.Reject(ErrorInvalidUri, "Cannot get the size of an image for an empty URI."); return; } DispatcherHelpers.RunOnDispatcher(async () => { try { var bitmapImage = new BitmapImage(); var loadQuery = bitmapImage.GetStreamLoadObservable() .Where(status => status.LoadStatus == ImageLoadStatus.OnLoadEnd) .FirstAsync() .Replay(1); using (loadQuery.Connect()) { using (var stream = await BitmapImageHelpers.GetStreamAsync(uriString)) { await bitmapImage.SetSourceAsync(stream); } await loadQuery; promise.Resolve(new JObject { { "width", bitmapImage.PixelWidth }, { "height", bitmapImage.PixelHeight }, }); } } catch (Exception ex) { promise.Reject(ErrorGetSizeFailure, ex.Message); } }); }
public ReadOnlyPromise(IPromise promised, bool allowWait) { _promised = promised; if (allowWait) { var promise = _promised as IWaitablePromise; if (promise != null) { _wait = () => promise.Wait(); } else { _wait = () => ThreadingHelper.SpinWaitUntil(() => _promised.IsCompleted); } } else { _wait = () => { throw new InvalidOperationException(); }; } }
public void SetConnection(ConnectionData connData) { _conn = null; _connData = null; btnEditConnection.Text = "No Connection ▼"; lblConnColor.BackColor = Color.Transparent; if (connData.Type != ConnectionType.Innovator) { MessageBox.Show("Only Innovator connections are supported"); return; } _connData = connData; btnEditConnection.Text = "Connecting... ▼"; _conn = connData.ArasLogin(true) .UiPromise(this) .Done(c => { btnEditConnection.Text = connData.ConnectionName + " ▼"; lblConnColor.BackColor = connData.Color; }); }
public void notifyApplicationReady(IPromise promise) { SettingsManager.RemovePendingUpdate(); promise.Resolve(""); }
static void WritePromiseCombiner(IChannelHandlerContext ctx, List <object> output, IPromise promise) { PromiseCombiner combiner = new PromiseCombiner(); for (int i = 0; i < output.Count; i++) { combiner.Add(ctx.WriteAsync(output[i])); } combiner.Finish(promise); }
private async Task <bool> PickMultipleFileAsync(FileOpenPicker picker, Boolean cache, Boolean readContent, IPromise promise) { IReadOnlyList <StorageFile> files = await picker.PickMultipleFilesAsync().AsTask().ConfigureAwait(false); if (files.Count > 0) { JArray jarrayObj = new JArray(); foreach (var file in files) { jarrayObj.Add(PrepareFile(file, cache, readContent).Result); } promise.Resolve(jarrayObj); } else { promise.Reject(E_DOCUMENT_PICKER_CANCELED, "User canceled document picker"); } return(true); }
public void pick(JObject options, IPromise promise) { try { FileOpenPicker openPicker = new FileOpenPicker(); openPicker.ViewMode = PickerViewMode.Thumbnail; openPicker.SuggestedStartLocation = PickerLocationId.DocumentsLibrary; // Get file type array options var fileTypeArray = options.Value <JArray>(OPTION_TYPE); var cache = options.Value <Boolean>(CACHE_TYPE); // Init file type filter if (fileTypeArray != null && fileTypeArray.Count > 0) { foreach (String typeString in fileTypeArray) { List <String> types = typeString.Split(' ').ToList(); foreach (String type in types) { if (Regex.Match(type, "(^[.]+[A-Za-z0-9]*$)|(^[*]$)").Success) { openPicker.FileTypeFilter.Add(type); } } } } else { openPicker.FileTypeFilter.Add("*"); } RunOnDispatcher(async() => { try { if (_isInForeground) { var isMultiple = options.Value <bool>(OPTION_MULIPLE); var readContent = options.Value <bool>(OPTION_READ_CONTENT); if (isMultiple) { await PickMultipleFileAsync(openPicker, cache, readContent, promise); } else { await PickSingleFileAsync(openPicker, cache, readContent, promise); } } else { _pendingPicker = openPicker; } } catch (Exception ex) { promise.Reject(E_FAILED_TO_SHOW_PICKER, ex.Message); } }); } catch (Exception ex) { promise.Reject(E_UNEXPECTED_EXCEPTION, ex.Message); } }
public void Foo(IPromise promise, int foo) { }
public static IObservable <T> ToObservable <T>(this IPromise <T> promise, IScheduler scheduler = null) { return(new PromiseObservable <T>(promise, scheduler)); }
public void getNewStatusReport(IPromise promise) { // TODO implement this promise.Resolve(""); }
public SelfParameterSyntax(TextSpan span, bool mutableSelf) : base(span, null) { MutableSelf = mutableSelf; DataType = Symbol.Select(s => s.DataType); }
public async void SearchLibrary(string libraryName, JObject searchLibraryQuery, IPromise promise) { try { // If the library is not found KeyNotFoundException will be thrown and the promise will be rejected. var library = _libraries[libraryName]; var libraryQuery = JsonUtils.ToLibraryQuery(searchLibraryQuery); TaskCompletionSource <IList <LibraryPreviewResult> > previewsFromHandlerTcs = null; TaskCompletionSource <IDictionary <string, LibraryQueryResult> > resultsFromHandlerTcs = null; if (libraryQuery.GenerateTextPreviews) { previewsFromHandlerTcs = GetPreviewCompleteTcs(library); } else { resultsFromHandlerTcs = GetSearchCompleteTcs(library); } // Ensure all indexing is complete before search. await library.WaitForAllIndexingTasksToFinishAsync().AsTask().ConfigureAwait(false); // We can do the searching in the background as the callbacks will receive the results. #pragma warning disable CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed library.SearchAsync(libraryQuery); #pragma warning restore CS4014 // Because this call is not awaited, execution of the current method continues before the call is completed if (previewsFromHandlerTcs != null) { var previewResults = await previewsFromHandlerTcs.Task.ConfigureAwait(false); promise.Resolve(JsonUtils.PreviewResultsToJson(previewResults)); } if (resultsFromHandlerTcs != null) { var resultsFromHandler = await resultsFromHandlerTcs.Task.ConfigureAwait(false); promise.Resolve(JsonUtils.SearchResultsToJson(resultsFromHandler)); } } catch (Exception e) { promise.Reject(e); } }
public PendingWrite(object msg, IPromise promise) { Message = msg; Promise = promise; }
public override void Write(IChannelHandlerContext context, object message, IPromise promise) { _queue.AddLast(new PendingWrite(message, promise)); }
public Task Foo(IPromise promise) { return(Task.FromResult(true)); }
/// <summary> /// Simulate a task. /// </summary> /// <returns>The task.</returns> /// <param name="promise">Promise.</param> protected IEnumerator DoTask(IPromise promise) { yield return(new WaitForSeconds(0.5f)); promise.SetResult(); }
public abstract Task CloseAsync(IPromise promise);
private void InitializeProcessQueue() { currentProcess = Promise.Resolved(); }
/// <summary> /// Remove a <see cref="IByteBuffer"/> from the queue with the specified number of bytes. Any added buffer who's bytes are /// fully consumed during removal will have it's promise completed when the passed aggregate <see cref="IPromise"/> /// completes. /// </summary> /// <param name="alloc">The allocator used if a new <see cref="IByteBuffer"/> is generated during the aggregation process.</param> /// <param name="bytes">the maximum number of readable bytes in the returned <see cref="IByteBuffer"/>, if {@code bytes} is greater /// than <see cref="ReadableBytes"/> then a buffer of length <see cref="ReadableBytes"/> is returned.</param> /// <param name="aggregatePromise">used to aggregate the promises and listeners for the constituent buffers.</param> /// <returns>a <see cref="IByteBuffer"/> composed of the enqueued buffers.</returns> public IByteBuffer Remove(IByteBufferAllocator alloc, int bytes, IPromise aggregatePromise) { if ((uint)bytes > SharedConstants.TooBigOrNegative) { ThrowHelper.ThrowArgumentException_PositiveOrZero(bytes, ExceptionArgument.bytes); } if (aggregatePromise is null) { ThrowHelper.ThrowArgumentNullException(ExceptionArgument.aggregatePromise); } // Use isEmpty rather than readableBytes==0 as we may have a promise associated with an empty buffer. if (_bufAndListenerPairs.IsEmpty) { Debug.Assert(_readableBytes == 0); return(RemoveEmptyValue()); } bytes = Math.Min(bytes, _readableBytes); IByteBuffer toReturn = null; IByteBuffer entryBuffer = null; int originalBytes = bytes; try { while (_bufAndListenerPairs.TryRemoveFirst(out var entry)) { if (entry is IPromise promise) { aggregatePromise.Task.CascadeTo(promise, Logger); continue; } entryBuffer = (IByteBuffer)entry; if (entryBuffer.ReadableBytes > bytes) { // Add the buffer back to the queue as we can't consume all of it. _bufAndListenerPairs.AddFirst(entryBuffer); if (bytes > 0) { // Take a slice of what we can consume and retain it. entryBuffer = entryBuffer.ReadRetainedSlice(bytes); toReturn = toReturn is null?ComposeFirst(alloc, entryBuffer) : Compose(alloc, toReturn, entryBuffer); bytes = 0; } break; } else { bytes -= entryBuffer.ReadableBytes; toReturn = toReturn is null?ComposeFirst(alloc, entryBuffer) : Compose(alloc, toReturn, entryBuffer); } entryBuffer = null; } } catch (Exception cause) { ReferenceCountUtil.SafeRelease(entryBuffer); ReferenceCountUtil.SafeRelease(toReturn); aggregatePromise.SetException(cause); throw; } DecrementReadableBytes(originalBytes - bytes); return(toReturn); }
public void PlanProcess(Func <IPromise> process) { currentProcess = currentProcess.Then(process); }
public virtual Task DisconnectAsync(IPromise promise) => _pipeline.DisconnectAsync(promise);
public PromiseObservable(IPromise <T> promise, IScheduler scheduler) { this.promise = promise; this.scheduler = scheduler ?? Scheduler.Default; }
public Task DeregisterAsync(IPromise promise) => _pipeline.DeregisterAsync(promise);
public override void Write(IChannelHandlerContext context, object message, IPromise promise) { if (message is IHttp2StreamFrame streamFrame) { frames.Enqueue(streamFrame); context.WriteAsync(Unpooled.Empty, promise); } else { context.WriteAsync(message, promise); } }
private async Task <bool> PickSingleFileAsync(FileOpenPicker picker, Boolean cache, Boolean readContent, IPromise promise) { var file = await picker.PickSingleFileAsync().AsTask().ConfigureAwait(false); if (file != null) { JArray jarrayObj = new JArray(); jarrayObj.Add(PrepareFile(file, cache, readContent).Result); promise.Resolve(jarrayObj); } else { promise.Reject(E_DOCUMENT_PICKER_CANCELED, "User canceled document picker"); } return(true); }
public virtual Task CloseAsync(IPromise promise) => _pipeline.CloseAsync(promise);
public void respondWith(IPromise<object> r) { }
public Task WriteAndFlushAsync(object message, IPromise promise) => _pipeline.WriteAndFlushAsync(message, promise);
public static extern Task <TResult> FromPromise <TResult>(IPromise promise, Delegate resultHandler);
public Task Foo(IPromise promise) { return(Task.CompletedTask); }
public void TestThenOrder() { promiseOneArg.Then(OneArgCallback); promiseOneArg.Then(OneArgCallbackTwo); promiseOneArg.Then(OneArgCallbackThree); promiseOneArg.Dispatch(add); Assert.AreEqual((add+(add * 2))*add, value); value = 0; promiseOneArg = new Promise<int>(); promiseOneArg.Then(OneArgCallback); promiseOneArg.Then(OneArgCallbackThree); promiseOneArg.Then(OneArgCallbackTwo); promiseOneArg.Dispatch(add); Assert.AreEqual((add*add)+(add*2), value); }
/// <inheritdoc /> public override void Write(IChannelHandlerContext ctx, object msg, IPromise promise) { ThreadLocalObjectList output = null; try { if (AcceptOutboundMessage(msg)) { output = ThreadLocalObjectList.NewInstance(); var cast = (T)msg; try { Encode(ctx, cast, output); } finally { _ = ReferenceCountUtil.Release(cast); } if (0u >= (uint)output.Count) { CThrowHelper.ThrowEncoderException_MustProduceAtLeastOneMsg(GetType()); } } else { _ = ctx.WriteAsync(msg, promise); } } catch (EncoderException) { throw; } catch (Exception ex) { CThrowHelper.ThrowEncoderException(ex); // todo: we don't have a stack on EncoderException but it's present on inner exception. } finally { if (output is object) { try { int lastItemIndex = output.Count - 1; if (0u >= (uint)lastItemIndex) { _ = ctx.WriteAsync(output[0], promise); } else if (lastItemIndex > 0) { // Check if we can use a voidPromise for our extra writes to reduce GC-Pressure // See https://github.com/netty/netty/issues/2525 if (promise == ctx.VoidPromise()) { WriteVoidPromise(ctx, output); } else { WritePromiseCombiner(ctx, output, promise); } } } finally { output.Return(); } } } }
public override Task WriteRstStreamAsync(IChannelHandlerContext ctx, int streamId, Http2Error errorCode, IPromise promise) { if (IsExistingStream(streamId)) { return(base.WriteRstStreamAsync(ctx, streamId, errorCode, promise)); } // Since the delegate doesn't know about any buffered streams we have to handle cancellation // of the promises and releasing of the ByteBufs here. if (_pendingStreams.TryGetValue(streamId, out var stream)) { _ = _pendingStreams.Remove(streamId); // Sending a RST_STREAM to a buffered stream will succeed the promise of all frames // associated with the stream, as sending a RST_STREAM means that someone "doesn't care" // about the stream anymore and thus there is not point in failing the promises and invoking // error handling routines. stream.Close(null); promise.Complete(); } else { promise.SetException(ThrowHelper.GetConnectionError_StreamDoesNotExist(streamId)); } return(promise.Task); }
public static extern Task <object[]> FromPromise(IPromise promise);
public bool cancel(IPromise promise) { return false; }
private IPromise<IResultObject> Submit(string query, OutputType preferred = OutputType.Any) { if (_currentQuery != null) { _currentQuery.Cancel(); _clock.Enabled = false; lblProgress.Text = "Canceled"; _currentQuery = null; outputEditor.Text = ""; _clock.Enabled = false; btnSubmit.Text = "► Run"; return null; } if (_proxy.ConnData != null && _proxy.ConnData.Confirm) { if (MessageBox.Show("Do you want to run this query on " + _proxy.ConnData.ConnectionName +"?", "Confirm Execution", MessageBoxButtons.YesNo) == DialogResult.No) { return null; } } try { outputEditor.Text = "Processing..."; lblProgress.Text = "Processing..."; _start = DateTime.UtcNow; _clock.Enabled = true; _outputTextSet = false; btnSubmit.Text = "Cancel"; var cmd = _proxy.NewCommand().WithQuery(query).WithAction(this.SoapAction); var queryParams = _proxy.GetHelper().GetParameterNames(query) .Select(p => GetCreateParameter(p)).ToList(); if (queryParams.Any() && this.SoapAction != ArasEditorProxy.UnitTestAction) { using (var dialog = new ParameterWindow(queryParams)) { switch (dialog.ShowDialog(this)) { case System.Windows.Forms.DialogResult.OK: foreach (var param in queryParams) { cmd.WithParam(param.Name, param.GetValue()); } break; case System.Windows.Forms.DialogResult.Ignore: break; default: return null; } } } // Only reset if we are getting a new result if (preferred != OutputType.None) { _result = null; _outputSet = null; var pagesToRemove = tbcOutputView.TabPages.OfType<TabPage>() .Where(p => p.Name.StartsWith(GeneratedPage)).ToArray(); foreach (var page in pagesToRemove) { tbcOutputView.TabPages.Remove(page); } pgTableOutput.Text = "Table"; dgvItems.DataSource = null; } if (_proxy.ConnData != null) { SnippetManager.Instance.SetLastQueryByConnection(_proxy.ConnData.ConnectionName, new Snippet() { Action = this.SoapAction, Text = inputEditor.Text }); Properties.Settings.Default.LastConnection = _proxy.ConnData.ConnectionName; Properties.Settings.Default.Save(); Properties.Settings.Default.Reload(); } var st = Stopwatch.StartNew(); _currentQuery = _proxy.Process(cmd, true) .UiPromise(this) .Done(result => { try { var milliseconds = st.ElapsedMilliseconds; _clock.Enabled = false; SetResult(result, milliseconds, preferred); } catch (Exception ex) { Utils.HandleError(ex); } }).Fail(ex => { outputEditor.Text = ex.Message; tbcOutputView.SelectedTab = pgTextOutput; lblProgress.Text = "Error"; }) .Always(() => { _clock.Enabled = false; _currentQuery = null; btnSubmit.Text = "► Run"; }); } catch (Exception err) { outputEditor.Text = err.Message; tbcOutputView.SelectedTab = pgTextOutput; _clock.Enabled = false; lblProgress.Text = "Error"; _currentQuery = null; btnSubmit.Text = "► Run"; } return _currentQuery; }
public void isFailedUpdate(string packageHash, IPromise promise) { promise.Resolve(SettingsManager.IsFailedHash(packageHash)); }
private void btnSubmit_Click(object sender, EventArgs e) { try { if (_currentRun == null) { if (_conn == null) { outputEditor.Text = "Please select a connection first"; return; } btnSubmit.Text = "► Cancel"; outputEditor.Text = "Processing..."; _currentRun = _conn .Continue(c => _script.Execute(c)) .UiPromise(this) .Done(s => { outputEditor.Text = s; _currentRun = null; }) .Fail(ex => outputEditor.Text = ex.ToString()); } else { btnSubmit.Text = "► Run"; _currentRun.Cancel(); _currentRun = null; } } catch (Exception ex) { outputEditor.Text = ex.ToString(); } }
public void installUpdate(JObject updatePackage, InstallMode installMode, int minimumBackgroundDuration, IPromise promise) { Action installUpdateAction = async () => { await _codePush.UpdateManager.InstallPackage(updatePackage, SettingsManager.IsPendingUpdate(null)); var pendingHash = (string)updatePackage[CodePushConstants.PackageHashKey]; SettingsManager.SavePendingUpdate(pendingHash, /* isLoading */false); if (installMode == InstallMode.OnNextResume) { if (_minimumBackgroundListener == null) { // Ensure we do not add the listener twice. Action loadBundleAction = () => { Context.RunOnNativeModulesQueueThread(async () => { await LoadBundle(); }); }; _minimumBackgroundListener = new MinimumBackgroundListener(loadBundleAction, minimumBackgroundDuration); _reactContext.AddLifecycleEventListener(_minimumBackgroundListener); } else { _minimumBackgroundListener.MinimumBackgroundDuration = minimumBackgroundDuration; } } promise.Resolve(""); }; Context.RunOnNativeModulesQueueThread(installUpdateAction); }
private IPromise<IResultObject> Submit(string query, OutputType preferred = OutputType.Any, int batchSize = 0, int concurrentCount = 0) { if (_currentQuery != null) { outputEditor.Text = ""; _currentQuery.Cancel(); _currentQuery = null; lblClock.Text = ""; progQuery.Visible = false; _clock.Enabled = false; btnSubmit.Text = "► Run"; lblProgress.Text = "Canceled"; return null; } if (_proxy.ConnData != null && _proxy.ConnData.Confirm) { if (Dialog.MessageDialog.Show("Do you want to run this query on " + _proxy.ConnData.ConnectionName + "?", "Confirm Execution" , "&Run Query", "&Cancel") != DialogResult.OK) { return null; } } try { var cmd = _proxy.NewCommand() .WithQuery(query) .WithAction(this.SoapAction) .WithStatementCount(batchSize) .WithConcurrentCount(concurrentCount); var queryParams = _proxy.GetHelper().GetParameterNames(query) .Select(p => GetCreateParameter(p)).ToList(); if (queryParams.Any() && this.SoapAction != ArasEditorProxy.UnitTestAction) { using (var dialog = new Dialog.ParameterDialog(queryParams)) { switch (dialog.ShowDialog(this)) { case System.Windows.Forms.DialogResult.OK: foreach (var param in queryParams) { cmd.WithParam(param.Name, param.GetValue()); } break; case System.Windows.Forms.DialogResult.Ignore: break; default: return null; } } } outputEditor.Text = "Processing..."; lblProgress.Text = "Processing..."; _start = DateTime.UtcNow; lblClock.Text = ""; progQuery.Visible = true; _clock.Enabled = true; _outputTextSet = false; btnSubmit.Text = "Cancel"; // Only reset if we are getting a new result if (preferred != OutputType.None) { _result = null; _outputSet = null; CleanupGrids(); } if (_proxy.ConnData != null) { SnippetManager.Instance.SetLastQueryByConnection(_proxy.ConnData.ConnectionName, new Snippet() { Action = this.SoapAction, Text = inputEditor.Text }); Properties.Settings.Default.LastConnection = _proxy.ConnData.ConnectionName; Properties.Settings.Default.Save(); Properties.Settings.Default.Reload(); } var st = Stopwatch.StartNew(); _currentQuery = _proxy .Process(cmd, true, (p, m) => this.UiThreadInvoke(() => { lblProgress.Text = m; progQuery.Value = p; })) .UiPromise(this) .Done(result => { try { var milliseconds = st.ElapsedMilliseconds; _clock.Enabled = false; SetResult(result, milliseconds, preferred); } catch (Exception ex) { Utils.HandleError(ex); } }).Fail(ex => { outputEditor.Text = ex.Message; tbcOutputView.SelectedTab = pgTextOutput; lblProgress.Text = "Error"; }) .Always(() => { lblClock.Text = ""; _clock.Enabled = false; _currentQuery = null; progQuery.Visible = false; btnSubmit.Text = "► Run"; }); // Handle the synchronous option if (!_clock.Enabled) _currentQuery = null; } catch (Exception err) { outputEditor.Text = err.Message; tbcOutputView.SelectedTab = pgTextOutput; _clock.Enabled = false; progQuery.Visible = false; lblClock.Text = ""; lblProgress.Text = "Error"; _currentQuery = null; btnSubmit.Text = "► Run"; } return _currentQuery; }
public void isFirstRun(string packageHash, IPromise promise) { Action isFirstRunAction = async () => { bool isFirstRun = _codePush.DidUpdate && packageHash != null && packageHash.Length > 0 && packageHash.Equals(await _codePush.UpdateManager.GetCurrentPackageHash()); promise.Resolve(isFirstRun); }; Context.RunOnNativeModulesQueueThread(isFirstRunAction); }
public void getCurrentConnectivity(IPromise promise) { promise.Resolve(CreateConnectivityEventMap()); }
public void prefetchImage(string uriString, int requestId, IPromise promise) { promise.Reject(ErrorPrefetchFailure, "Prefetch is not yet implemented."); }
public void prefetchImage(string uriString, IPromise promise) { promise.Reject(ErrorPrefetchFailure, "Prefetch is not yet implemented."); }
public void queryCache(string[] urls, IPromise promise) { promise.Reject(ErrorQueryCacheFailure, "Prefetch is not yet implemented."); }
public IPromise<CompletionData> GetCompletions(string xml, string soapAction) { //var overlap = 0; if (string.IsNullOrEmpty(xml)) return Promises.Resolved<CompletionData>(new CompletionData()); var path = new List<AmlNode>(); string attr = null; string attrValue = null; var state = XmlUtils.ProcessFragment(xml, (r, o) => { switch (r.NodeType) { case XmlNodeType.Element: if (!r.IsEmptyElement) path.Add(new AmlNode() { LocalName = r.LocalName, Type = r.GetAttribute("type"), Action = r.GetAttribute("action") }); break; case XmlNodeType.EndElement: path.RemoveAt(path.Count - 1); break; case XmlNodeType.Attribute: attr = r.LocalName; attrValue = r.Value; break; } return true; }); if (state == XmlState.Tag && (xml.Last() == '"' || xml.Last() == '\'')) return Promises.Resolved<CompletionData>(new CompletionData()); IPromise<IEnumerable<string>> items = null; var filter = string.Empty; var multiValueAttribute = false; if (path.Count < 1) { switch (soapAction) { case "ApplySQL": items = StringPromise("sql"); break; case "ApplyAML": items = StringPromise("AML"); break; default: items = StringPromise("Item"); break; } } else { switch (state) { case XmlState.Attribute: case XmlState.AttributeStart: switch (path.Last().LocalName) { case "and": case "or": case "not": case "Relationships": case "AML": case "sql": case "SQL": break; case "Item": switch (soapAction) { case "GenerateNewGUIDEx": items = StringPromise("quantity"); break; case "": break; default: items = StringPromise(new string[] {"action" , "access_type" , "config_path" , "doGetItem" , "id" , "idlist" , "isCriteria" , "language" , "levels" , "maxRecords" , "page" , "pagesize" , "orderBy" , "queryDate" , "queryType" , "related_expand" , "select" , "serverEvents" , "type" , "typeID" , "version" , "where"} .Where(i => path.Last().Action == "getPermissions" || i != "access_type")); break; } break; default: items = StringPromise("condition", "is_null"); break; } filter = attr; break; case XmlState.AttributeValue: if (path.Last().LocalName == "Item") { ItemType itemType; switch (attr) { case "action": if (_methods == null && _conn != null) { _methods = _conn.ApplyAsync("<AML><Item action=\"get\" type=\"Method\" select=\"name\"></Item></AML>", true, false) .Convert(r => r.Items() .Select(m => m.Property("name").AsString(""))); } var baseMethods = new string[] {"ActivateActivity" , "add" , "AddItem" , "AddHistory" , "ApplyUpdate" , "BuildProcessReport" , "CancelWorkflow" , "checkImportedItemType" , "closeWorkflow" , "copy" , "copyAsIs" , "copyAsNew" , "create" , "delete" , "edit" , "EmailItem" , "EvaluateActivity" , "exportItemType" , "get" , "getItemAllVersions" , "getAffectedItems" , "GetItemConfig" , "getItemLastVersion" , "getItemNextStates" , "getItemRelationships" , "GetItemRepeatConfig" , "getItemWhereUsed" , "GetMappedPath" , "getPermissions" , "getRelatedItem" , "GetUpdateInfo" , "instantiateWorkflow" , "lock" , "merge" , "New Workflow Map" , "PromoteItem" , "purge" , "recache" , "replicate" , "resetAllItemsAccess" , "resetItemAccess" , "resetLifecycle" , "setDefaultLifecycle" , "skip" , "startWorkflow" , "unlock" , "update" , "ValidateWorkflowMap" , "version"}; items = _methods == null ? StringPromise(baseMethods) : _methods.Convert(m => m.Concat(baseMethods)); break; case "access_type": items = StringPromise("can_add", "can_delete", "can_get", "can_update"); break; case "doGetItem": case "version": case "isCriteria": case "related_expand": case "serverEvents": items = StringPromise("0", "1"); break; case "queryType": items = StringPromise("Effective", "Latest", "Released"); break; case "orderBy": if (!string.IsNullOrEmpty(path.Last().Type) && _itemTypes.TryGetValue(path.Last().Type, out itemType)) { var lastComma = attrValue.LastIndexOf(","); if (lastComma >= 0) attrValue = attrValue.Substring(lastComma + 1).Trim(); items = GetProperties(itemType) .Convert(p => p.SelectMany(i => new string[] { i.Name, i.Name + " DESC" })); } multiValueAttribute = true; break; case "select": if (!string.IsNullOrEmpty(path.Last().Type) && _itemTypes.TryGetValue(path.Last().Type, out itemType)) { string partial; var selectPath = SelectPath(attrValue, out partial); attrValue = partial; var itPromise = new Promise<ItemType>(); RecurseProperties(itemType, selectPath, it => itPromise.Resolve(it)); items = itPromise .Continue(it => GetProperties(it)) .Convert(p => p.Select(i => i.Name)); } multiValueAttribute = true; break; case "type": if (path.Count > 2 && path[path.Count - 3].LocalName == "Item" && path[path.Count - 2].LocalName == "Relationships") { if (!string.IsNullOrEmpty(path[path.Count - 3].Type) && _itemTypes.TryGetValue(path[path.Count - 3].Type, out itemType)) { items = StringPromise(itemType.Relationships.Select(r => r.Name)); } } else { items = StringPromise(_itemTypes.Select(i => i.Value.Name)); } break; case "where": if (!string.IsNullOrEmpty(path.Last().Type) && _itemTypes.TryGetValue(path.Last().Type, out itemType)) { items = GetProperties(itemType) .Convert(i => i.Select(p => "[" + itemType.Name + "].[" + p.Name + "]")); } multiValueAttribute = true; break; } } else { switch (attr) { case "condition": items = StringPromise("between" , "eq" , "ge" , "gt" , "in" , "is not null" , "is null" , "is" , "le" , "like" , "lt" , "ne" , "not between" , "not in" , "not like"); break; case "is_null": items = StringPromise("0", "1"); break; } } filter = attrValue; break; default: if (path.Count == 1 && path.First().LocalName == "AML") { items = StringPromise("Item"); } else { var j = path.Count - 1; while (path[j].LocalName == "and" || path[j].LocalName == "not" || path[j].LocalName == "or") j--; var last = path[j]; if (last.LocalName == "Item") { var buffer = new List<string>(); buffer.Add("Relationships"); if (last.Action == "get") { buffer.Add("and"); buffer.Add("not"); buffer.Add("or"); } ItemType itemType; if (!string.IsNullOrEmpty(last.Type) && _itemTypes.TryGetValue(last.Type, out itemType)) { items = GetProperties(itemType) .Convert(p => p.Select(i => i.Name).Concat(buffer)); } else { items = StringPromise(buffer); } } else if (path.Count > 1) { var lastItem = path.LastOrDefault(n => n.LocalName == "Item"); if (lastItem != null) { if (path.Last().LocalName == "Relationships") { items = StringPromise("Item"); } else { ItemType itemType; if (!string.IsNullOrEmpty(lastItem.Type) && _itemTypes.TryGetValue(lastItem.Type, out itemType)) { items = GetProperty(itemType, path.Last().LocalName) .Convert(p => { if (p.Type == PropertyType.item && p.Restrictions.Any()) { return p.Restrictions.Select(type => "Item type=\"" + type + "\""); } else { return Enumerable.Empty<string>(); } }); } } } } } break; } } if (items == null) return Promises.Resolved(new CompletionData()); return items.Convert(i => new CompletionData() { Items = string.IsNullOrEmpty(filter) ? i.OrderBy(j => j) : FilterAndSort(i, filter), MultiValueAttribute = multiValueAttribute, Overlap = (filter ?? "").Length, State = state }); }
public IPromise Each <T>(IPromise <IEnumerable <T> > items, Action <T> action) { return(items.Then(result => Each(result, action))); }