// http://stackoverflow.com/questions/619895/how-can-i-properly-handle-404-in-asp-net-mvc
        private void Application_Error(Object sender, EventArgs e)
        {
            if (!Settings.Enabled)
            {
                return;
            }

            HttpException ex = HttpContext.Current.Server.GetLastError() as HttpException;

            if (ex != null && ex.GetType().Name == "AspNetSessionExpiredException")
            {
                HttpContext.Current.Server.ClearError();
                HttpContext.Current.Response.Redirect(FormsAuthentication.LoginUrl);
            }
            else if (ex != null && ex.GetHttpCode() == 404)
            {
                //HttpContext.Current.Response.Redirect(new { controller = "Error", action = "PageNotFound404" }, _err);
                return;
            }
            else
            {
                if (UnhandledExceptionOccurred != null)
                {
                    UnhandledExceptionOccurred(ex);
                }

                ExceptionOccurred(ex, HttpContext.Current.Response.StatusCode);
            }
        }
Example #2
0
        public int SetErrorLog(HttpException exception, string userIp, string browser, string browserVersion)
        {
            objAppErrorSchema.ErrorCode      = exception.ErrorCode.ToString();
            objAppErrorSchema.Message        = exception.Message;
            objAppErrorSchema.Type           = exception.GetType().ToString();
            objAppErrorSchema.StackTrace     = exception.StackTrace;
            objAppErrorSchema.InnerException = Convert.ToString(exception.InnerException);
            objAppErrorSchema.HtmlError      = (exception.GetHtmlErrorMessage() == null) ? string.Empty : exception.GetHtmlErrorMessage();
            objAppErrorSchema.UserIp         = userIp;
            objAppErrorSchema.Browser        = browser;
            objAppErrorSchema.BrowserVersion = browserVersion;

            int exceptionId;

            try
            {
                exceptionId = objappErrorBL.SaveAppErrorDeatails(objAppErrorSchema);
            }
            catch (Exception ex)
            {
                exceptionId = -1;
                throw ex;
            }
            finally
            {
            }

            return(exceptionId);
        }
        private async Task HandleHttpExceptionAsync(HttpContext context, HttpException exception)
        {
            _logger.LogWarning($"Handling {nameof(HttpException)} ({exception.GetType().Name}).\n" +
                               $"Request: {context.Request.Method} {context.Request.Path}\n" +
                               $"Message: {exception.Message}");

            await WriteErrorsResponse(context.Response, exception);
        }
        public void MediumTrustThrowsSecurityExceptionWhenCopyingBetweenTypesFromDifferentModules()
        {
            Exception     e1 = new Exception("my name is e1");
            HttpException e2 = new HttpException("my name is e2");

            // I know, I am a bit paranoid about that basic assumption
            Assert.AreNotEqual(e1.GetType().Assembly, e2.GetType().Assembly);

            SecurityTemplate.MediumTrustInvoke(new ThreadStart(new CopyCommand(e2, e1).Execute));
            Assert.AreEqual(e1.Message, e2.Message);
        }
        /// <summary>
        /// Generate a HTTP error page (that will be added to the response body).
        /// response status code is also set.
        /// </summary>
        /// <param name="response">Response that the page will be generated in.</param>
        /// <param name="err">exception.</param>
        protected virtual void ErrorPage(IHttpResponse response, HttpException err)
        {
            response.Reason      = err.GetType().Name;
            response.Status      = err.HttpStatusCode;
            response.ContentType = "text/plain";
            StreamWriter writer = new StreamWriter(response.Body);

#if DEBUG
            writer.WriteLine(err);
#else
            writer.WriteLine(err.Message);
#endif
            writer.Flush();
        }
        public void Increment_WithHttpExceptionThatIsNot404_AddsStatusCodeToReadingName()
        {
            var sensor = new ExceptionSensor();

            var exception = new HttpException(500, "Page not found");

            sensor.AddError(exception);

            Reading reading = null;

            ReadingPublisher.Readings.TryDequeue(out reading); // TotalExceptions
            ReadingPublisher.Readings.TryDequeue(out reading);

            Assert.That(reading.Data.Name, Is.EqualTo(exception.GetHttpCode() + exception.GetType().Name));
        }
Example #7
0
        public CrudResponse handleHttpFourAndFiveHundredErrors(CrudResponse response, HttpException error, int id)
        {
            response.ChangedEntityId = id;

            Message message = new Message();

            message.DetailMessage = error.GetHtmlErrorMessage();
            message.Severity      = error.ErrorCode.ToString();
            message.Type          = error.GetType().ToString();

            response.Messages.Add(message);

            response.ErrorCode    = error.GetHttpCode().ToString();
            response.ErrorMessage = error.Message;
            return(response);
        }
Example #8
0
        protected void Application_Error(object sender, EventArgs e)
        {
            Exception     exc = Server.GetLastError();
            HttpException lastErrorWrapper = ((HttpException)(Server.GetLastError()));

            Server.ClearError();

            switch (lastErrorWrapper.GetHttpCode())
            {
            case 404:
                Response.Redirect("~/ErrorPages/404.aspx");
                break;

            case 500:
                string lasterrortype       = lastErrorWrapper.GetType().ToString();
                string lasterrormessage    = lastErrorWrapper.Message;
                string lastErrorstacktrace = lastErrorWrapper.StackTrace;
                Response.Redirect("~/ErrorPages/500.aspx");
                break;
            }
        }
Example #9
0
        private static string GetMessage(HttpException ex)
        {
            var errors = new StringBuilder();

            errors.AppendLine();
#if DEBUG
            errors.AppendLine($"[{ex.GetType().Name}]");
#endif

            switch (ex.WebEventCode)
            {
            // Maximum request length exceeded
            case 3004:
                errors.AppendLine("حجم درخواست از حداکثر طول مجاز تجاوز نموده است.");
                break;

            default:
                errors.AppendLine($"{ex.WebEventCode}: {ex.Message}");
                break;
            }

            return(errors.ToString());
        }
Example #10
0
		/// <summary>
		/// Generate a HTTP error page (that will be added to the response body).
		/// response status code is also set.
		/// </summary>
		/// <param name="response">Response that the page will be generated in.</param>
		/// <param name="err">exception.</param>
		protected virtual void ErrorPage(IHttpResponse response, HttpException err)
		{
			response.Reason = err.GetType().Name;
			response.Status = err.HttpStatusCode;
			response.ContentType = "text/plain";
			StreamWriter writer = new StreamWriter(response.Body);
#if DEBUG
            writer.WriteLine(err);
#else
			writer.WriteLine(err.Message);
#endif
			writer.Flush();
		}
Example #11
0
        private void Handle(HttpException e, Context ctx)
        {
            string result;

            if (ctx.ContentType() == "application/json")
            {
                result = $@"{{""title"": ""{e.Message}"",""status"": {e.Status},""type"": ""{e.GetType().Name}""}}";
            }
            else
            {
                result = $"{e.Status} {e.Message}";
            }
            ctx.Status(e.Status).Result(result);
        }
Example #12
0
        /// <summary>
        /// Handles the Error event of the Application control.
        /// </summary>
        /// <param name="sender">The source of the event.</param>
        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
        protected void Application_Error(object sender, EventArgs e)
        {
            try
            {
                Exception exe = Server.GetLastError();
                if (this.EnvironmentLive)
                {
                    HttpException exec = (HttpException)exe;
                    if (exec != null)
                    {
                        Server.ClearError();
                        string id         = Guid.NewGuid().ToString();
                        bool   isAjaxCall = string.Equals("XMLHttpRequest", Context.Request.Headers["x-requested-with"], StringComparison.OrdinalIgnoreCase);
                        string msg        = "An error has occurred while serving your request. Please contact your administrator for more information.Error Id: " + id;

                        // if (exe.GetType() == typeof(FaultException<BusinessExceptionError>) || exe.GetType() == typeof(FaultException))
                        if ((exec.GetHttpCode() == 401) || (exec.GetHttpCode() == 402) || (exec.GetHttpCode() == 403) || (exec.GetHttpCode() == 404) || (exec.GetHttpCode() == 500) || (exec.GetHttpCode() == 503))
                        {
                            msg = exec.Message;

                            // Logger.Error("BusinessExceptionError OR FaultException");
                            Logger.Error(exec.GetHttpCode() + " Error:");
                            Logger.Error(msg);
                        }
                        else if (exec.GetType() == typeof(HttpException))
                        {
                            msg = exec.Message;

                            Logger.Error("HttpException");
                            Logger.Error(msg);
                        }
                        else
                        {
                            Logger.Error("Error ID :" + id, exec);
                        }
                        if (isAjaxCall)
                        {
                            Response.Clear();
                            Response.ContentType = "application/json";
                            ActionStatus status = new ActionStatus();
                            status.IsSucceed = false;
                            status.Messages.Add(msg);
                            Response.Write(JsonConvert.SerializeObject(status));
                            Response.End();
                        }
                        else
                        {
                            if (!Request.Url.ToString().Contains("Master/Error"))
                            {
                                Response.Redirect("~/Master/Error?msg=" + msg);
                            }
                        }
                    }
                }
                else
                {
                    if (exe != null)
                    {
                        Logger.Error(exe);
                    }
                }
            }
            catch (Exception ex)
            {
                Logger.Error(ex);
            }
        }
Example #13
0
    protected void Page_Load(object sender, EventArgs e)
    {
        Util.setCSS();
        labApplicationName.Text = Util.getAppSetting("app://ApplicationName/");
        if (Server.GetLastError() != null)
        {
            string strErrType = "";
            string strErrMsg  = "";

            //SqlException
            if (string.IsNullOrEmpty(strErrType))
            {
                if (Server.GetLastError().GetBaseException() is System.Data.SqlClient.SqlException)
                {
                    //SqlException
                    System.Data.SqlClient.SqlException ex = (System.Data.SqlClient.SqlException)Server.GetLastError().GetBaseException();
                    strErrType += string.Format(SinoPac.WebExpress.Common.Properties.Resources.Msg_ErrorType, ex.GetType().Name);
                    strErrType += " " + string.Format(SinoPac.WebExpress.Common.Properties.Resources.Msg_ErrorCode, ex.ErrorCode);
                    strErrMsg  += ex.Message.ToString();
                }
            }

            //HttpException
            if (string.IsNullOrEmpty(strErrType))
            {
                if (Server.GetLastError().GetBaseException() is HttpException)
                {
                    HttpException ex = (HttpException)Server.GetLastError().GetBaseException();
                    strErrType += string.Format(SinoPac.WebExpress.Common.Properties.Resources.Msg_ErrorType, ex.GetType().Name);
                    strErrType += " " + string.Format(SinoPac.WebExpress.Common.Properties.Resources.Msg_ErrorCode, ex.GetHttpCode());
                    strErrMsg  += ex.Message.ToString();
                }
            }

            //Exception
            if (string.IsNullOrEmpty(strErrType))
            {
                Exception ex = (Exception)Server.GetLastError().GetBaseException();
                strErrType += string.Format(SinoPac.WebExpress.Common.Properties.Resources.Msg_ErrorType, ex.GetType().Name);
                strErrMsg  += ex.Message.ToString();
            }

            labErrType.Text = Util.getHtmlMessage(Util.HtmlMessageKind.Error, strErrType);
            labErrMsg.Text  = string.Format("<div class='Util_Frame' style='padding:10px;background-color: #ccc;'>{0}</div>", strErrMsg);
        }
    }