public void SetsSpecifiedExceptionMessageAndStatusCode() { var exception = new ApiException("Shit still broke", HttpStatusCode.Gone); Assert.Equal("Shit still broke", exception.Message); Assert.Equal(HttpStatusCode.Gone, exception.StatusCode); }
protected void HandleBadRequest(ApiException apiException) { if (apiException.StatusCode == HttpStatusCode.BadRequest) { //There are, at the moment, two types of bad requests: when signing in, JsonData might contain an error and error_description field. //When returning a BadRequest from the Web API, we'll get a message and ModelState error dictionary back. var badRequestData = JsonConvert.DeserializeObject<JsonBadRequest>(apiException.JsonData); if (badRequestData.ModelState != null) { foreach (var modelStateItem in badRequestData.ModelState) { foreach (var message in modelStateItem.Value) { ModelState.AddModelError(modelStateItem.Key, message); } } } //When an error occurs while signing in, Error equals "invalid_grant" and ErrorDescription will contain more detail. //This error is being set in the Web API project in the YetAnotherTodo.WebApi.Providers.ApplicationOAuthProvider class if (string.Equals(badRequestData.Error, "invalid_grant")) { ModelState.AddModelError("", badRequestData.ErrorDescription); } } }
public static Exception GetCustomTestException(ApiException apiException, string currentClassName, string currentMethodName, HttpStatusCode expectedCode) { var correlationId = apiException.CorrelationId; var printableError = string.Format("{0} || {1}.{2} {3} | Error: {4} | CorrelationId: {5}", apiException.HttpStatusCode.ToString(), currentClassName, currentMethodName, apiException.ApplicationName ?? "", apiException.Message ?? "", correlationId ); Debug.WriteLine(printableError); switch (apiException.HttpStatusCode) { case HttpStatusCode.NotFound: return null; // or use new Exception("No Item Found with API transaction.") ; case HttpStatusCode.NoContent: return null; // or use new Exception("No Content was returned by the API") ; case HttpStatusCode.Unauthorized: return new Exception("Unauthorized Access To this API, Please check your behaviors and possibly re-install the application to this store to pick up changes."); case HttpStatusCode.Forbidden: return new Exception("Forbidden Access To this API, Please check your SiteId settings and possibly re-install the application to this store."); default: return new Exception(String.Format("Test Fails - [{0}:expected {1}] but the actual return code is {2}. {3}", currentMethodName, expectedCode.ToString(), apiException.HttpStatusCode, printableError)); } }
public void SetsSpecifiedExceptionMessageAndInnerException() { var inner = new InvalidOperationException(); var exception = new ApiException("Shit broke", inner); Assert.Equal("Shit broke", exception.Message); Assert.Same(inner, exception.InnerException); }
protected virtual ErrorMessage CreateErrorMessage(ApiException ae, Exception e) { HttpContext context = HttpContext.Current; return new ErrorMessage { Message = ae.Message, ErrorCode = (int)ae.StatusCode, Exception = (context != null && context.IsDebuggingEnabled) ? CreateErrorException(e) : null }; }
public void CreatesGitHubErrorIfResponseMessageIsNotValidJson(string responseContent) { var response = new Response( HttpStatusCode.GatewayTimeout, responseContent, new Dictionary<string, string>(), "application/json"); var exception = new ApiException(response); Assert.Equal(responseContent, exception.ApiError.Message); Assert.Equal(HttpStatusCode.GatewayTimeout, exception.StatusCode); }
public void CreatesGitHubErrorIfResponseMessageIsNotValidJson(string responseContent) { var response = new ApiResponse<object> { Body = responseContent, StatusCode = HttpStatusCode.GatewayTimeout }; var exception = new ApiException(response); Assert.Equal(responseContent, exception.ApiError.Message); Assert.Equal(HttpStatusCode.GatewayTimeout, exception.StatusCode); }
private static bool ContainsNameEmptyValidationError(ApiException ex) { ex.StatusCode.Should().Be(HttpStatusCode.BadRequest); var validationErrors = ex.GetContentAs<IDictionary<string, IDictionary<string, string[]>>>(); validationErrors.Should().HaveCount(1); validationErrors.First().Key.Should().Be("errors"); validationErrors.First().Value.Should().HaveCount(1); validationErrors.First().Value.Should().ContainKey("name"); validationErrors.First().Value.First().Value.Should().Contain("'Name' should not be empty."); return true; }
public void CreatesEmptyGitHubErrorWhenResponseBodyIsNull() { var response = Substitute.For<IResponse>(); response.Body.Returns("test"); var exception = new ApiException(); var anotherException = new ApiException(new ApiResponse<object> { Body = "message1" }); var thirdException = new ApiException(new ApiResponse<object> { Body = "message2" }); // It's fine if the message is null when there's no response body as long as this doesn't throw. Assert.Null(exception.ApiError.Message); Assert.Equal("message1", anotherException.ApiError.Message); Assert.Equal("message2", thirdException.ApiError.Message); }
public ValidationException(ApiException apiException) : base(apiException) { if (apiException.Elements != null && apiException.Elements.Any()) { ValidationErrors = new List<ValidationError>(); foreach (var ve in apiException .Elements .SelectMany(e => e.ValidationErrors)) { ValidationErrors.Add(ve); } } }
public void CreatesGitHubErrorFromJsonResponse() { var response = new ApiResponse<object> { Body = @"{""errors"":[{""code"":""custom"",""field"":""key"",""message"":""key is " + @"already in use"",""resource"":""PublicKey""}],""message"":""Validation Failed""}", StatusCode = HttpStatusCode.GatewayTimeout }; var exception = new ApiException(response); Assert.Equal("Validation Failed", exception.ApiError.Message); Assert.Equal("key is already in use", exception.ApiError.Errors.First().Message); Assert.Equal(HttpStatusCode.GatewayTimeout, exception.StatusCode); }
public void CreatesGitHubErrorFromJsonResponse() { var response = new Response( HttpStatusCode.GatewayTimeout, @"{""errors"":[{""code"":""custom"",""field"":""key"",""message"":""key is " + @"already in use"",""resource"":""PublicKey""}],""message"":""Validation Failed""}", new Dictionary<string, string>(), "application/json" ); var exception = new ApiException(response); Assert.Equal("Validation Failed", exception.ApiError.Message); Assert.Equal("key is already in use", exception.ApiError.Errors.First().Message); Assert.Equal(HttpStatusCode.GatewayTimeout, exception.StatusCode); }
public static async Task EnsureSuccessAsync(HttpResponseMessage response, IApiContext apiContext) { if (!response.IsSuccessStatusCode) { var content = await response.Content.ReadAsStringAsync(); ApiException exception; var htmlMediaType = new MediaTypeHeaderValue("text/html"); if (response.Content.Headers.ContentType != null && response.Content.Headers.ContentType.MediaType == htmlMediaType.MediaType) { var message = String.Format("Status Code {0}, Uri - {1}", response.StatusCode, response.RequestMessage.RequestUri.AbsoluteUri); exception = new ApiException(message, new Exception(content)); } else exception = JsonConvert.DeserializeObject<ApiException>(content); exception.HttpStatusCode = response.StatusCode; exception.CorrelationId = HttpHelper.GetHeaderValue(Headers.X_VOL_CORRELATION, response.Headers); exception.ApiContext = apiContext; throw exception; } }
public ValidationException(ApiException apiException) : base(apiException) { if (apiException.Elements != null && apiException.Elements.Any()) { ValidationErrors = new List<ValidationError>(); AccountNumbers = new List<string>(); foreach (var ve in apiException .Elements .SelectMany(e => e.ValidationErrors)) { ValidationErrors.Add(ve); } foreach(var an in apiException .Elements .Select(e => e.AccountNumber)) { AccountNumbers.Add(an); } } }
/// <summary> /// Creates and send an HTTP request to the specified URL /// </summary> /// <param name="httpMethod">A valid HTTP method</param> /// <param name="url">Target URL</param> /// <param name="parameters">Optional request data</param> /// <returns>Response string</returns> /// <exception cref="ApiException">Thrown when an exception occurs at server</exception> /// <exception cref="NetworkException">Thrown when server is unreachable</exception> public static string SendRequest(string httpMethod, string url, Dictionary <string, object> parameters) { httpMethod = httpMethod.ToUpper(); if (httpMethod == "GET") { url = AppendUrlParameters(url, parameters); } ConfigureTls(); var webRequest = HttpWebRequestFactory(url); webRequest.Method = httpMethod; webRequest.Credentials = new NetworkCredential(ApiKey, ""); if (httpMethod != "GET" && parameters != null) { webRequest.ContentType = "application/json"; using (var sw = new StreamWriter(webRequest.GetRequestStream())) { sw.Write(Serializer.Serialize(parameters)); sw.Flush(); } } try { string result = null; HttpWebResponse response = webRequest.GetResponse() as HttpWebResponse; using (var sr = new StreamReader(response.GetResponseStream())) { result = sr.ReadToEnd(); } return(result); } catch (WebException ex) { if (ex.Status == WebExceptionStatus.ProtocolError) { string result = null; var response = ex.Response as HttpWebResponse; using (var sr = new StreamReader(response.GetResponseStream())) { result = sr.ReadToEnd(); } if ((int)response.StatusCode == 429) { throw new TooManyRequestsException("Too Many Requests") { HttpStatusCode = (int)response.StatusCode, ResponsePayload = result }; } if ((int)response.StatusCode >= 400 && (int)response.StatusCode < 600) { dynamic resObj = Serializer.Deserialize <object>(result); var msg = ""; try { msg = resObj.message; } catch {} var exception = new ApiException(msg) { HttpStatusCode = (int)response.StatusCode, ResponsePayload = result, }; try { exception.Type = resObj.type.ToString(); } catch {} try { exception.Errors = resObj.errors.ToString(); } catch {} try { exception.ErrorsDictionary = Serializer.Deserialize <Dictionary <string, List <string> > >(resObj.errors.ToString()); } catch {} throw exception; } } throw new NetworkException("Could not connect to Moyasar service", ex); } }
/// <summary> /// Add a CustomerFeed that associates the feed with this customer for /// the LOCATION placeholder type. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="feed">The GMB feed.</param> void AddCustomerFeed(AdWordsUser user, Feed feed) { using (CustomerFeedService customerFeedService = (CustomerFeedService)user.GetService( AdWordsService.v201802.CustomerFeedService)) { // Add a CustomerFeed that associates the feed with this customer for // the LOCATION placeholder type. CustomerFeed customerFeed = new CustomerFeed(); customerFeed.feedId = feed.id; customerFeed.placeholderTypes = new int[] { PLACEHOLDER_LOCATION }; // Create a matching function that will always evaluate to true. Function customerMatchingFunction = new Function(); ConstantOperand constOperand = new ConstantOperand(); constOperand.type = ConstantOperandConstantType.BOOLEAN; constOperand.booleanValue = true; customerMatchingFunction.lhsOperand = new FunctionArgumentOperand[] { constOperand }; customerMatchingFunction.@operator = FunctionOperator.IDENTITY; customerFeed.matchingFunction = customerMatchingFunction; // Create an operation to add the customer feed. CustomerFeedOperation customerFeedOperation = new CustomerFeedOperation(); customerFeedOperation.operand = customerFeed; customerFeedOperation.@operator = Operator.ADD; // After the completion of the Feed ADD operation above the added feed // will not be available for usage in a CustomerFeed until the sync // between the AdWords and GMB accounts completes. The loop below // will retry adding the CustomerFeed up to ten times with an // exponential back-off policy. CustomerFeed addedCustomerFeed = null; AdWordsAppConfig config = new AdWordsAppConfig(); config.RetryCount = 10; ErrorHandler errorHandler = new ErrorHandler(config); try { do { try { CustomerFeedReturnValue customerFeedResult = customerFeedService.mutate( new CustomerFeedOperation[] { customerFeedOperation }); addedCustomerFeed = customerFeedResult.value[0]; Console.WriteLine("Added CustomerFeed for feed ID {0} and placeholder type {1}", addedCustomerFeed.feedId, addedCustomerFeed.placeholderTypes[0]); break; } catch (AdWordsApiException e) { ApiException apiException = (ApiException)e.ApiException; foreach (ApiError error in apiException.errors) { if (error is CustomerFeedError) { if ((error as CustomerFeedError).reason == CustomerFeedErrorReason.MISSING_FEEDMAPPING_FOR_PLACEHOLDER_TYPE) { errorHandler.DoExponentialBackoff(); errorHandler.IncrementRetriedAttempts(); } else { throw; } } } } } while (errorHandler.HaveMoreRetryAttemptsLeft()); // OPTIONAL: Create a CampaignFeed to specify which FeedItems to use at // the Campaign level. This will be similar to the CampaignFeed in the // AddSiteLinks example, except you can also filter based on the // business name and category of each FeedItem by using a // FeedAttributeOperand in your matching function. // OPTIONAL: Create an AdGroupFeed for even more fine grained control // over which feed items are used at the AdGroup level. } catch (Exception e) { throw new System.ApplicationException("Failed to create customer feed.", e); } } }
/// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">Id of the ad group to which ads are added. /// </param> public void Run(AdWordsUser user, long adGroupId) { // Get the AdGroupAdService. AdGroupAdService service = (AdGroupAdService)user.GetService(AdWordsService.v201502.AdGroupAdService); // Create the third party redirect ad that violates a policy. ThirdPartyRedirectAd redirectAd = new ThirdPartyRedirectAd(); redirectAd.name = "Policy violation demo ad " + ExampleUtilities.GetRandomString(); redirectAd.url = "gopher://gopher.google.com"; redirectAd.dimensions = new Dimensions(); redirectAd.dimensions.width = 300; redirectAd.dimensions.height = 250; redirectAd.snippet = "<img src=\"https://sandbox.google.com/sandboximages/image.jpg\"/>"; redirectAd.impressionBeaconUrl = "http://www.examples.com/beacon1"; redirectAd.certifiedVendorFormatId = 119; redirectAd.isCookieTargeted = false; redirectAd.isUserInterestTargeted = false; redirectAd.isTagged = false; AdGroupAd redirectAdGroupAd = new AdGroupAd(); redirectAdGroupAd.adGroupId = adGroupId; redirectAdGroupAd.ad = redirectAd; // Create the operations. AdGroupAdOperation redirectAdOperation = new AdGroupAdOperation(); redirectAdOperation.@operator = Operator.ADD; redirectAdOperation.operand = redirectAdGroupAd; try { AdGroupAdReturnValue retVal = null; // Setup two arrays, one to hold the list of all operations to be // validated, and another to hold the list of operations that cannot be // fixed after validation. List <AdGroupAdOperation> allOperations = new List <AdGroupAdOperation>(); List <AdGroupAdOperation> operationsToBeRemoved = new List <AdGroupAdOperation>(); allOperations.Add(redirectAdOperation); try { // Validate the operations. service.RequestHeader.validateOnly = true; retVal = service.mutate(allOperations.ToArray()); } catch (AdWordsApiException ex) { ApiException innerException = ex.ApiException as ApiException; if (innerException == null) { throw new Exception("Failed to retrieve ApiError. See inner exception for more " + "details.", ex); } // Examine each ApiError received from the server. foreach (ApiError apiError in innerException.errors) { int index = ErrorUtilities.GetOperationIndex(apiError.fieldPath); if (index == -1) { // This API error is not associated with an operand, so we cannot // recover from this error by removing one or more operations. // Rethrow the exception for manual inspection. throw; } // Handle policy violation errors. if (apiError is PolicyViolationError) { PolicyViolationError policyError = (PolicyViolationError)apiError; if (policyError.isExemptable) { // If the policy violation error is exemptable, add an exemption // request. List <ExemptionRequest> exemptionRequests = new List <ExemptionRequest>(); if (allOperations[index].exemptionRequests != null) { exemptionRequests.AddRange(allOperations[index].exemptionRequests); } ExemptionRequest exemptionRequest = new ExemptionRequest(); exemptionRequest.key = policyError.key; exemptionRequests.Add(exemptionRequest); allOperations[index].exemptionRequests = exemptionRequests.ToArray(); } else { // Policy violation error is not exemptable, remove this // operation from the list of operations. operationsToBeRemoved.Add(allOperations[index]); } } else { // This is not a policy violation error, remove this operation // from the list of operations. operationsToBeRemoved.Add(allOperations[index]); } } // Remove all operations that aren't exemptable. foreach (AdGroupAdOperation operation in operationsToBeRemoved) { allOperations.Remove(operation); } } if (allOperations.Count > 0) { // Perform the operations exemptible of a policy violation. service.RequestHeader.validateOnly = false; retVal = service.mutate(allOperations.ToArray()); // Display the results. if (retVal != null && retVal.value != null && retVal.value.Length > 0) { foreach (AdGroupAd newAdGroupAd in retVal.value) { Console.WriteLine("New ad with id = \"{0}\" and displayUrl = \"{1}\" was created.", newAdGroupAd.ad.id, newAdGroupAd.ad.displayUrl); } } else { Console.WriteLine("No ads were created."); } } else { Console.WriteLine("There are no ads to create after policy violation checks."); } } catch (Exception ex) { throw new System.ApplicationException("Failed to create ads.", ex); } }
public Dictionary<string, string> OnApiFailed(ApiException apiException) { CanCancel = false; return HandleApiError(new Dictionary<string, string>(), apiException); }
/// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="gmbEmailAddress">The email address for Google My Business /// account.</param> /// <param name="gmbAccessToken">The OAuth2 access token for Google /// My Business account.</param> /// <param name="businessAccountIdentifier">The account identifier for /// Google My Business account.</param> public void Run(AdWordsUser user, string gmbEmailAddress, string gmbAccessToken, string businessAccountIdentifier) { FeedService feedService = (FeedService)user.GetService(AdWordsService.v201605.FeedService); CustomerFeedService customerFeedService = (CustomerFeedService)user.GetService( AdWordsService.v201605.CustomerFeedService); // Create a feed that will sync to the Google My Business account // specified by gmbEmailAddress. Do not add FeedAttributes to this object, // as AdWords will add them automatically because this will be a // system generated feed. Feed gmbFeed = new Feed(); gmbFeed.name = String.Format("Google My Business feed #{0}", ExampleUtilities.GetRandomString()); PlacesLocationFeedData feedData = new PlacesLocationFeedData(); feedData.emailAddress = gmbEmailAddress; feedData.businessAccountIdentifier = businessAccountIdentifier; // Optional: specify labels to filter Google My Business listings. If // specified, only listings that have any of the labels set are // synchronized into FeedItems. feedData.labelFilters = new string[] { "Stores in New York City" }; OAuthInfo oAuthInfo = new OAuthInfo(); oAuthInfo.httpMethod = "GET"; // Permissions for the AdWords API scope will also cover GMB. oAuthInfo.httpRequestUrl = user.Config.GetDefaultOAuth2Scope(); oAuthInfo.httpAuthorizationHeader = string.Format("Bearer {0}", gmbAccessToken); feedData.oAuthInfo = oAuthInfo; gmbFeed.systemFeedGenerationData = feedData; // Since this feed's feed items will be managed by AdWords, // you must set its origin to ADWORDS. gmbFeed.origin = FeedOrigin.ADWORDS; // Create an operation to add the feed. FeedOperation feedOperation = new FeedOperation(); feedOperation.operand = gmbFeed; feedOperation.@operator = Operator.ADD; try { // Add the feed. Since it is a system generated feed, AdWords will // automatically: // 1. Set up the FeedAttributes on the feed. // 2. Set up a FeedMapping that associates the FeedAttributes of the // feed with the placeholder fields of the LOCATION placeholder // type. FeedReturnValue addFeedResult = feedService.mutate(new FeedOperation[] { feedOperation }); Feed addedFeed = addFeedResult.value[0]; Console.WriteLine("Added GMB feed with ID {0}", addedFeed.id); // Add a CustomerFeed that associates the feed with this customer for // the LOCATION placeholder type. CustomerFeed customerFeed = new CustomerFeed(); customerFeed.feedId = addedFeed.id; customerFeed.placeholderTypes = new int[] { PLACEHOLDER_LOCATION }; // Create a matching function that will always evaluate to true. Function customerMatchingFunction = new Function(); ConstantOperand constOperand = new ConstantOperand(); constOperand.type = ConstantOperandConstantType.BOOLEAN; constOperand.booleanValue = true; customerMatchingFunction.lhsOperand = new FunctionArgumentOperand[] { constOperand }; customerMatchingFunction.@operator = FunctionOperator.IDENTITY; customerFeed.matchingFunction = customerMatchingFunction; // Create an operation to add the customer feed. CustomerFeedOperation customerFeedOperation = new CustomerFeedOperation(); customerFeedOperation.operand = customerFeed; customerFeedOperation.@operator = Operator.ADD; // After the completion of the Feed ADD operation above the added feed // will not be available for usage in a CustomerFeed until the sync // between the AdWords and GMB accounts completes. The loop below // will retry adding the CustomerFeed up to ten times with an // exponential back-off policy. CustomerFeed addedCustomerFeed = null; AdWordsAppConfig config = new AdWordsAppConfig(); config.RetryCount = 10; ErrorHandler errorHandler = new ErrorHandler(config); do { try { CustomerFeedReturnValue customerFeedResult = customerFeedService.mutate(new CustomerFeedOperation[] { customerFeedOperation }); addedCustomerFeed = customerFeedResult.value[0]; Console.WriteLine("Added CustomerFeed for feed ID {0} and placeholder type {1}", addedCustomerFeed.feedId, addedCustomerFeed.placeholderTypes[0]); break; } catch (AdWordsApiException e) { ApiException apiException = (ApiException)e.ApiException; foreach (ApiError error in apiException.errors) { if (error is CustomerFeedError) { if ((error as CustomerFeedError).reason == CustomerFeedErrorReason.MISSING_FEEDMAPPING_FOR_PLACEHOLDER_TYPE) { errorHandler.DoExponentialBackoff(); errorHandler.IncrementRetriedAttempts(); } else { throw; } } } } } while (errorHandler.HaveMoreRetryAttemptsLeft()); // OPTIONAL: Create a CampaignFeed to specify which FeedItems to use at // the Campaign level. This will be similar to the CampaignFeed in the // AddSiteLinks example, except you can also filter based on the // business name and category of each FeedItem by using a // FeedAttributeOperand in your matching function. // OPTIONAL: Create an AdGroupFeed for even more fine grained control // over which feed items are used at the AdGroup level. } catch (Exception e) { throw new System.ApplicationException("Failed to create customer feed.", e); } }
/// <summary> /// The result of a job execution. The result of a job execution. /// </summary> /// <exception cref="IO.Swagger.Client.ApiException">Thrown when fails to make API call</exception> /// <param name="id">The id of a process</param> /// <param name="jobID">The id of a job</param> /// <returns>Task of ApiResponse (Result)</returns> public async System.Threading.Tasks.Task <ApiResponse <Result> > ProcessesIdJobsJobIDResultGetAsyncWithHttpInfo(string id, string jobID) { // verify the required parameter 'id' is set if (id == null) { throw new Client.ApiException(400, "Missing required parameter 'id' when calling GetResultApi->ProcessesIdJobsJobIDResultGet"); } // verify the required parameter 'jobID' is set if (jobID == null) { throw new Client.ApiException(400, "Missing required parameter 'jobID' when calling GetResultApi->ProcessesIdJobsJobIDResultGet"); } var localVarPath = "./processes/{id}/jobs/{jobID}/result"; var localVarPathParams = new Dictionary <String, String>(); var localVarQueryParams = new List <KeyValuePair <String, String> >(); var localVarHeaderParams = new Dictionary <String, String>(this.Configuration.DefaultHeader); var localVarFormParams = new Dictionary <String, String>(); var localVarFileParams = new Dictionary <String, FileParameter>(); Object localVarPostBody = null; // to determine the Content-Type header String[] localVarHttpContentTypes = new String[] { }; String localVarHttpContentType = this.Configuration.ApiClient.SelectHeaderContentType(localVarHttpContentTypes); // to determine the Accept header String[] localVarHttpHeaderAccepts = new String[] { "application/json" }; String localVarHttpHeaderAccept = this.Configuration.ApiClient.SelectHeaderAccept(localVarHttpHeaderAccepts); if (localVarHttpHeaderAccept != null) { localVarHeaderParams.Add("Accept", localVarHttpHeaderAccept); } if (id != null) { localVarPathParams.Add("id", this.Configuration.ApiClient.ParameterToString(id)); // path parameter } if (jobID != null) { localVarPathParams.Add("jobID", this.Configuration.ApiClient.ParameterToString(jobID)); // path parameter } // make the HTTP request IRestResponse localVarResponse = (IRestResponse)await this.Configuration.ApiClient.CallApiAsync(localVarPath, Method.GET, localVarQueryParams, localVarPostBody, localVarHeaderParams, localVarFormParams, localVarFileParams, localVarPathParams, localVarHttpContentType); int localVarStatusCode = (int)localVarResponse.StatusCode; if (ExceptionFactory != null) { ApiException exception = ExceptionFactory("ProcessesIdJobsJobIDResultGet", localVarResponse); if (exception != null) { throw exception; } } return(new ApiResponse <Result>(localVarStatusCode, localVarResponse.Headers.ToDictionary(x => x.Key, x => string.Join(",", x.Value)), (Result)this.Configuration.ApiClient.Deserialize(localVarResponse, typeof(Result)))); }
public static void FireOnError(ApiException exception) { OnError(exception); }
public void SetsDefaultExceptionMessage() { var exception = new ApiException(); Assert.Equal("An error occurred with this API request", exception.Message); }
private void AssertApiException(ApiException exception, HttpStatusCode code) { Assert.AreEqual(code, exception.ResponseCode); }
protected virtual Response <TResult> GetResponse <TResult>(ApiException fromApiException) { throw new InvalidOperationException($"If you are returning true in CanPrepareResponse method " + "you have to override GetResponse methods."); }
public ErrorModel(ApiException exception) { Message = exception.Message; Content = exception.Content; }
protected virtual bool CanPrepareResponse(ApiException fromApiException) => false;
public static bool IsENException(this ApiException apiException) => ApiExceptionStatusCodes.FAILED_ALL.Contains(apiException.StatusCode);
public void Put(int id, [FromBody] ApiException value) { }
public void Post([FromBody] ApiException value) { }
/// <summary> /// 创建一个对象信息 /// </summary> /// <param name="info">新增对象</param> /// <param name="logonInfo">登录人信息</param> /// <returns></returns> public virtual ResultView Create(T info, TokenLogonInfo logonInfo) { if (info == null) { ApiException.ThrowBadRequest("新增对象不能为空"); } _logger.LogTrace($"新增一个对象信息 ==> 类型为:[{typeof(T).FullName}]\r\n新增对象:[{info.ToJson()}]"); try { // 新增数据前的预制数据 info.CreateDate = DateTime.Now; info.UpdateDate = DateTime.Now; info.UpdaterId = logonInfo.Id; info.UpdaterName = logonInfo.Name; info.CreaterId = logonInfo.Id; info.CreaterName = logonInfo.Name; info.IsDelete = false; info.ProcessState = ProcessState.Edit; #region 保存验证 // 保存的数据校验 SavingCheck(info, logonInfo); // 判断是否可以执行新增操作 if (!IsExecuteCreate(info, logonInfo)) { return(ResultView.Success()); } // 保存数据验证的事件处理 OnCreateCheck?.Invoke(info, logonInfo); OnSaveCheck?.Invoke(info, logonInfo); #endregion #region 保存的前置处理 // 新增的前置操作,可以被重写 Creating(info, logonInfo); // 新增/保存的通用前置操作,可以被重写 Saving(info, logonInfo); // 新增时的前置事件处理 OnCreating?.Invoke(info, logonInfo); OnSaving?.Invoke(info, logonInfo); #endregion // 持久化数据 _Dal.InsertObject(info); #region 保存后置处理 // 新增的通用后置操作,可以被重写 Created(info, logonInfo); // 新增/保存的通用后置操作,可以被重写 Saved(info, logonInfo); // 新增后的后置事件处理 OnCreated?.Invoke(info, logonInfo); OnSaved?.Invoke(info, logonInfo); #endregion // 返回保存结果 return(ResultView.Success(info.IdString)); } catch (Exception ex) { _logger.LogError(ex, $"新增一个对象信息异常 ==> 类型为:[{typeof(T).FullName}]\r\n操作人信息:[{logonInfo.ToJson()}]\r\n新增对象:[{info.ToJson()}]"); throw; } }
/// <summary> /// Main method for the thread. /// </summary> /// <param name="obj">The thread parameter.</param> public void Run(Object obj) { // Create the operations. List <AdGroupCriterionOperation> operations = new List <AdGroupCriterionOperation>(); for (int j = 0; j < NUM_KEYWORDS; j++) { // Create the keyword. Keyword keyword = new Keyword(); keyword.text = "mars cruise thread " + threadIndex.ToString() + " seed " + j.ToString(); keyword.matchType = KeywordMatchType.BROAD; // Create the biddable ad group criterion. AdGroupCriterion keywordCriterion = new BiddableAdGroupCriterion(); keywordCriterion.adGroupId = adGroupId; keywordCriterion.criterion = keyword; // Create the operations. AdGroupCriterionOperation keywordOperation = new AdGroupCriterionOperation(); keywordOperation.@operator = Operator.ADD; keywordOperation.operand = keywordCriterion; operations.Add(keywordOperation); } // Get the AdGroupCriterionService. This should be done within the // thread, since a service can only handle one outgoing HTTP request // at a time. using (AdGroupCriterionService adGroupCriterionService = (AdGroupCriterionService)user.GetService( AdWordsService.v201705.AdGroupCriterionService)) { adGroupCriterionService.RequestHeader.validateOnly = true; int retryCount = 0; const int NUM_RETRIES = 3; try { while (retryCount < NUM_RETRIES) { try { // Validate the keywords. adGroupCriterionService.mutate(operations.ToArray()); break; } catch (AdWordsApiException e) { // Handle API errors. ApiException innerException = e.ApiException as ApiException; if (innerException == null) { throw new Exception("Failed to retrieve ApiError. See inner exception " + "for more details.", e); } foreach (ApiError apiError in innerException.errors) { if (!(apiError is RateExceededError)) { // Rethrow any errors other than RateExceededError. throw; } // Handle rate exceeded errors. RateExceededError rateExceededError = (RateExceededError)apiError; Console.WriteLine("Got Rate exceeded error - rate name = '{0}', " + "scope = '{1}', retry After {2} seconds.", rateExceededError.rateScope, rateExceededError.rateName, rateExceededError.retryAfterSeconds); Thread.Sleep(rateExceededError.retryAfterSeconds * 1000); retryCount = retryCount + 1; } } finally { if (retryCount == NUM_RETRIES) { throw new Exception(String.Format("Could not recover after making {0} attempts.", retryCount)); } } } } catch (Exception e) { throw new System.ApplicationException("Failed to validate keywords.", e); } } }
/// <summary> /// Initializes a new instance of <see cref="ErrorResponseException"/> with response error details and API excepiton. /// </summary> /// <param name="error">The response error details</param> /// <param name="inner">The exception occurred during calling service API.</param> public ErrorResponseException(ErrorResponse error, ApiException inner) : base(error.GetSummaryMessage() ?? string.Empty, inner) { Error = error; StatusCode = inner.StatusCode; }
public ServerResponseException(ApiException apiException) : base(apiException.Message, apiException) { _message = FormatExceptionMessage(apiException); }
public async Task <UserResponse> Login(string brandToken, UserLoginRequest model) { try { var result = new UserResponse(); using (var client = new HttpClient()) { client.BaseAddress = new Uri("http://authorizecore.unicode.edu.vn"); var oBject = new { Email = model.Email, Password = model.Password, brandToken = brandToken }; var response = await client.PostAsJsonAsync("/api/authorize/login", oBject); if (response.IsSuccessStatusCode) { var responseObj = await response.Content.ReadAsAsync <JObject>(); var token = responseObj.SelectToken("token").ToString(); var role = responseObj.SelectToken("roles").ToArray(); var emp = employeeService.Get(model.Email).FirstOrDefault(); result.Token = token; result.Employee = emp; result.Role = role; var loyaltyResponse = RootConfig.LoyaltyClient.MembershipsApi.Get(new ResoLoyalty.Client.Models.Request.MembershipRequest() { of_emp_code = emp.EmpEnrollNumber, includes = new List <string>() { MembershipRequest.Basic, MembershipRequest.CreditAcc } }).Result; var membership = loyaltyResponse.Content.ReadAsAsync <BaseResponse <IEnumerable <Membership> > >().Result.Data.FirstOrDefault(); result.Membership = membership; //var tokenJWT = Utils.DecodeJwtToken(token); //tokenJWT.Claims.Where(p => p.Type ) //var email = data.SelectToken("email").ToString(); //employeeService.Add(model); } else { if (response.StatusCode == HttpStatusCode.Unauthorized) { throw ApiException.Get(false, ConstantManager.UNAUTHORIZED, ResultEnum.Unauthorization, HttpStatusCode.Unauthorized); } else { throw ApiException.Get(false, ConstantManager.FAIL, ResultEnum.InternalError, HttpStatusCode.InternalServerError); } } } return(result); } catch (Exception ex) { if (ex is ApiException) { throw ex; } else { throw ApiException.Get(false, ConstantManager.FAIL, ResultEnum.InternalError, HttpStatusCode.InternalServerError); } } }
/// <summary> /// Checks a list of keywords for policy violations, and add the errors to /// a list of traffic estimates. /// </summary> /// <param name="user">The user.</param> /// <param name="trafficEstimates">The list of keywords and their traffic /// estimates.</param> /// <param name="adGroupId">The ad group ID.</param> /// <remarks>Users can use the policy violation details to decide whether /// to pick a keyword and submit an exemption request, or skip the /// violating keyword and scout for other keywords that are policy /// compliant.</remarks> private void CheckPolicyViolations(AdWordsUser user, List <TrafficEstimate> trafficEstimates, long adGroupId) { // Get the AdGroupCriterionService. AdGroupCriterionService adGroupCriterionService = (AdGroupCriterionService)user.GetService( AdWordsService.v201509.AdGroupCriterionService); adGroupCriterionService.RequestHeader.validateOnly = true; for (int i = 0; i < trafficEstimates.Count; i += Settings.AGCS_KEYWORDS_LIST_SIZE) { List <AdGroupCriterionOperation> operations = new List <AdGroupCriterionOperation>(); for (int j = i; j < i + Settings.AGCS_KEYWORDS_LIST_SIZE && j < trafficEstimates.Count; j++) { AdGroupCriterionOperation operation = new AdGroupCriterionOperation() { @operator = Operator.ADD, operand = new BiddableAdGroupCriterion() { adGroupId = adGroupId, criterion = new Keyword() { text = trafficEstimates[i].Keyword.KeywordText, matchType = trafficEstimates[i].MatchType, }, userStatus = UserStatus.ENABLED } }; operations.Add(operation); } try { AdGroupCriterionReturnValue retVal = adGroupCriterionService.mutate( operations.ToArray()); } catch (AdWordsApiException e) { ApiException innerException = e.ApiException as ApiException; if (innerException == null) { throw new Exception("Failed to retrieve ApiError. See inner exception for more " + "details.", e); } // Examine each ApiError received from the server. foreach (ApiError apiError in innerException.errors) { int index = ErrorUtilities.GetOperationIndex(apiError.fieldPath); if (index == -1) { // This API error is not associated with an operand, so we cannot // recover from this error by removing one or more operations. // Rethrow the exception for manual inspection. throw; } // Handle policy violation errors. if (apiError is PolicyViolationError) { PolicyViolationError policyError = (PolicyViolationError)apiError; trafficEstimates[i + index].Errors.Add(policyError); } } } } return; }
internal void Print(ApiException level, string Method) { Print("Warning", Method, level.Message); }
private static Dictionary<string, string> HandleApiError(Dictionary<string, string> errors, ApiException e) { if (e.StatusCode == HttpStatusCode.Unauthorized) { if (e.HasContent && e.Content.StartsWith("<html")) { errors.Add("Auth", "Access denied to VPDB. Seems like the site is protected and you need to put additional credentials in here."); } else { errors.Add("ApiKey", "Authentication failed. Are you sure you've correctly pasted your API key?"); } } else { errors.Add("ApiKey", e.Message); } return errors; }
public void DoesNotPrintNonStringContent() { var responceBody = new byte[0]; var response = new Response( HttpStatusCode.GatewayTimeout, responceBody, new Dictionary<string, string>(), "application/json" ); var exception = new ApiException(response); var stringRepresentation = exception.ToString(); Assert.NotNull(stringRepresentation); }
private void OnTransactionReply(uint transactionId, Codes replyCode, Codes extendedCode, OrderStatus status, long orderId, string message) { this.AddDebugLog("Order: transId {0} replyCode {1} extendedCode {2} status {3} orderId {4} message {5}", transactionId, replyCode, extendedCode, status, orderId, message); if (!IsAsyncMode) { return; } try { var builder = _transactions.TryGetValue(transactionId); if (builder == null) { throw new InvalidOperationException(LocalizedStrings.Str1839Params.Put(transactionId)); } if (builder.TransactionType == TransactionTypes.CancelGroup) { if (replyCode != Codes.Success || status != OrderStatus.Accepted) { SendOutError(new ApiException(replyCode, message)); } return; } if (builder.TransactionType == TransactionTypes.Register && extendedCode == Codes.Success && orderId == 0) { extendedCode = Codes.Failed; } var isCancelFailed = builder.TransactionType == TransactionTypes.Cancel && status != OrderStatus.Accepted; if (isCancelFailed) { extendedCode = Codes.Failed; } ApiException exception = null; if (extendedCode != Codes.Success) { exception = new ApiException(extendedCode, message); } var orderMessage = builder.Message.CreateReply(); orderMessage.SystemComment = message; if (!isCancelFailed) { orderMessage.OrderStatus = (long)status; } ProcessTransactionReply(orderMessage, builder, orderId, message, replyCode, exception); } catch (Exception ex) { SendOutError(ex); } }
public void CanPopulateObjectFromSerializedData() { IResponse response = new Response( (HttpStatusCode)422, @"{""errors"":[{""code"":""custom"",""field"":""key"",""message"":""key is " + @"already in use"",""resource"":""PublicKey""}],""message"":""Validation Failed""}", new Dictionary<string, string>(), "application/json"); var exception = new ApiException(response); using (var stream = new MemoryStream()) { var formatter = new BinaryFormatter(); formatter.Serialize(stream, exception); stream.Position = 0; var deserialized = (ApiException)formatter.Deserialize(stream); Assert.Equal("Validation Failed", deserialized.ApiError.Message); Assert.Equal("key is already in use", exception.ApiError.Errors.First().Message); } }
public static IHttpActionResult CreateErrorResult(HttpRequestMessage request, ApiException ex) { HttpResponseMessage response = request.CreateResponse(ex.HttpStatusCode, new ApiResponse { ApiStatusCode = ex.ErrorCode, ApiStatusMessage = ex.Message, ExceptionDetails = new ApiExceptionDetails(ex) }); return(new ResponseMessageResult(response)); }
public void DoesNotThrowIfBodyIsNotDefined() { var response = new Response( HttpStatusCode.GatewayTimeout, null, new Dictionary<string, string>(), "application/json" ); var exception = new ApiException(response); var stringRepresentation = exception.ToString(); Assert.NotNull(stringRepresentation); }
/// <summary> /// Initializes a new instance of <see cref="DefaultErrorResponseException"/> with response error details and API excepiton. /// </summary> /// <param name="error"></param> /// <param name="inner"></param> public DefaultErrorResponseException(ErrorResponse error, ApiException inner) : base(error, inner) { }
/// <summary> /// Handles IoT Hub exception and transform it as an <see cref="ApiException"/> with a well-known application error code. /// </summary> /// <param name="deviceId"></param> /// <param name="iotHubException"></param> /// <param name="apiException"></param> /// <returns></returns> private bool TryHandleIotHubException(string deviceId, IotHubException iotHubException, out ApiException apiException) { switch (iotHubException) { // thrown when there's no IoT Hub device registration OR there's an enabled IoT Hub device registration but device did not establish connection yet case DeviceNotFoundException ex: apiException = new IdNotFoundException(ErrorCodes.DeviceNotFound, deviceId, ex); break; // thrown when an attempt to communicate with the IoT Hub fails case IotHubCommunicationException ex: m_Logger.LogWarning($"An IotHubCommunicationException occurred: {ex}"); apiException = new CommunicationException(ErrorCodes.CommunicationError, ex.Message, ex); break; // thrown when the IoT Hub returns an error code (i.e. device registration is disable which prevent the actual device from establishing a connection) case ServerErrorException ex: m_Logger.LogWarning($"A ServerErrorException occurred: {ex}"); apiException = new CommunicationException(ErrorCodes.GatewayError, ErrorMessages.GetGatewayErrorMessage(), ex); break; // thrown when the maximum number of IoT Hub messages has been reached case QuotaExceededException ex: apiException = new CommunicationException(ErrorCodes.QuotaExceeded, ErrorMessages.GetQuotaExceededErrorMessage(), ex); break; // thrown when the message size is greater than the max size allowed (131072 bytes) case MessageTooLargeException ex: apiException = new InvalidResultException(ErrorCodes.MessageTooLarge, ErrorMessages.GetMessageTooLargeErrorMessage(), ex); break; // thrown when an error occurs during device client operation (i.e. device doesn't repond within the configured time out) // shall always be kept last case IotHubException ex: m_Logger.LogWarning($"An IotHubException occurred: {ex}"); apiException = new OperationException(ErrorCodes.DeviceOperationError, ErrorMessages.GetOperationErrorMessage(), ex); break; // exception won't be transformed and therefore will be logged accordingly default: apiException = null; break; } return(apiException != null); }
/// <summary> /// Header传递关键参数处理方法 /// </summary> /// <param name="controller">控制器</param> /// <param name="baseApi">传入参数</param> /// <returns></returns> private object HeaderBussResults(Controller controller, BaseApi baseApi, IPAddress iPAddress) { var route = ""; var action = ""; var routeController = controller.RouteData.Values["controller"].ToString(); var routeAction = controller.RouteData.Values["action"].ToString(); route = Global.ROUTE_PX + "/" + routeController + "/" + routeAction; action = routeAction.Replace("/", ""); if (controller.Request.Headers.ContainsKey("userid")) { baseApi.code = controller.Request.Headers["userid"].ToString(); } if (controller.Request.Headers.ContainsKey("token")) { baseApi.token = controller.Request.Headers["token"].ToString(); } if (controller.Request.Headers.ContainsKey("sign") && controller.Request.Headers.ContainsKey("nonceStr")) { baseApi.sign = controller.Request.Headers["sign"].ToString(); baseApi.nonceStr = controller.Request.Headers["nonceStr"].ToString(); } Message msg = null; switch (baseApi.GetCheckType()) { case CheckType.Open: break; case CheckType.Token: msg = CheckToken(baseApi, true, route); break; case CheckType.OpenToken: msg = CheckToken(baseApi, false, route); break; case CheckType.Sign: msg = CheckSign(baseApi, route); break; case CheckType.WhiteList: msg = CheckWhiteList(baseApi, iPAddress); break; default: break; } if (msg != null) { controller.Response.Headers.Add("code", ((int)msg.code).ToString()); controller.Response.Headers.Add("msg", msg.msg); return(""); } var obj = bussList[baseApi.GetApiType()]; MethodInfo methodInfo = obj.GetType().GetMethod("Do_" + action); if (methodInfo == null) { controller.Response.Headers.Add("code", ((int)CodeMessage.InvalidMethod).ToString()); controller.Response.Headers.Add("msg", "InvalidMethod"); return(""); } else { Message message = null; object data = null; try { data = methodInfo.Invoke(obj, new object[] { baseApi }); } catch (Exception ex) { if (ex.InnerException.GetType() == typeof(ApiException)) { ApiException apiException = (ApiException)ex.InnerException; message = new Message(apiException.code, apiException.msg); } else { message = new Message(CodeMessage.InnerError, "InnerError"); } } if (message != null) { controller.Response.Headers.Add("code", ((int)message.code).ToString()); controller.Response.Headers.Add("msg", message.msg); } else { controller.Response.Headers.Add("code", ((int)CodeMessage.OK).ToString()); controller.Response.Headers.Add("msg", ""); } return(data); } }
/// <summary> /// Runs the code example. /// </summary> /// <param name="user">The AdWords user.</param> /// <param name="adGroupId">Id of the ad group to which ads are added. /// </param> public void Run(AdWordsUser user, long adGroupId) { // Get the AdGroupAdService. AdGroupAdService service = (AdGroupAdService)user.GetService(AdWordsService.v201603.AdGroupAdService); // Create the text ad. TextAd textAd = new TextAd(); textAd.headline = "Luxury Cruise to Mars"; textAd.description1 = "Visit the Red Planet in style."; textAd.description2 = "Low-gravity fun for everyone!!"; textAd.displayUrl = "www.example.com"; textAd.finalUrls = new string[] { "http://www.example.com" }; AdGroupAd textadGroupAd = new AdGroupAd(); textadGroupAd.adGroupId = adGroupId; textadGroupAd.ad = textAd; // Create the operations. AdGroupAdOperation textAdOperation = new AdGroupAdOperation(); textAdOperation.@operator = Operator.ADD; textAdOperation.operand = textadGroupAd; try { AdGroupAdReturnValue retVal = null; // Setup two arrays, one to hold the list of all operations to be // validated, and another to hold the list of operations that cannot be // fixed after validation. List <AdGroupAdOperation> allOperations = new List <AdGroupAdOperation>(); List <AdGroupAdOperation> operationsToBeRemoved = new List <AdGroupAdOperation>(); allOperations.Add(textAdOperation); try { // Validate the operations. service.RequestHeader.validateOnly = true; retVal = service.mutate(allOperations.ToArray()); } catch (AdWordsApiException e) { ApiException innerException = e.ApiException as ApiException; if (innerException == null) { throw new Exception("Failed to retrieve ApiError. See inner exception for more " + "details.", e); } // Examine each ApiError received from the server. foreach (ApiError apiError in innerException.errors) { int index = ErrorUtilities.GetOperationIndex(apiError.fieldPath); if (index == -1) { // This API error is not associated with an operand, so we cannot // recover from this error by removing one or more operations. // Rethrow the exception for manual inspection. throw; } // Handle policy violation errors. if (apiError is PolicyViolationError) { PolicyViolationError policyError = (PolicyViolationError)apiError; if (policyError.isExemptable) { // If the policy violation error is exemptable, add an exemption // request. List <ExemptionRequest> exemptionRequests = new List <ExemptionRequest>(); if (allOperations[index].exemptionRequests != null) { exemptionRequests.AddRange(allOperations[index].exemptionRequests); } ExemptionRequest exemptionRequest = new ExemptionRequest(); exemptionRequest.key = policyError.key; exemptionRequests.Add(exemptionRequest); allOperations[index].exemptionRequests = exemptionRequests.ToArray(); } else { // Policy violation error is not exemptable, remove this // operation from the list of operations. operationsToBeRemoved.Add(allOperations[index]); } } else { // This is not a policy violation error, remove this operation // from the list of operations. operationsToBeRemoved.Add(allOperations[index]); } } // Remove all operations that aren't exemptable. foreach (AdGroupAdOperation operation in operationsToBeRemoved) { allOperations.Remove(operation); } } if (allOperations.Count > 0) { // Perform the operations exemptible of a policy violation. service.RequestHeader.validateOnly = false; retVal = service.mutate(allOperations.ToArray()); // Display the results. if (retVal != null && retVal.value != null && retVal.value.Length > 0) { foreach (AdGroupAd newAdGroupAd in retVal.value) { Console.WriteLine("New ad with id = \"{0}\" and displayUrl = \"{1}\" was created.", newAdGroupAd.ad.id, newAdGroupAd.ad.displayUrl); } } else { Console.WriteLine("No ads were created."); } } else { Console.WriteLine("There are no ads to create after policy violation checks."); } } catch (Exception e) { throw new System.ApplicationException("Failed to create ads.", e); } }
public BadRequestException(ApiException apiException) : base(HttpStatusCode.BadRequest, apiException.Message) { ErrorNumber = apiException.ErrorNumber; Type = apiException.Type; }
public void ContainsResponseBody() { const string responseBody = @"{""errors"":[{""code"":""custom"",""field"":""key"",""message"":""key is " + @"already in use"",""resource"":""PublicKey""}],""message"":""Validation Failed""}"; var response = new Response( HttpStatusCode.GatewayTimeout, responseBody, new Dictionary<string, string>(), "application/json" ); var exception = new ApiException(response); var stringRepresentation = exception.ToString(); Assert.Contains(responseBody, stringRepresentation); }
public Message LogApiError(ApiException exception, string message) { var msg = CreateError(exception, message, MessageType.ApiError); msg.Data.Add(DataStatusCode, exception.StatusCode.ToString()); msg.Data.Add(DataContent, exception.Content); _crashManager.Report(exception, "api"); return Log(msg); }
/// <summary> /// Identify whether the API exception was caused by a request validation problem /// </summary> public static bool IsValidationProblem(this ApiException ex) { return(ex.ErrorCode == (int)HttpStatusCode.BadRequest); }
/// <summary> /// 更新一个对象信息 /// </summary> /// <param name="info">更新对象</param> /// <param name="logonInfo">登录人信息</param> /// <returns></returns> public virtual ResultView Update(T info, TokenLogonInfo logonInfo) { if (info == null) { ApiException.ThrowBadRequest("更新对象不能为空"); } _logger.LogTrace($"更新一个对象信息 ==> 类型为:[{typeof(T).FullName}]\r\n操作人信息:[{logonInfo.ToJson()}]\r\n更新对象:[{info.ToJson()}]"); try { // 根据ID获取原数据信息 var old = _SearchById(info.Id); // 更新数据前的预制数据 info.CreateDate = old.CreateDate; info.CreaterId = old.CreaterId; info.CreaterName = old.CreaterName; info.UpdateDate = DateTime.Now; info.UpdaterId = logonInfo.Id; info.UpdaterName = logonInfo.Name; info.IsDelete = false; if (info.ProcessState == ProcessState.None) { info.ProcessState = ProcessState.Edit; } #region 保存验证 // 保存的数据校验,可以被重写 SavingCheck(info, logonInfo); // 判断是否可以执行新增操作,可以被重写 if (!IsExecuteUpdate(info, old, logonInfo)) { return(ResultView.Success()); } OnUpdateCheck?.Invoke(info, old, logonInfo); OnSaveCheck?.Invoke(info, logonInfo); #endregion #region 保存的前置处理 // 更新的前置操作,可以被重写 Updating(info, old, logonInfo); // 新增/保存的通用前置操作,可以被重写 Saving(info, logonInfo); // 事件处理 OnUpdating?.Invoke(info, old, logonInfo); OnSaving?.Invoke(info, logonInfo); #endregion // 持久化数据 _Dal.UpdateObject(info); #region 保存后置处理 // 更新的后置操作,可以被重写 Updated(info, old, logonInfo); // 新增/保存的通用后置操作,可以被重写 Saved(info, logonInfo); // 新增后的后置事件处理 OnUpdated?.Invoke(info, old, logonInfo); OnSaved?.Invoke(info, logonInfo); #endregion // 返回保存结果 return(ResultView.Success(info.IdString)); } catch (Exception ex) { _logger.LogError(ex, $"更新一个对象信息异常 ==> 类型为:[{typeof(T).FullName}]\r\n操作人信息:[{logonInfo.ToJson()}]\r\n更新对象:[{info.ToJson()}]"); throw; } }
public void CreatesEmptyGitHubErrorWhenResponseBodyIsNull() { var response = Substitute.For<IResponse>(); response.Body.Returns("test"); var exception = new ApiException(); var anotherException = new ApiException(new Response(HttpStatusCode.ServiceUnavailable, "message1", new Dictionary<string, string>(), "application/json")); var thirdException = new ApiException(new Response(HttpStatusCode.ServiceUnavailable, "message2", new Dictionary<string, string>(), "application/json")); // It's fine if the message is null when there's no response body as long as this doesn't throw. Assert.Null(exception.ApiError.Message); Assert.Equal("message1", anotherException.ApiError.Message); Assert.Equal("message2", thirdException.ApiError.Message); }
/// <summary> /// Execute the specified action, resourcePath and baseObject. /// </summary> /// <param name="action">Action.</param> /// <param name="resourcePath">Resource path.</param> /// <param name="requestMap">Request Map.</param> /// <param name="headerList">Header List.</param> public virtual IDictionary <String, Object> Execute(OperationConfig config, OperationMetadata metadata, BaseObject requestMap) { IRestResponse response; RestyRequest request; IRestClient client; CryptographyInterceptor interceptor; try { request = this.GetRequest(config, metadata, requestMap); interceptor = request.interceptor; //arizzini: create client if (this.restClient != null) { client = restClient; } else { client = new RestClient(); } client.BaseUrl = request.BaseUrl; client.Proxy = ApiConfig.GetProxy(); log.Debug(">>Execute(action='" + config.Action + "', resourcePaht='" + config.ResourcePath + "', requestMap='" + requestMap + "'"); log.Debug("excute(), request.Method='" + request.Method + "'"); log.Debug("excute(), request.URL=" + request.AbsoluteUrl.ToString()); log.Debug("excute(), request.Header="); log.Debug(request.Parameters.Where(x => x.Type == ParameterType.HttpHeader)); log.Debug("excute(), request.Body="); log.Debug(request.Parameters.Where(x => x.Type == ParameterType.RequestBody)); response = client.Execute(request); log.Debug("Execute(), response.Header="); log.Debug(response.Headers); log.Debug("Execute(), response.Body="); log.Debug(response.Content.ToString()); if (response.ErrorException == null && response.Content != null) { IDictionary <String, Object> responseObj = new Dictionary <String, Object>(); if (response.Content.Length > 0) { if (response.StatusCode < HttpStatusCode.Ambiguous) { responseObj = SmartMap.AsDictionary(response.Content); if (interceptor != null) { try { responseObj = interceptor.Decrypt(responseObj); } catch (Exception e) { throw new ApiException("Error: decrypting payload", e); } } log.Debug("<<Execute()"); return(responseObj); } else { int status = (int)response.StatusCode; throw new ApiException(status, SmartMap.AsObject(response.Content)); } } else { return(responseObj); } } else { throw new ApiException(response.ErrorMessage, response.ErrorException); } } catch (ApiException apiE) { log.Error(apiE.Message, apiE); throw; } catch (Exception genE) { ApiException wrapper = new ApiException(genE.Message, genE); log.Error(wrapper.Message, wrapper); throw wrapper; } }
private ApiException CreateErrorResponseException(ErrorResponse response) { Exception innerException = null; if (!String.IsNullOrEmpty(response.sub_code)) { innerException = new ApiException(response.sub_msg, response.sub_code); } if (innerException == null) { return new ApiException(response.msg, response.code); } return new ApiException(response.msg, response.code, innerException); }
/// <summary> /// Body传递关键参数处理方法 /// </summary> /// <param name="controller">控制器</param> /// <param name="baseApi">传入参数</param> /// <returns></returns> private object BodyBussResults(Controller controller, BaseApi baseApi) { var route = ""; var action = ""; var routeController = controller.RouteData.Values["controller"].ToString(); var routeAction = controller.RouteData.Values["action"].ToString(); route = Global.ROUTE_PX + "/" + routeController + "/" + routeAction + "/" + baseApi.method; action = routeAction.Replace("/", ""); Message msg = null; switch (baseApi.GetCheckType()) { case CheckType.Open: break; case CheckType.Token: msg = CheckToken(baseApi, true, route); break; case CheckType.OpenToken: msg = CheckToken(baseApi, false, route); break; case CheckType.Sign: msg = CheckSign(baseApi, route); break; default: break; } if (msg != null) { return(new ResultsJson(new Message(CodeMessage.InvalidToken, "InvalidToken"), null)); } var obj = bussList[baseApi.GetApiType()]; MethodInfo methodInfo = obj.GetType().GetMethod("Do_" + baseApi.method); if (methodInfo == null) { return(new ResultsJson(new Message(CodeMessage.InvalidMethod, "InvalidMethod"), null)); } else { Message message = null; object data = null; try { data = methodInfo.Invoke(obj, new object[] { baseApi }); } catch (Exception ex) { if (ex.InnerException.GetType() == typeof(ApiException)) { ApiException apiException = (ApiException)ex.InnerException; message = new Message(apiException.code, apiException.msg); } else { message = new Message(CodeMessage.InnerError, "InnerError"); } } ResultsJson resultsJson = new ResultsJson(message, data); return(resultsJson); } }
/// <summary> /// Validate HttpResponse message, throws an Api Exception with context /// </summary> /// <param name="response"></param> /// <param name="request"></param> /// <param name="apiContext"></param> /// <exception cref="ApiException"></exception> public static void EnsureSuccess(HttpResponseMessage response, HttpRequestMessage request=null, IApiContext apiContext=null) { if (response.IsSuccessStatusCode) return; if (response.StatusCode == HttpStatusCode.NotModified) return; var content = response.Content.ReadAsStringAsync().Result; ApiException exception ; var htmlMediaType = new MediaTypeHeaderValue("text/html"); if (response.Content.Headers.ContentType != null && response.Content.Headers.ContentType.MediaType == htmlMediaType.MediaType) { var message = String.Format("Status Code {0}, Uri - {1}", response.StatusCode, response.RequestMessage.RequestUri.AbsoluteUri); exception = new ApiException(message, new Exception(content)); } else if (!String.IsNullOrEmpty(content)) exception = JsonConvert.DeserializeObject<ApiException>(content); else if (HttpStatusCode.NotFound == response.StatusCode && string.IsNullOrEmpty(content) && request != null) exception = new ApiException("Uri "+request.RequestUri.AbsoluteUri + " does not exist"); else exception = new ApiException("Unknow Exception"); exception.HttpStatusCode = response.StatusCode; exception.CorrelationId = HttpHelper.GetHeaderValue(Headers.X_VOL_CORRELATION, response.Headers); exception.ApiContext = apiContext; if (!MozuConfig.ThrowExceptionOn404 && string.Equals(exception.ErrorCode, "ITEM_NOT_FOUND", StringComparison.OrdinalIgnoreCase) && response.RequestMessage.Method.Method == "GET") return; throw exception; }