public AsyncOperationState <User, AccessProvider> Reduce(AsyncOperationState <User, AccessProvider> previousState, IAction action) { if (action is SetLoginStartAction) { var setLoginStartAction = action as SetLoginStartAction; return(previousState .Set(v => v.Value, setLoginStartAction.User) .Set(v => v.Status, setLoginStartAction.Status) .Set(v => v.Error, setLoginStartAction.Error) .Build()); } if (action is SetLoginCompleteAction) { var setLoginCompleteAction = action as SetLoginCompleteAction; return(previousState .Set(v => v.Error, setLoginCompleteAction.Error) .Set(v => v.Status, setLoginCompleteAction.Status) .Set(v => v.Value, setLoginCompleteAction.User) .Build()); } return(previousState); }
public AsyncOperationState <IList <Place>, long> Reduce(AsyncOperationState <IList <Place>, long> previousState, IAction action) { if (action is GetPlacesStartAction <long> ) { var getPlacesListByUserIdAction = action as GetPlacesStartAction <long>; return(previousState .Set(v => v.TriggerValue, getPlacesListByUserIdAction.Value) .Set(v => v.Status, getPlacesListByUserIdAction.Status) .Build()); } if (action is GetPlacesListByUserIdCompleteAction) { var getPlacesListByUserIdCompleteAction = action as GetPlacesListByUserIdCompleteAction; return(previousState .Set(v => v.Value, getPlacesListByUserIdCompleteAction.PlacesList) .Set(v => v.Status, getPlacesListByUserIdCompleteAction.Status) .Set(v => v.Error, getPlacesListByUserIdCompleteAction.Error) .Build()); } return(previousState); }
public AsyncOperationState <WrongPlaceReport, Unit> Reduce(AsyncOperationState <WrongPlaceReport, Unit> previousState, IAction action) { if (action is SetWrongPlaceReportStartAction) { var setWrongPlaceReportStartAction = action as SetWrongPlaceReportStartAction; return(previousState .Set(v => v.Status, setWrongPlaceReportStartAction.Status) .Set(v => v.Value, setWrongPlaceReportStartAction.WrongPlaceReport) .Set(v => v.Error, null) .Build()); } if (action is SetWrongPlaceReportCompleteAction) { var setWrongPlaceReportCompleteAction = action as SetWrongPlaceReportCompleteAction; return(previousState .Set(v => v.Status, setWrongPlaceReportCompleteAction.Status) .Set(v => v.Value, setWrongPlaceReportCompleteAction.WrongPlaceReport) .Set(v => v.Error, setWrongPlaceReportCompleteAction.Error) .Build()); } if (action is SetEmptyWrongPlaceReportAction) { return(previousState .Set(v => v.Status, Core.Enums.Status.Empty) .Set(v => v.Value, null) .Set(v => v.Error, null) .Build()); } return(previousState); }
internal void Reject(Exception reason) { Result = Handle(reason); if (Result.IsSuccessful) { Accept(Result.Value); } else { State = AsyncOperationState.Failed; while (_continuations.TryDequeue(out var continuation)) { continuation._complete(Result); } if (IsDone) { Async.Throw(reason); } lock (this) _otherwiseClause?.Accept(reason); } }
public AsyncOperationState <User, Unit> Reduce(AsyncOperationState <User, Unit> previousState, IAction action) { if (action is SetRegisterUserStartAction) { var setRegisterUserStartAction = action as SetRegisterUserStartAction; return(previousState .Set(v => v.Error, setRegisterUserStartAction.Error) .Set(v => v.Status, setRegisterUserStartAction.Status) .Set(v => v.Value, setRegisterUserStartAction.User) .Build()); } if (action is SetRegisterUserCompleteAction) { var setRegisterCompleteAction = action as SetRegisterUserCompleteAction; return(previousState .Set(v => v.Error, setRegisterCompleteAction.Error) .Set(v => v.Status, setRegisterCompleteAction.Status) .Set(v => v.Value, setRegisterCompleteAction.User) .Build()); } return(previousState); }
/// <summary> /// Constructor using fields /// </summary> /// <param name="exchangeRequest"></param> /// <param name="operationState"></param> public OperationStateEventArgs( ExchangeRequest exchangeRequest, AsyncOperationState operationState) { m_ExchangeRequest = exchangeRequest; m_OperationState = operationState; }
public AsyncOperationState <Place, int> Reduce(AsyncOperationState <Place, int> previousState, IAction action) { if (action is GetPlaceByIdStartAction) { var downloadPlaceByIdStartAction = action as GetPlaceByIdStartAction; return(previousState .Set(v => v.TriggerValue, downloadPlaceByIdStartAction.Id) .Set(v => v.Status, Status.Getting) .Build()); } if (action is GetPlaceByIdCompleteAction) { var downloadPlaceByIdCompleteAction = action as GetPlaceByIdCompleteAction; return(previousState .Set(v => v.Value, downloadPlaceByIdCompleteAction.Place) .Set(v => v.Status, downloadPlaceByIdCompleteAction.Status) .Set(v => v.Error, downloadPlaceByIdCompleteAction.Error) .Build()); } return(previousState); }
private void DeviceLocationSubscription() { appStore .DistinctUntilChanged(state => new { state.DeviceData.LocationState.Status }) .Subscribe(state => { AsyncOperationState <PermissionStatus, Unit> locationPermissionState = null; state.PermissionsDictionary.TryGetValue(PermissionName.Location, out locationPermissionState); var locationStatus = state.DeviceData.LocationState.Status; if ((locationStatus == Status.Empty || locationStatus == Status.Unknown) && locationPermissionState.Value == PermissionStatus.Granted) { appStore.DispatchAsync(deviceLocationActionCreator.RequestDeviceLocation(TimeSpan.FromSeconds(8))); } }, error => { appStore.Dispatch(new SetErrorAction(error, "Bootstrapper - DeviceLocationSubscription.")); }); appStore .DistinctUntilChanged(state => new { state.PermissionsDictionary[PermissionName.Location].Status }) .Subscribe(state => { AsyncOperationState <PermissionStatus, Unit> locationPermissionState = null; state.PermissionsDictionary.TryGetValue(PermissionName.Location, out locationPermissionState); var locationStatus = state.DeviceData.LocationState.Status; if (locationPermissionState.Value == PermissionStatus.Granted && (locationStatus == Status.Empty || locationStatus == Status.Error)) { appStore.DispatchAsync(deviceLocationActionCreator.RequestDeviceLocation(TimeSpan.FromSeconds(8))); } }, error => { appStore.Dispatch(new SetErrorAction(error, "Bootstrapper - DeviceLocationSubscription.")); }); }
public AsyncOperationState <IList <Place>, Criteria> Reduce(AsyncOperationState <IList <Place>, Criteria> previousState, IAction action) { if (action is GetPlacesStartAction <Criteria> ) { var downloadPlacesListByCriteriaStartAction = action as GetPlacesStartAction <Criteria>; return(previousState .Set(v => v.TriggerValue, downloadPlacesListByCriteriaStartAction.Value) .Set(v => v.Status, downloadPlacesListByCriteriaStartAction.Status) .Build()); } if (action is GetPlacesListByCriteriaCompleteAction) { var downloadPlacesListByCriteriaCompleteAction = action as GetPlacesListByCriteriaCompleteAction; return(previousState .Set(v => v.Value, downloadPlacesListByCriteriaCompleteAction.PlacesList) .Set(v => v.Status, downloadPlacesListByCriteriaCompleteAction.Status) .Set(v => v.Error, downloadPlacesListByCriteriaCompleteAction.Error) .Build()); } return(previousState); }
internal TenantConfigurationState ToTenantConfigurationState(AsyncOperationState state) { TenantConfigurationState tenantState; switch (state) { case AsyncOperationState.Started: tenantState = TenantConfigurationState.Started; break; case AsyncOperationState.InProgress: tenantState = TenantConfigurationState.InProgress; break; case AsyncOperationState.Succeeded: tenantState = TenantConfigurationState.Succeeded; break; case AsyncOperationState.Failed: tenantState = TenantConfigurationState.Failed; break; default: throw new NotSupportedException("Invalid State :" + state); } return(tenantState); }
public void Dispatch(object?arg) { if (State == AsyncOperationState.Initial) { State = AsyncOperationState.Dispatched; Operator !.Dispatch(arg, _complete); } }
internal void Accept(object?result) { State = AsyncOperationState.Completed; Result = AsyncOperationResult.Success(result); while (_continuations.TryDequeue(out var continuation)) { continuation.Dispatch(Result.Value); } }
public void Abort() { if (State == AsyncOperationState.Aborted) { return; } if (State == AsyncOperationState.Dispatched) { Operator !.Cancel(); } State = AsyncOperationState.Aborted; foreach (var continuation in _continuations) { continuation.Abort(); } }
/// <summary> /// Convert an enum of type AsyncOperationState to a string. /// </summary> /// <param name='value'> /// The value to convert to a string. /// </param> /// <returns> /// The enum value as a string. /// </returns> internal static string AsyncOperationStateToString(AsyncOperationState value) { if (value == AsyncOperationState.Started) { return("Started"); } if (value == AsyncOperationState.InProgress) { return("InProgress"); } if (value == AsyncOperationState.Succeeded) { return("Succeeded"); } if (value == AsyncOperationState.Failed) { return("Failed"); } throw new ArgumentOutOfRangeException("value"); }
internal TenantConfigurationState ToTenantConfigurationState(AsyncOperationState state) { TenantConfigurationState tenantState; switch (state) { case AsyncOperationState.Started: tenantState = TenantConfigurationState.Started; break; case AsyncOperationState.InProgress: tenantState = TenantConfigurationState.InProgress; break; case AsyncOperationState.Succeeded: tenantState = TenantConfigurationState.Succeeded; break; case AsyncOperationState.Failed: tenantState = TenantConfigurationState.Failed; break; default: throw new NotSupportedException("Invalid State :" + state); } return tenantState; }
internal static string ToSerializedValue(this AsyncOperationState value) { switch (value) { case AsyncOperationState.NotStarted: return("NotStarted"); case AsyncOperationState.Running: return("Running"); case AsyncOperationState.Cancelled: return("Cancelled"); case AsyncOperationState.Succeeded: return("Succeeded"); case AsyncOperationState.Failed: return("Failed"); case AsyncOperationState.TimedOut: return("TimedOut"); } return(null); }
public void Wait() { var result = _Wait(); if (!result.IsSuccessful) { result = Handle(result.Error !); } if (result.IsSuccessful) { Accept(result.Value); } else { result = Handle(result.Error !); State = AsyncOperationState.Failed; while (_continuations.TryDequeue(out var continuation)) { continuation._complete(result); } throw new AsyncException(result.Error !); } }
public EventMessage(OperationStateEventArgs evt, AsyncEvents eventType) { m_ExchangeRequest = evt.ExchangeRequest; m_OperationState = evt.OperationState; m_EventType = eventType; }
public AsyncOperationState <Report, Unit> Reduce(AsyncOperationState <Report, Unit> previousState, IAction action) { if (action is SetNewReportAction) { return(previousState .Set(v => v.Value, new Report(null, null, Core.Enums.ReportType.Create)) .Build()); } if (action is SetUpdateReportPlaceAction) { var setUpdateReportPlaceAction = action as SetUpdateReportPlaceAction; return(previousState .Set(v => v.Value, new Report(setUpdateReportPlaceAction.Place, setUpdateReportPlaceAction.Place.Location, Core.Enums.ReportType.Update)) .Build()); } if (action is SetReportPlaceAction) { var passPlaceToReportAction = action as SetReportPlaceAction; var newReportObject = previousState.Value .Set(v => v.Place, passPlaceToReportAction.Place) .Build(); return(previousState .Set(v => v.Value, newReportObject) .Build()); } if (action is SetReportUserAction) { var setReportUserAction = action as SetReportUserAction; var updatedPlace = previousState.Value.Place; updatedPlace.UserId = setReportUserAction.User.Id; var newReportObject = previousState.Value .Set(v => v.Place, updatedPlace) .Build(); return(previousState .Set(v => v.Value, newReportObject) .Build()); } if (action is SetReportLocationAction) { //TODO: Place HAVE TO be immutable. var updateLocationInReportAction = action as SetReportLocationAction; previousState.Value.Place.Location = updateLocationInReportAction.Location; var newReportObject = previousState.Value .Set(v => v.Location, updateLocationInReportAction.Location) .Build(); return(previousState .Set(v => v.Value, newReportObject) .Build()); } return(previousState); }
/// <summary> /// The Get Operation Status operation returns the status of the /// specified operation. After calling an asynchronous operation, you /// can call Get Operation Status to determine whether the operation /// has succeeded, failed, or is still in progress. /// </summary> /// <param name='operationStatusLink'> /// Required. Location value returned by the Begin operation. /// </param> /// <param name='cancellationToken'> /// Cancellation token. /// </param> /// <returns> /// The azure async operation response. /// </returns> public async Task <OperationResource> GetLongRunningOperationStatusAsync(string operationStatusLink, CancellationToken cancellationToken) { // Validate if (operationStatusLink == null) { throw new ArgumentNullException("operationStatusLink"); } // Tracing bool shouldTrace = TracingAdapter.IsEnabled; string invocationId = null; if (shouldTrace) { invocationId = TracingAdapter.NextInvocationId.ToString(); Dictionary <string, object> tracingParameters = new Dictionary <string, object>(); tracingParameters.Add("operationStatusLink", operationStatusLink); TracingAdapter.Enter(invocationId, this, "GetLongRunningOperationStatusAsync", tracingParameters); } // Construct URL string url = ""; url = url + operationStatusLink; url = url.Replace(" ", "%20"); // Create HTTP transport objects HttpRequestMessage httpRequest = null; try { httpRequest = new HttpRequestMessage(); httpRequest.Method = HttpMethod.Get; httpRequest.RequestUri = new Uri(url); // Set Headers httpRequest.Headers.Add("x-ms-version", "2015-03-01-preview"); // Set Credentials cancellationToken.ThrowIfCancellationRequested(); await this.Credentials.ProcessHttpRequestAsync(httpRequest, cancellationToken).ConfigureAwait(false); // Send Request HttpResponseMessage httpResponse = null; try { if (shouldTrace) { TracingAdapter.SendRequest(invocationId, httpRequest); } cancellationToken.ThrowIfCancellationRequested(); httpResponse = await this.HttpClient.SendAsync(httpRequest, cancellationToken).ConfigureAwait(false); if (shouldTrace) { TracingAdapter.ReceiveResponse(invocationId, httpResponse); } HttpStatusCode statusCode = httpResponse.StatusCode; if (statusCode != HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); CloudException ex = CloudException.Create(httpRequest, null, httpResponse, await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false)); if (shouldTrace) { TracingAdapter.Error(invocationId, ex); } throw ex; } // Create Result OperationResource result = null; // Deserialize Response if (statusCode == HttpStatusCode.OK) { cancellationToken.ThrowIfCancellationRequested(); string responseContent = await httpResponse.Content.ReadAsStringAsync().ConfigureAwait(false); result = new OperationResource(); JToken responseDoc = null; if (string.IsNullOrEmpty(responseContent) == false) { responseDoc = JToken.Parse(responseContent); } if (responseDoc != null && responseDoc.Type != JTokenType.Null) { JToken statusValue = responseDoc["status"]; if (statusValue != null && statusValue.Type != JTokenType.Null) { AsyncOperationState statusInstance = ((AsyncOperationState)Enum.Parse(typeof(AsyncOperationState), ((string)statusValue), true)); result.State = statusInstance; } JToken errorValue = responseDoc["error"]; if (errorValue != null && errorValue.Type != JTokenType.Null) { ErrorInfo errorInstance = new ErrorInfo(); result.ErrorInfo = errorInstance; JToken codeValue = errorValue["code"]; if (codeValue != null && codeValue.Type != JTokenType.Null) { string codeInstance = ((string)codeValue); errorInstance.Code = codeInstance; } JToken messageValue = errorValue["message"]; if (messageValue != null && messageValue.Type != JTokenType.Null) { string messageInstance = ((string)messageValue); errorInstance.Message = messageInstance; } } } } result.StatusCode = statusCode; if (httpResponse.Headers.Contains("x-ms-request-id")) { result.RequestId = httpResponse.Headers.GetValues("x-ms-request-id").FirstOrDefault(); } if (shouldTrace) { TracingAdapter.Exit(invocationId, result); } return(result); } finally { if (httpResponse != null) { httpResponse.Dispose(); } } } finally { if (httpRequest != null) { httpRequest.Dispose(); } } }