public JsonResult GetError(ErrorFilter errorFilter)
{
var error = _BuggerBusiness.GetError(errorFilter);
error.FirstOrDefault().ScreenShot = null;
error.FirstOrDefault().ScreenShotB64 = null;
return(Json(error));
}
protected override void DoConfigure(IConfigSectionNode node)
{
if (node == null)
{
//0 get very root
node = App.ConfigRoot[SysConsts.CONFIG_WAVE_SECTION];
if (!node.Exists)
{
return;
}
//1 try to find the server with the same name as this instance
var snode = node.Children.FirstOrDefault(cn => cn.IsSameName(CONFIG_SERVER_SECTION) && cn.IsSameNameAttr(Name));
//2 try to find a server without a name
if (snode == null)
{
snode = node.Children.FirstOrDefault(cn => cn.IsSameName(CONFIG_SERVER_SECTION) && cn.AttrByName(Configuration.CONFIG_NAME_ATTR).Value.IsNullOrWhiteSpace());
}
if (snode == null)
{
return;
}
node = snode;
}
ConfigAttribute.Apply(this, node);
m_Prefixes.Clear();
foreach (var name in node.Children
.Where(c => c.IsSameName(CONFIG_PREFIX_SECTION))
.Select(c => c.AttrByName(Configuration.CONFIG_NAME_ATTR).Value)
.Where(n => n.IsNotNullOrWhiteSpace()))
{
m_Prefixes.Add(name);
}
var nGate = node[CONFIG_GATE_SECTION];
if (nGate.Exists)
{
m_Gate = FactoryUtils.MakeAndConfigure <INetGateImplementation>(nGate, typeof(NetGate), args: new object[] { this });
}
var nDispatcher = node[CONFIG_DISPATCHER_SECTION];
if (nDispatcher.Exists)
{
m_Dispatcher = FactoryUtils.MakeAndConfigure <WorkDispatcher>(nDispatcher, typeof(WorkDispatcher), args: new object[] { this });
}
ErrorFilter.ConfigureMatches(node[CONFIG_DEFAULT_ERROR_HANDLER_SECTION], m_ErrorShowDumpMatches, m_ErrorLogMatches, null, GetType().FullName);
}
public void Given_there_are_no_filters_that_match_Should_not_exclude_it()
{
var error = new Error(new ArgumentException());
var pipeline = new ErrorFilter();
pipeline.WithExceptionTypes(typeof(InvalidOperationException));
pipeline.WithErrorMessageContaining("test");
var exclude = pipeline.Exclude(error);
Assert.IsFalse(exclude);
}
public void Given_at_least_one_filter_matches_Should_exclude_it()
{
var error = new Error(new ArgumentException("test"));
var pipeline = new ErrorFilter();
pipeline.WithExceptionTypes(typeof(InvalidOperationException));
pipeline.WithErrorMessageContaining("test");
var exclude = pipeline.Exclude(error);
Assert.IsTrue(exclude);
}
public void OnError_ErrorWithoutException_ShouldReturnErrorAsIs()
{
// Arrange
IError error = ErrorBuilder.New()
.SetMessage("Error occurred")
.Build();
var filter = new ErrorFilter();
// Act
IError result = filter.OnError(error);
// Assert
result.Should().Be(error);
}
public void OnError_WithException_ShouldSetErrorCode()
{
// Arrange
IError error = ErrorBuilder.New()
.SetMessage("Error occurred")
.SetException(new NotImplementedException())
.Build();
var filter = new ErrorFilter();
// Act
IError result = filter.OnError(error);
// Assert
result.Code.Should().Be("NOT_IMPLEMENTED");
}
/// <summary>
/// Handles processing exception by calling ErrorFilter.HandleException(work, error).
/// All parameters except ERROR can be null - which indicates error that happened during WorkContext dispose
/// </summary>
public virtual void HandleException(WorkContext work, WorkFilter filter, WorkHandler handler, Exception error)
{
try
{
if (m_InstrumentationEnabled)
{
Interlocked.Increment(ref m_stat_ServerHandleException);
}
//work may be null (when WorkContext is already disposed)
if (work != null)
{
ErrorFilter.HandleException(work, error, m_ErrorShowDumpMatches, m_ErrorLogMatches);
}
else
{
Log(MessageType.Error,
StringConsts.SERVER_DEFAULT_ERROR_WC_NULL_ERROR + error.ToMessageWithType(),
"HandleException()",
error);
}
}
catch (Exception error2)
{
if (m_LogHandleExceptionErrors)
{
try
{
Log(MessageType.Error,
StringConsts.SERVER_DEFAULT_ERROR_HANDLER_ERROR + error2.ToMessageWithType(),
"HandleException.catch()",
error2,
pars: new
{
OriginalError = error.ToMessageWithType()
}.ToJSON()
);
}
catch {}
}
}
}
public void OnError_WithExceptionContainingProperties_ShouldSetErrorData()
{
// Arrange
IError error = ErrorBuilder.New()
.SetMessage("Error occurred")
.SetException(new PropertiesException(123, "abc"))
.Build();
var filter = new ErrorFilter();
// Act
IError result = filter.OnError(error);
// Assert
result.Extensions.Keys.Should().Contain("data");
var data = result.Extensions["data"] as IReadOnlyDictionary <string, object>;
data.Should().NotBeNull();
data["paramA"].Should().Be(123);
data["paramB"].Should().Be("abc");
}
internal static List <Error> GetError(ErrorFilter errorFilter)
{
List <Error> result = new List <Error>();
using (SqlConnection sqlcon = new SqlConnection(Settings.GetCS()))
{
using (SqlCommand cmd = new SqlCommand("SP_GetError", sqlcon))
{
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.Add("@ErrorId", SqlDbType.Int).Value = CheckDBNUll(errorFilter.ErrorId);
cmd.Parameters.Add("@ProjectId", SqlDbType.Int).Value = CheckDBNUll(errorFilter.ProjectId);
cmd.Parameters.Add("@AssigneeUserId", SqlDbType.Int).Value = CheckDBNUll(errorFilter.UserId);
cmd.Parameters.Add("@ErrorSeverityId", SqlDbType.NVarChar).Value = CheckDBNUll_STR(errorFilter.ErrorSeverity);
cmd.Parameters.Add("@ErrorTypeId", SqlDbType.NVarChar).Value = CheckDBNUll_STR(errorFilter.ErrorType);
cmd.Parameters.Add("@ErrorStatusId", SqlDbType.NVarChar).Value = CheckDBNUll_STR(errorFilter.ErrorStatus);
cmd.Parameters.Add("@PageSize", SqlDbType.Int).Value = CheckDBNUll(errorFilter.PageSize);
cmd.Parameters.Add("@PageNumber", SqlDbType.Int).Value = CheckDBNUll(errorFilter.PageNumber);
using (SqlDataAdapter da = new SqlDataAdapter(cmd))
{
using (DataSet ds = new DataSet())
{
da.Fill(ds);
result = ds.Tables[0].ToListof <Error>();
//foreach(Error err in result)
//{
// err.ScreenShotB64 = Convert.ToBase64String(err.ScreenShot);
// err.ScreenShot = null;
//}
}
}
}
}
return(result);
}
private void Error_Filter_Catch()
{
var errorFilter = new ErrorFilter();
var context = new ExceptionContext(
new ActionContext()
{
HttpContext = new DefaultHttpContext(),
ActionDescriptor = new ActionDescriptor(),
RouteData = new RouteData()
},
new List <IFilterMetadata>()
);
context.Exception = _throwedException;
errorFilter.OnException(context);
_statusCode = context.HttpContext.Response.StatusCode;
_result = context.Result;
_isExceptionHandled = context.ExceptionHandled;
}
private void ConfigureFilters(string config)
{
var doc = new XmlDocument();
doc.Load(config);
var filterNodes = doc.SelectNodes("//errorFilter");
if (filterNodes != null)
{
foreach (XmlNode filterNode in filterNodes)
{
var notList = new List <string>();
var notifiers = filterNode.SelectNodes("//notifier");
{
if (notifiers != null)
{
foreach (XmlElement notifier in notifiers)
{
var name = notifier.Attributes["name"]?.Value;
if (name != null)
{
notList.Add(name);
}
}
}
}
var assertionNode = (XmlElement)filterNode.SelectSingleNode("test/*");
if (assertionNode != null)
{
var a = AssertionFactory.Create(assertionNode);
var filter = new ErrorFilter(a, notList);
Filtering += filter.OnErrorModuleFiltering;
_filters.Add(filter);
}
}
}
}
public MemoryStream GetExcelReport(ErrorFilter errorFilter)
{
var masterRecord = GetMasterRecords();
var result = Core.GetError(errorFilter);
// ScreenshotUrlFrameUp
foreach (Error err in result)
{
err.E_ScreenShotUrl = HttpContext.Current.Request.Url.AbsoluteUri.Replace(HttpContext.Current.Request.Url.PathAndQuery, "") + Settings.ScreenSHotURLPrefix + err.ErrorId;
err.E_Project = masterRecord.project.Where(x => x.ProjectId.Equals(err.ProjectId)).FirstOrDefault().ProjectName;
err.E_ErrorSeverity = masterRecord.ErrorSeverity.Where(x => x.EId.Equals(err.ErrorSeverityId)).FirstOrDefault().EDisplayName;
err.E_ErrorType = masterRecord.ErrorType.Where(x => x.EId.Equals(err.ErrorTypeId)).FirstOrDefault().EDisplayName;
err.E_ErrorStatus = masterRecord.ErrorStatus.Where(x => x.EId.Equals(err.ErrorStatusId)).FirstOrDefault().EDisplayName;
err.E_AssigneeUser = masterRecord.UserList.Where(x => x.UserId.Equals(err.AssigneeUserId)).FirstOrDefault().UserName;
err.E_OwnerUser = masterRecord.UserList.Where(x => x.UserId.Equals(err.OwnerUserId)).FirstOrDefault().UserName;
}
var dataTable = Helper.ConvertToDataTable <Error>(result);
return(Helper.GetExcelSheetMemoryStream(dataTable));
}
public ErrorFilterTests()
{
_errorFilter = new ErrorFilter();
}
public List <Error> GetError(ErrorFilter errorFilter)
{
var result = Core.GetError(errorFilter);
return(result);
}
public FileResult GetExcelReport(ErrorFilter error)
{
return(new FileStreamResult(_BuggerBusiness.GetExcelReport(error), "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"));
}
public static ErrorFilter WithUrlMatching(this ErrorFilter pipeline, string expression)
{
pipeline.WithFilter(new RegexUrlErrorFilter(expression));
return(pipeline);
}
public static ErrorFilter WithUrlFragment(this ErrorFilter pipeline, string urlFragment)
{
pipeline.WithFilter(new ContainsUrlFragmentErrorFilter(urlFragment));
return(pipeline);
}
public static ErrorFilter WithHttpCode(this ErrorFilter pipeline, HttpStatusCode statusCode)
{
pipeline.WithFilter(new HttpCodeErrorFilter(statusCode));
return(pipeline);
}
public ActionResult GetError(ErrorFilter errorFilter)
{
ViewBag.ErrorFilter = errorFilter;
return(View(_BuggerBusiness.GetError(errorFilter)));
}
