public BaseResponse(RespsonseStatus status = RespsonseStatus.Ok, ResponseError error = ResponseError.None, string errorMessage = "") { Status = status; ErrorCode = error; ErrorMessage = errorMessage; }
/// <summary> /// Deserialize items from byte array. /// </summary> /// <param name="byteArray">The byte array which contains response message.</param> /// <param name="currentIndex">The index special where to start.</param> /// <param name="lengthOfItems">The length of items.</param> protected override void DeserializeItemsFromByteArray(byte[] byteArray, ref int currentIndex, int lengthOfItems) { if (lengthOfItems != 0) { throw new ResponseParseErrorException(currentIndex, "ReadAccessResponse over-parse error", null); } int index = currentIndex; this.ReadResponseError = StreamObject.GetCurrent<ResponseError>(byteArray, ref index); currentIndex = index; }
/// <summary> /// Creates the error response from the values provided. /// /// If the errorCode is empty it will use the first validation error code, /// if there is none it will throw an error. /// </summary> /// <param name="errorCode">The error code.</param> /// <param name="errorMessage">The error message.</param> /// <param name="validationErrors">The validation errors.</param> /// <returns></returns> public static ResponseStatus CreateResponseStatus(string errorCode, string errorMessage, IEnumerable<ValidationErrorField> validationErrors) { var to = new ResponseStatus { ErrorCode = errorCode, Message = errorMessage, Errors = new List<ResponseError>(), }; if (validationErrors != null) { foreach (var validationError in validationErrors) { var error = new ResponseError { ErrorCode = validationError.ErrorCode, FieldName = validationError.FieldName, Message = validationError.ErrorMessage, }; to.Errors.Add(error); if (string.IsNullOrEmpty(to.ErrorCode)) { to.ErrorCode = validationError.ErrorCode; } if (string.IsNullOrEmpty(to.Message)) { to.Message = validationError.ErrorMessage; } } } if (string.IsNullOrEmpty(errorCode)) { if (string.IsNullOrEmpty(to.ErrorCode)) { throw new ArgumentException("Cannot create a valid error response with a en empty errorCode and an empty validationError list"); } } return to; }
public ServiceException(ResponseError errorCode) { ErrorCode = errorCode; }
public ProtocolException(ResponseError respError, String errorMessage) : this(respError.Key, errorMessage, null) { }
/// <summary> /// Occurs when a response returns an error code that does not fit into any other category, or an exception occurs during the response. /// </summary> /// <param name="e">Arguments for the event.</param> protected virtual void OnResponseError(ResponseEventArgs e) { ResponseError?.Invoke(this, e); }
public void SetError(ResponseError error, string errorMessage) { SetError(error); ErrorMessage = errorMessage; }
/// <summary> /// This method is used to test Response Error related adapter requirements. /// </summary> /// <param name="instance">Specify the instance which need to be verified.</param> /// <param name="site">Specify the ITestSite instance.</param> public void VerifyResponseError(ResponseError instance, ITestSite site) { // If the instance is not null and there are no parsing errors, then the Response Error related adapter requirements can be directly captured. if (null == instance) { site.Assert.Fail("The instance of type ResponseError is null due to parsing error or type casting error."); } // Verify the stream object header related requirements. this.ExpectStreamObjectHeaderStart(instance.StreamObjectHeaderStart, instance.GetType(), site); // Directly capture requirement MS-FSSHTTPB_R617, if the stream object header is StreamObjectHeaderStart32bit. site.CaptureRequirementIfAreEqual<Type>( typeof(StreamObjectHeaderStart32bit), instance.StreamObjectHeaderStart.GetType(), "MS-FSSHTTPB", 617, @"[In Response Error] Error Start (4 bytes): A 32-bit stream object header (section 2.2.1.5.2) that specifies an error start."); // Directly capture requirement MS-FSSHTTPB_R618, if there are no parsing errors. site.CaptureRequirement( "MS-FSSHTTPB", 618, @"[In Response Error] Error Type GUID (16 bytes): A GUID that specifies the error type."); bool responseErrorFlag = instance.ErrorTypeGUID == new Guid(ResponseError.CellErrorGuid) || instance.ErrorTypeGUID == new Guid(ResponseError.ProtocolErrorGuid) || instance.ErrorTypeGUID == new Guid(ResponseError.Win32ErrorGuid) || instance.ErrorTypeGUID == new Guid(ResponseError.HresultErrorGuid); site.Assert.IsTrue( responseErrorFlag, "Actual the error type guid {0}, which should be either 5A66A756-87CE-4290-A38B-C61C5BA05A67,7AFEAEBF-033D-4828-9C31-3977AFE58249, 32C39011-6E39-46C4-AB78-DB41929D679E or 8454C8F2-E401-405A-A198-A10B6991B56E for requirement MS-FSSHTTPB_R619", instance.ErrorTypeGUID.ToString()); // Directly capture requirement MS-FSSHTTPB_R619, if the responseErrorFlag is true; site.CaptureRequirementIfIsTrue( responseErrorFlag, "MS-FSSHTTPB", 619, @"[In Response Error] Error Type GUID (16 bytes): The following table contains the possible values for the error type: [the value of the Error Type GUID field must be {5A66A756-87CE-4290-A38B-C61C5BA05A67},{7AFEAEBF-033D-4828-9C31-3977AFE58249}, {32C39011-6E39-46C4-AB78-DB41929D679E}, {8454C8F2-E401-405A-A198-A10B6991B56E}."); switch (instance.ErrorTypeGUID.ToString("D").ToUpper(CultureInfo.CurrentCulture)) { case ResponseError.CellErrorGuid: // Capture requirement MS-FSSHTTPB_R620, if the error data type is CellError. site.CaptureRequirementIfAreEqual<Type>( typeof(CellError), instance.ErrorData.GetType(), "MS-FSSHTTPB", 620, @"[In Response Error] Error Type GUID field is set to {5A66A756-87CE-4290-A38B-C61C5BA05A67}[ specifies the error type is ]Cell error (section 2.2.3.2.1)."); break; case ResponseError.ProtocolErrorGuid: // All the serial number null values related requirements can be located here. site.Log.Add(LogEntryKind.Debug, "Runs for ProtocolErrorGuid verification logic with the error code {0}.", instance.ErrorData.ErrorDetail); break; case ResponseError.Win32ErrorGuid: // Capture requirement MS-FSSHTTPB_R622, if the error data type is Win32 error. site.CaptureRequirementIfAreEqual<Type>( typeof(Win32Error), instance.ErrorData.GetType(), "MS-FSSHTTPB", 622, @"[In Response Error] Error Type GUID field is set to {32C39011-6E39-46C4-AB78-DB41929D679E}[ specifies the error type is ]Win32 error (section 2.2.3.2.3)."); break; case ResponseError.HresultErrorGuid: // Capture requirement MS-FSSHTTPB_R623, if the error data type is HRESULTError. site.CaptureRequirementIfAreEqual<Type>( typeof(HRESULTError), instance.ErrorData.GetType(), "MS-FSSHTTPB", 623, @"[In Response Error] Error Type GUID field is set to {8454C8F2-E401-405A-A198-A10B6991B56E}[ specifies the error type is ]HRESULT error (section 2.2.3.2.4)."); break; default: site.Assert.Fail("Unsupported error type GUID " + instance.ErrorTypeGUID.ToString()); break; } // Directly capture requirement MS-FSSHTTPB_R625, if there are no parsing errors. site.CaptureRequirement( "MS-FSSHTTPB", 625, @"[In Response Error] Error Data (variable): A structure that specifies the error data based on the Error Type GUID."); if (instance.ChainedError != null) { // Directly capture requirement MS-FSSHTTPB_R631, if there are no parsing errors. site.CaptureRequirement( "MS-FSSHTTPB", 631, @"[In Response Error] Chained Error (variable): An optional response error that specifies the chained error information."); } // Verify the stream object header end related requirements. this.ExpectStreamObjectHeaderEnd(instance.StreamObjectHeaderEnd, instance.GetType(), site); this.ExpectCompoundObject(instance.StreamObjectHeaderStart, site); // Directly capture requirement MS-FSSHTTPB_R632, if the stream object end is StreamObjectHeaderEnd16bit. site.CaptureRequirementIfAreEqual<Type>( typeof(StreamObjectHeaderEnd16bit), instance.StreamObjectHeaderEnd.GetType(), "MS-FSSHTTPB", 632, @"[In Response Error] Error End (2 bytes): A 16-bit stream object header (section 2.2.1.5.4) that specifies an error end."); }
public JsonRpcRemoteException(ResponseError error) : this(error?.Message, error, null) { Initialize(); }
public JsonRpcRemoteException(string message, ResponseError error, Exception innerException) : base(message, innerException) { Error = error; }
internal ErrorResponse(ResponseError error) { Error = error; }
protected virtual bool TryHandleBusinessExceptionByPayload(ResponseError error, out Exception generatedException) { generatedException = null; return(false); }
private void SelectPlayer(Grant grant, List <LootLockerRewardObject> rewardObjects = null) { string header = ""; string normalTextMessage = ""; Dictionary <string, string> data = new Dictionary <string, string>(); string icon = grant == Grant.Credits ? creditsSprite : xpSprite; LootLockerSDKManager.StartSession(LootLockerConfig.current.deviceID, (response) => { LoadingManager.HideLoadingScreen(); if (response.success) { header = "Success"; if (grant == Grant.Credits) { normalTextMessage = "Successfully granted Credits."; } if (grant == Grant.XP) { normalTextMessage = "Successfully granted XP."; } data.Clear(); //Preparing data to display or error messages we have data.Add("1", normalTextMessage); StagesManager.instance.GoToStage(StagesManager.StageID.Home, response); if (rewardObjects != null && rewardObjects.Count > 0) { for (int i = 0; i < rewardObjects.Count; i++) { PopupData PopupData = new PopupData(); PopupData.buttonText = "Ok"; PopupData.url = rewardObjects[i].asset.links.thumbnail; PopupData.withKey = true; PopupData.normalText = new Dictionary <string, string>() { { "Reward", rewardObjects[i].asset.name } }; PopupData.header = "You got a reward"; PopupSystem.ShowScheduledPopup(PopupData); } } } else { header = "Failed"; string correctedResponse = response.Error.First() == '{' ? response.Error : response.Error.Substring(response.Error.IndexOf('{')); ResponseError errorMessage = new ResponseError(); errorMessage = JsonConvert.DeserializeObject <ResponseError>(correctedResponse); normalTextMessage = errorMessage.messages[0]; data.Clear(); //Preparing data to display or error messages we have data.Add("1", normalTextMessage); } PopupSystem.ShowApprovalFailPopUp(header, data, icon); }); }
public Status(ResponseError responseError) { CODE = responseError.CODE; DESC = responseError.DESC; }
public SocialSpiException(ResponseError error, String errorMessage) : base(errorMessage) { this.error = error; }
void Instance_onEncounterError(ResponseError data) { if(data.showPopup) DialogService.Instance.ShowDialog(new DialogMessage("Error: " + data.errorCode, data.errorMessage, null)); }
public void ProcessSubscriptionStatus(Session session, Message message) { IObserver <SubscriptionResponse> observer; if (!TryGet(message.CorrelationID, out observer)) { return; } if (MessageTypeNames.SubscriptionFailure.Equals(message.MessageType)) { var reasonElement = message.GetElement(ElementNames.Reason); var error = new ResponseError( reasonElement.GetElement(ElementNames.Source).GetValueAsString(), reasonElement.GetElement(ElementNames.Category).GetValueAsString(), null, reasonElement.GetElement(ElementNames.ErrorCode).GetValueAsInt32(), reasonElement.GetElement(ElementNames.Description).GetValueAsString()); var subscriptionFailure = new SubscriptionFailure(error); observer.OnNext(new SubscriptionResponse(message.TopicName, subscriptionFailure)); } else if (MessageTypeNames.SubscriptionTerminated.Equals(message.MessageType)) { var reason = message.GetElement(ElementNames.Reason); switch (reason.GetElementAsString(ElementNames.Category)) { case "LIMIT": var responseError = new ResponseError( reason.GetElement(ElementNames.Source).GetValueAsString(), reason.GetElement(ElementNames.Category).GetValueAsString(), null, reason.GetElement(ElementNames.ErrorCode).GetValueAsInt32(), reason.GetElement(ElementNames.Description).GetValueAsString()); observer.OnNext(new SubscriptionResponse(message.TopicName, new SubscriptionFailure(responseError))); break; case "UNCLASSIFIED": /* * "Failed to obtain initial paint" * If this error occurs, the Bloomberg Data Center * was unable to get the initial paint for the * subscription. You will still receive subscription * ticks. */ break; case "CANCELED": Remove(message.CorrelationID); observer.OnCompleted(); break; } } else if (MessageTypeNames.SubscriptionStarted.Equals(message.MessageType)) { if (message.HasElement(ElementNames.Exceptions)) { var fieldErrors = new Dictionary <string, ResponseError>(); var exceptionsArrayElement = message.GetElement(ElementNames.Exceptions); for (var i = 0; i < exceptionsArrayElement.NumValues; ++i) { var exceptionsElement = exceptionsArrayElement.GetValueAsElement(i); var fieldId = exceptionsElement.GetElementAsString(ElementNames.FieldId); var reasonElement = exceptionsElement.GetElement(ElementNames.Reason); var error = new ResponseError( reasonElement.GetElement(ElementNames.Source).GetValueAsString(), reasonElement.GetElement(ElementNames.Category).GetValueAsString(), reasonElement.GetElement(ElementNames.SubCategory).GetValueAsString(), reasonElement.GetElement(ElementNames.ErrorCode).GetValueAsInt32(), reasonElement.GetElement(ElementNames.Description).GetValueAsString()); fieldErrors.Add(fieldId, error); } var subscriptionFailure = new SubscriptionFailure(fieldErrors); observer.OnNext(new SubscriptionResponse(message.TopicName, subscriptionFailure)); } } }
public void SetError(ResponseError error) { Status = RespsonseStatus.Error; ErrorCode = error; }
public static async ValueTask <RequestFailedException> CreateExceptionForFailedOperationAsync(bool async, ClientDiagnostics diagnostics, Response response, ResponseError error) { var additionalInfo = new Dictionary <string, string>(1) { { "AdditionInformation", error.ToString() } }; return(async ? await diagnostics.CreateRequestFailedExceptionAsync(response, error, additionalInfo).ConfigureAwait(false) : diagnostics.CreateRequestFailedException(response, error, additionalInfo)); }
public TickerResponseError(string ticker, ResponseError responseError) { Ticker = ticker; ResponseError = responseError; }
public async Task GetAndListOperationsAsync() { string endpoint = TestEnvironment.Endpoint; string apiKey = TestEnvironment.ApiKey; #region Snippet:FormRecognizerSampleGetAndListOperations var client = new DocumentModelAdministrationClient(new Uri(endpoint), new AzureKeyCredential(apiKey)); // Make sure there is at least one operation, so we are going to build a custom model. #if SNIPPET Uri trainingFileUri = < trainingFileUri >; #else Uri trainingFileUri = new Uri(TestEnvironment.BlobContainerSasUrl); #endif BuildModelOperation operation = await client.StartBuildModelAsync(trainingFileUri, DocumentBuildMode.Template); await operation.WaitForCompletionAsync(); // List the first ten or fewer operations that have been executed in the last 24h. AsyncPageable <ModelOperationInfo> modelOperations = client.GetOperationsAsync(); string operationId = string.Empty; int count = 0; await foreach (ModelOperationInfo modelOperationInfo in modelOperations) { Console.WriteLine($"Model operation info:"); Console.WriteLine($" Id: {modelOperationInfo.OperationId}"); Console.WriteLine($" Kind: {modelOperationInfo.Kind}"); Console.WriteLine($" Status: {modelOperationInfo.Status}"); Console.WriteLine($" Percent completed: {modelOperationInfo.PercentCompleted}"); Console.WriteLine($" Created on: {modelOperationInfo.CreatedOn}"); Console.WriteLine($" LastUpdated on: {modelOperationInfo.LastUpdatedOn}"); Console.WriteLine($" Resource location of successful operation: {modelOperationInfo.ResourceLocation}"); if (count == 0) { operationId = modelOperationInfo.OperationId; } if (++count == 10) { break; } } // Get an operation by ID ModelOperation specificOperation = await client.GetOperationAsync(operationId); if (specificOperation.Status == DocumentOperationStatus.Succeeded) { Console.WriteLine($"My {specificOperation.Kind} operation is completed."); DocumentModel result = specificOperation.Result; Console.WriteLine($"Model ID: {result.ModelId}"); } else if (specificOperation.Status == DocumentOperationStatus.Failed) { Console.WriteLine($"My {specificOperation.Kind} operation failed."); ResponseError error = specificOperation.Error; Console.WriteLine($"Code: {error.Code}: Message: {error.Message}"); } else { Console.WriteLine($"My {specificOperation.Kind} operation status is {specificOperation.Status}"); } #endregion }