public override void OnException(HttpActionExecutedContext actionExecutedContext)
        {
            if (actionExecutedContext.Exception != null)
            {

                var exception = actionExecutedContext.Exception;
                var actionName = actionExecutedContext.ActionContext.ActionDescriptor.ActionName;
                var controllerName = actionExecutedContext.ActionContext.ControllerContext.ControllerDescriptor.ControllerName;

                string resourceFile = String.IsNullOrEmpty(LocalResourceFile) 
                                        ? Localization.ExceptionsResourceFile 
                                        : LocalResourceFile;

                string key = String.IsNullOrEmpty(MessageKey) ? controllerName + "_" + actionName + ".Error" : MessageKey;

                var response = new HttpResponseMessage
                                        {
                                            StatusCode = HttpStatusCode.InternalServerError,
                                            ReasonPhrase = Localization.GetString(key, resourceFile)
                                        };
                
                actionExecutedContext.Response = response;

                Exceptions.LogException(exception);
            }
        }

 public override void OnException(HttpActionExecutedContext context)
 {
     if (context.Exception is ValidationException)
     {
         RespondWithBadRequest(context);
     }
 }

        public override void OnException(HttpActionExecutedContext context)
        {
            if (MvcApplication.Logger != null && context.Exception != null)
            {
                MvcApplication.Logger.Error("ExceptionHandlingAttribute", context.Exception);
            }

            if (context.Exception is System.Data.DataException)
            {
                throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
                {
                    Content = new StringContent(context.Exception.Message),
                    ReasonPhrase = "Exception"
                });
            }

            //Log Critical errors
            Debug.WriteLine(context.Exception);

            throw new HttpResponseException(new HttpResponseMessage(HttpStatusCode.InternalServerError)
            {
                Content = new StringContent("An error occurred, please try again or contact the administrator."),
                ReasonPhrase = "Critical Exception"
            });
        }

        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            var buffer = TraceBuffer.Current;

            if (buffer == null)
            {
                return;
            }

            TraceBuffer.Clear();

            if (buffer.HasContent)
            {
                string originalContent;
                HttpStatusCode statusCode;

                if (actionExecutedContext.Exception == null)
                {
                    originalContent = actionExecutedContext.Response.Content.ReadAsStringAsync().Result;
                    statusCode = actionExecutedContext.Response.StatusCode;
                }
                else
                {
                    originalContent = actionExecutedContext.Exception.ToLogString();
                    statusCode = HttpStatusCode.InternalServerError;
                }

                actionExecutedContext.Response = new HttpResponseMessage(statusCode)
                {
                    Content = new StringContent(string.Format("{0}\n\n{1}", buffer, originalContent).Trim())
                };
            }
        }

        private void End(HttpActionExecutedContext actionExecutedContext)
        {
            if (actionExecutedContext.Exception != null)
                WindsorAccessor.Instance.Container.Resolve<IUnitOfWork>().Abort();

            WindsorAccessor.Instance.Container.Resolve<IUnitOfWork>().End();
        }

    public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
    {
        if (actionExecutedContext.Response != null)
            actionExecutedContext.Response.Headers.Add("Access-Control-Allow-Origin", "*");

        base.OnActionExecuted(actionExecutedContext);
    }

 public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
 {
     try
     {
         //Apply logging
         var objChanges = HttpContext.Current.Items[ContactInfo.CONTACT_CHANGE] as List<ActivityObjectChangeInfo>;
         if (objChanges != null)
         {
             var activityInfo = new ActivityLogInfo
                                    {
                                        FunctionId = 0,
                                        CreatedBy = UserContext.GetCurrentUser().UserID
                                    };
             activityInfo.Id = ActivityLogRepository.Create(activityInfo);
             foreach (var objChange in objChanges)
             {
                 objChange.ActivityId = activityInfo.Id;
                 ActivityObjectChangeRepository.Create(objChange);
             }
         }
         HttpContext.Current.Items[ContactInfo.CONTACT_CHANGE] = null;
     }
     catch
     {
         //Dont throw exception if loging failed
     }
     base.OnActionExecuted(actionExecutedContext);
 }

 public override void OnException(HttpActionExecutedContext actionExecutedContext)
 {
     if (actionExecutedContext.Exception is DraftAuthenticationException)
     {
         actionExecutedContext.Response = new HttpResponseMessage(HttpStatusCode.Unauthorized)
         {
             Content = new StringContent("Unauthorized"),
             ReasonPhrase = "Unauthorized"
         };
     }
     else if (actionExecutedContext.Exception is HttpStatusException)
     {
         HttpStatusException exc = (HttpStatusException)actionExecutedContext.Exception;
         actionExecutedContext.Response = new HttpResponseMessage(exc.Status)
         {
             Content = new StringContent(exc.Message),
             ReasonPhrase = exc.Message
         };
     }
     else if (actionExecutedContext.Exception != null)
     {
         Exception exc = actionExecutedContext.Exception;
         actionExecutedContext.Response = new HttpResponseMessage(HttpStatusCode.InternalServerError)
         {
             Content = new StringContent(exc.Message),
             ReasonPhrase = exc.Source + " : " + exc.GetType().ToString() + " : " + exc.Message
         };
     }
 }

 public override void OnException(HttpActionExecutedContext actionExecutedContext)
 {
     if (actionExecutedContext.Exception is BadRequestException)
     {
         actionExecutedContext.Response = actionExecutedContext.Request.CreateResponse(HttpStatusCode.BadRequest, new HttpError(actionExecutedContext.Exception.Message));
     }
 }

        /// <summary>
        /// Called when the action is executed.
        /// </summary>
        /// <param name="actionExecutedContext">The action executed context.</param>
        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            base.OnActionExecuted(actionExecutedContext);

              if (!actionExecutedContext.Response.IsSuccessStatusCode) {
            return;
              }

              object responseObject;
              if (!actionExecutedContext.Response.TryGetContentValue(out responseObject)) {
            return;
              }

              var queryable = ApplySelectAndExpand(responseObject as IQueryable, actionExecutedContext.Request);
              if (queryable != null) {
            // if a select or expand was encountered we need to
            // execute the DbQueries here, so that any exceptions thrown can be properly returned.
            // if we wait to have the query executed within the serializer, some exceptions will not
            // serialize properly.
            var rQuery = Enumerable.ToList((dynamic) queryable);

            var formatter = ((dynamic) actionExecutedContext.Response.Content).Formatter;
            var oc = new ObjectContent(rQuery.GetType(), rQuery, formatter);
            actionExecutedContext.Response.Content = oc;
              }

              Object tmp;
              actionExecutedContext.Request.Properties.TryGetValue("MS_InlineCount", out tmp);
              var inlineCount = (Int64?) tmp;

              if (inlineCount.HasValue) {
            actionExecutedContext.Response.Headers.Add("X-InlineCount", inlineCount.ToString());
              }
        }

        public override void OnException(HttpActionExecutedContext context)
        {
            HttpStatusCode status = HttpStatusCode.InternalServerError;

            var exType = context.Exception.GetType();

            if (exType == typeof(UnauthorizedAccessException))
                status = HttpStatusCode.Unauthorized;
            else if (exType == typeof(ArgumentException))
                status = HttpStatusCode.NotFound;
            else if (exType == typeof(ServiceUnavailableExceptions))
                status = HttpStatusCode.ServiceUnavailable;
            else if (exType == typeof(InvalidOperationException)) // Happens when someone tries to Update on POST instead of PUT.
                status = HttpStatusCode.MethodNotAllowed;
            else if (exType == typeof(ItemNotFoundException))
                status = HttpStatusCode.NotFound;

            var apiError = new ApiMessageError() { message = context.Exception.Message };

            // create a new response and attach our ApiError object
            // which now gets returned on ANY exception result
            var errorResponse = context.Request.CreateResponse<ApiMessageError>(status, apiError);
            context.Response = errorResponse;
            errorResponse.ReasonPhrase = context.Exception.Message;

            base.OnException(context);
        }

 public override void OnException(HttpActionExecutedContext context)
 {
     if (context.Exception is ArgumentNullException)
     {
         context.Response = context.Request.CreateErrorResponse(HttpStatusCode.BadRequest, "ArgumentNullException occurred");
     }
 }

        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            if (actionExecutedContext.Response != null)
                actionExecutedContext.Response.Headers.Add("Access-Control-Allow-Origin", ConfigurationManager.AppSettings["ClientUrl"]);

            base.OnActionExecuted(actionExecutedContext);
        }

        /// <summary>
        /// Raises the exception event.
        /// </summary>
        /// <param name="context">The context for the action.</param>
        public override void OnException(HttpActionExecutedContext context)
        {
            var wrapResultAttribute = HttpActionDescriptorHelper
                .GetWrapResultAttributeOrNull(context.ActionContext.ActionDescriptor) ??
                _configuration.DefaultWrapResultAttribute;

            if (wrapResultAttribute.LogError)
            {
                LogHelper.LogException(Logger, context.Exception);
            }

            if (!wrapResultAttribute.WrapOnError)
            {
                return;
            }

            if (IsIgnoredUrl(context.Request.RequestUri))
            {
                return;
            }

            context.Response = context.Request.CreateResponse(
                GetStatusCode(context),
                new AjaxResponse(
                    SingletonDependency<ErrorInfoBuilder>.Instance.BuildForException(context.Exception),
                    context.Exception is Abp.Authorization.AbpAuthorizationException)
            );

            EventBus.Trigger(this, new AbpHandledExceptionData(context.Exception));
        }

 Uri GetContactLink(int contactId, HttpActionExecutedContext context)
 {
     var routeData = context.Request.GetRouteData();
     var controller = routeData.Values["controller"];
     var urlHelper = context.Request.GetUrlHelper();
     return new Uri(urlHelper.Route("DefaultApi", new { controller = controller, id = contactId }), UriKind.Relative);
 }

 public static HttpActionExecutedContext GetActionExecutedContext(HttpRequestMessage request, HttpResponseMessage response)
 {
     HttpActionContext actionContext = CreateActionContext();
     actionContext.ControllerContext.Request = request;
     HttpActionExecutedContext actionExecutedContext = new HttpActionExecutedContext(actionContext, null) { Response = response };
     return actionExecutedContext;
 }

        private static void HandleJsonException(HttpActionExecutedContext ec)
        {
            ErrorDto data = new ErrorDto();

            // Different data depending on exception type
            var exceptionType = ec.Exception.GetType();
            if (exceptionType == typeof(BrokenRuleException))
            {
                data.BrokenRules = GetDistinctBrokenRules(((BrokenRuleException) ec.Exception).BrokenRules);
            }
            else if (exceptionType == typeof(UserFriendlyException))
            {
                data.Message = ec.Exception.Message.Replace("\r\n", "<br/>");
            }
            else
            {
                data.Message = string.Format("An unexpected error has occurred. Please try agian.");
            }

            ec.Response = new HttpResponseMessage(HttpStatusCode.InternalServerError)
            {
                Content =
                    new ObjectContent<ErrorDto>(
                        data,
                        new JsonMediaTypeFormatter() {UseDataContractJsonSerializer = false})
            };
        }

        /// <summary>
        /// Called when the action is executed.  If the return type is IEnumerable or IQueryable, 
        /// calls OnActionExecuted in the base class, which in turn calls ApplyQuery.
        /// </summary>
        /// <param name="actionExecutedContext">The action executed context.</param>
        public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
        {
            var response = actionExecutedContext.Response;
              if (response == null || !response.IsSuccessStatusCode) {
            return;
              }

              object responseObject;
              if (!response.TryGetContentValue(out responseObject)) {
            return;
              }

              var request = actionExecutedContext.Request;
              var returnType = actionExecutedContext.ActionContext.ActionDescriptor.ReturnType;
              var queryHelper = GetQueryHelper(request);
              if (typeof(IEnumerable).IsAssignableFrom(returnType) || responseObject is IEnumerable) {
            // QueryableAttribute only applies for IQueryable and IEnumerable return types
            base.OnActionExecuted(actionExecutedContext);
            if (!actionExecutedContext.Response.IsSuccessStatusCode) {
              return;
            }
            if (!response.TryGetContentValue(out responseObject)) {
              return;
            }
            var queryResult = queryHelper.ApplySelectAndExpand(responseObject as IQueryable, request.RequestUri.ParseQueryString());
            queryHelper.WrapResult(request, response, queryResult);
              } else {
            // For non-IEnumerable results, post-processing must be done manually by the developer.
              }

              queryHelper.ConfigureFormatter(actionExecutedContext.Request, responseObject as IQueryable);
        }

 public override void OnException(HttpActionExecutedContext context)
 {
     if (context.Exception is ApplicationException)
     {
        context.Response= context.Request.CreateErrorResponse(HttpStatusCode.BadRequest, context.Exception.Message);
     }
 }

        public override void OnException(HttpActionExecutedContext ctx)
        {
            if (!IgnoreExceptions.Contains(ctx.Exception.GetType()))
            {
                var statusCode = GetStatus(ctx.Exception.GetType());

                var error = new HttpError(ctx.Exception, IncludeErrorDetails(ctx));

                var req = ctx.Request;

                var exLog = ctx.Exception.LogException(e =>
                {
                    e.ActionName = ctx.ActionContext.ActionDescriptor.ActionName;
                    e.ControllerName = ctx.ActionContext.ActionDescriptor.ControllerDescriptor.ControllerName;
                    e.UserAgent = req.Headers.UserAgent.ToString();
                    e.RequestUrl = req.RequestUri.ToString();
                    e.UrlReferer = req.Headers.Referrer?.ToString();
                    e.UserHostAddress = GetClientIp(req);
                    e.UserHostName = GetClientName(req);
                    e.QueryString = ExceptionEntity.Dump(req.RequestUri.ParseQueryString());
                    e.Form = (string)(req.Properties.ContainsKey(SignumAuthenticationAndProfilerAttribute.SavedRequestKey) ? req.Properties[SignumAuthenticationAndProfilerAttribute.SavedRequestKey] : null);
                    e.Session = GetSession(req);
                });

                error["ExceptionID"] = exLog.Id.ToString();

                ctx.Response = ctx.Request.CreateResponse<HttpError>(statusCode, error);
            }

            base.OnException(ctx);
        }