public static HttpResponseMessage CreateOAuthErrorResponse(this HttpRequestMessage request, string OAuthError)
        {
            Tracing.Information("Sending error response: " + OAuthError);

            return request.CreateErrorResponse(HttpStatusCode.BadRequest,
                string.Format("{{ \"{0}\": \"{1}\" }}", OAuth2Constants.Errors.Error, OAuthError));
        }
Exemplo n.º 2
0
 public static HttpResponseMessage CreateResponse(this HttpRequestMessage request, ApiResult result)
 {
     if (result.success)
         return request.CreateResponse(HttpStatusCode.OK, result);
     else
         return request.CreateErrorResponse(HttpStatusCode.InternalServerError, result.message);
 }
 internal static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message, string messageDetail)
 {
     HttpError error = new HttpError(message);
     HttpConfiguration config = request.GetConfiguration();
     if (config != null && ShouldIncludeErrorDetail(config, request))
     {
         error.Add(MessageDetailKey, messageDetail);
     }
     return request.CreateErrorResponse(statusCode, error);
 }
Exemplo n.º 4
0
        public static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, InvalidByteRangeException invalidByteRangeException)
        {
            if (invalidByteRangeException == null)
            {
                throw new ArgumentNullException("invalidByteRangeException");
            }

            HttpResponseMessage rangeNotSatisfiableResponse = request.CreateErrorResponse(HttpStatusCode.RequestedRangeNotSatisfiable, invalidByteRangeException);
            rangeNotSatisfiableResponse.Content.Headers.ContentRange = invalidByteRangeException.ContentRange;
            return rangeNotSatisfiableResponse;
        }
 public static HttpResponseException CreateHttpResponseException(this HttpRequestMessage request, HttpStatusCode statusCode, string message)
 {
     return new HttpResponseException(request.CreateErrorResponse(statusCode, message));
 }
        internal static void ValidateODataBatchRequest(this HttpRequestMessage request)
        {
            Contract.Assert(request != null);

            if (request.Content == null)
            {
                throw new HttpResponseException(request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    SRResources.BatchRequestMissingContent));
            }

            MediaTypeHeaderValue contentType = request.Content.Headers.ContentType;
            if (contentType == null)
            {
                throw new HttpResponseException(request.CreateErrorResponse(
                    HttpStatusCode.BadRequest,
                    SRResources.BatchRequestMissingContentType));
            }
            if (!String.Equals(contentType.MediaType, BatchMediaType, StringComparison.OrdinalIgnoreCase))
            {
                throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.BadRequest,
                        Error.Format(SRResources.BatchRequestInvalidMediaType, BatchMediaType)));
            }
            NameValueHeaderValue boundary = contentType.Parameters.FirstOrDefault(p => String.Equals(p.Name, Boundary, StringComparison.OrdinalIgnoreCase));
            if (boundary == null || String.IsNullOrEmpty(boundary.Value))
            {
                throw new HttpResponseException(request.CreateErrorResponse(HttpStatusCode.BadRequest,
                    SRResources.BatchRequestMissingBoundary));
            }
        }
        private static HttpResponseMessage Create(this HttpRequestMessage request, HttpStatusCode status, string format, params object[] args)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            if (format == null)
            {
                throw new ArgumentNullException("format");
            }

            string msg = (args != null && args.Length > 0) ? string.Format(CultureInfo.CurrentCulture, format, args) : format;

            return request.CreateErrorResponse(status, msg);
        }
 internal static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message, string messageDetail)
 {
     HttpError httpError = new HttpError(message);
     return request.CreateErrorResponse(statusCode, includeErrorDetail => includeErrorDetail ? httpError.AddAndReturn(HttpErrorConstants.MessageDetailKey, messageDetail) : httpError);
 }
 internal static HttpResponseMessage CreateErrorResponse(this HttpRequestMessage request, HttpStatusCode statusCode, string message, string messageDetail)
 {
     HttpError error = new HttpError(message);
     if (request.ShouldIncludeErrorDetail())
     {
         error.Add(MessageDetailKey, messageDetail);
     }
     return request.CreateErrorResponse(statusCode, error);
 }
        public static HttpResponseMessage GenerateCustomError(this HttpRequestMessage request, ErrorEnum error)
        {
            var customError = new HttpError();
            var statusCode = 400;
            var errorMessage = "";
            switch (error)
            {
                case ErrorEnum.MissingRequiredQueryParameter:
                    {
                        statusCode = 400;
                        errorMessage = "A required query parameter was not specified for this request.";
                        break;
                    };
                case ErrorEnum.UnsupportedQueryParameter:
                    {
                        statusCode = 400;
                        errorMessage = "One of the query parameters specified in the request URI is not supported.";
                        break;
                    };
                case ErrorEnum.InvalidQueryParameterValue:
                    {
                        statusCode = 400;
                        errorMessage = "An invalid value was specified for one of the query parameters in the request URI.";
                        break;
                    };
                case ErrorEnum.OutOfRangeQueryParameterValue:
                    {
                        statusCode = 400;
                        errorMessage = "A query parameter specified in the request URI is outside the permissible range.";
                        break;
                    };
                case ErrorEnum.RequestUrlFailedToParse:
                    {
                        statusCode = 400;
                        errorMessage = "The url in the request could not be parsed.";
                        break;
                    };
                case ErrorEnum.InvalidUri:
                    {
                        statusCode = 400;
                        errorMessage = "The requested URI does not represent any resource on the server.";
                        break;
                    };
                case ErrorEnum.InvalidAuthenticationInfo:
                    {
                        statusCode = 400;
                        errorMessage = "The authentication information was not provided in the correct format. Verify the value of Authorization header.";
                        break;
                    };
                case ErrorEnum.AuthenticationFailed:
                    {
                        statusCode = 403;
                        errorMessage = "The server failed to authenticate the request. Verify that the value of authorization header is formed correctly and includes the signature.";
                        break;
                    };
                case ErrorEnum.ResourceNotFound:
                    {
                        statusCode = 404;
                        errorMessage = "The specified resource does not exist.";
                        break;
                    };
                case ErrorEnum.AccountIsDisabled:
                    {
                        statusCode = 403;
                        errorMessage = "The specified account is disabled.";
                        break;
                    };
                case ErrorEnum.InsufficientAccountPermissions:
                    {
                        statusCode = 403;
                        errorMessage = "The account being accessed does not have sufficient permissions to execute this operation.";
                        break;
                    };
                case ErrorEnum.InternalError:
                    {
                        statusCode = 500;
                        errorMessage = "The server encountered an internal error. Please retry the request.";
                        break;
                    };
                case ErrorEnum.OperationTimedOut:
                    {
                        statusCode = 500;
                        errorMessage = "The operation could not be completed within the permitted time.";
                        break;
                    };
                case ErrorEnum.ServerBusy:
                    {
                        statusCode = 503;
                        errorMessage = "The server is currently unable to receive requests. Please retry your request.";
                        break;
                    };
                case ErrorEnum.AccountExisting:
                    {
                        statusCode = 400;
                        errorMessage = "User with account's Facebook or account's LinkedIn already exists.";
                        break;
                    }

            }
            customError["status_code"] = statusCode.ToString();
            customError["error_code"] = error.ToString();
            customError["error"] = errorMessage;
            HttpStatusCode code = HttpStatusCode.InternalServerError;
            switch (statusCode)
            {
                case 400:
                    {
                        code = HttpStatusCode.BadRequest;
                        break;
                    }
                case 404:
                    {
                        code = HttpStatusCode.NotFound;
                        break;
                    }
                case 403:
                    {
                        code = HttpStatusCode.Forbidden;
                        break;
                    }
                case 503:
                    {
                        code = HttpStatusCode.ServiceUnavailable;
                        break;
                    }
            }
            return request.CreateErrorResponse(code, customError);
        }
        public static byte[] GetVersionFromIfMatch(this HttpRequestMessage request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            if (request.Headers.IfMatch != null)
            {
                if (request.Headers.IfMatch.Count == 1)
                {
                    EntityTagHeaderValue ifMatch = request.Headers.IfMatch.First();
                    if (ifMatch == EntityTagHeaderValue.Any)
                    {
                        return null;
                    }

                    if (ifMatch.IsWeak)
                    {
                        string error = TResources.TableController_InvalidIfMatch.FormatForUser(ifMatch.ToString());
                        HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.BadRequest, error);
                        throw new HttpResponseException(response);
                    }

                    try
                    {
                        string unquotedEtag = HttpHeaderUtils.GetUnquotedString(ifMatch.Tag);
                        return Convert.FromBase64String(unquotedEtag);
                    }
                    catch
                    {
                        string error = TResources.TableController_InvalidIfMatch.FormatForUser(ifMatch.ToString());
                        HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.BadRequest, error);
                        throw new HttpResponseException(response);
                    }
                }
                else if (request.Headers.IfMatch.Count > 1)
                {
                    string error = TResources.TableController_InvalidIfMatch.FormatForUser(request.Headers.IfMatch.ToString());
                    HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.BadRequest, error);
                    throw new HttpResponseException(response);
                }
            }

            return null;
        }