/// <summary> /// Запись в лог /// </summary> /// <param name="logLevel">Уровень</param> /// <param name="message">Текст записи</param> /// <param name="exception">Исключение</param> public LogEntry(ErrorLevel logLevel, string message, Exception exception) : this() { Level = logLevel; Message = message; Exception = exception; }
public static void Output(string Message, ErrorLevel Level) { if (Level >= ErrorLevel.Error) ErrorStream.WriteLine("{0}: {1}", Level.ToString(), Message); else Console.WriteLine("{0}: {1}", Level.ToString(), Message); }
/// <summary> /// Creates a new reader /// </summary> /// <param name="stream"></param> /// <param name="errorLevel"></param> public FbxAsciiReader(Stream stream, ErrorLevel errorLevel = ErrorLevel.Checked) { if(stream == null) throw new ArgumentNullException(nameof(stream)); this.stream = stream; this.errorLevel = errorLevel; }
public void Log(object message, ErrorLevel level, SocketKey key = null) { lock (_logLock) { entries.Add(new LogEntry() { timestamp = DateTime.Now, level = level, key = key, message = MsgFmt(message) }); } switch (level) { case ErrorLevel.Info: Debug.Log(KeyFmt(key) + message); break; case ErrorLevel.Warning: Debug.LogWarning(KeyFmt(key) + message); break; case ErrorLevel.Error: Debug.LogError(KeyFmt(key) + message); break; } }
public DataReturnUploadError(ErrorLevel errorLevel, UploadErrorType errorType, string description, int lineNumber = 0) { ErrorType = errorType; ErrorLevel = errorLevel; Description = description; LineNumber = lineNumber; }
public void Handle(Exception exception, ErrorLevel errorLevel) { if (exception is WrappedException) _reportAnyManagedExceptions(exception.Message, ((WrappedException) exception).Exception, errorLevel); else _reportAnyManagedExceptions(exception.Message, exception, errorLevel); if (errorLevel < SdeAppConfiguration.WarningLevel) return; if (_exceptionAlreadyShown(exception.Message)) return; if (Application.Current != null) { _checkMainWindow(); if (IgnoreNoMainWindow) { WindowProvider.ShowWindow(new ErrorDialog("Information", _getHeader(errorLevel) + exception.Message, errorLevel), WpfUtilities.TopWindow); } else { if (!Application.Current.Dispatch(() => Application.Current.MainWindow != null && Application.Current.MainWindow.IsLoaded)) { _showBasicError(_getHeader(errorLevel) + exception.Message, "Information"); return; } Application.Current.Dispatch(() => WindowProvider.ShowWindow(new ErrorDialog("Information", _getHeader(errorLevel) + exception.Message, errorLevel), Application.Current.MainWindow)); } } }
public LogEntry(DateTime errorDateTime, ErrorLevel errorLevel, string tag,string message) { this.errorDateTime = errorDateTime; this.errorLevel = errorLevel; this.tag = tag; this.message = message; }
public XmlValidationError(ErrorLevel errorLevel, XmlErrorType errorType, string message, int? lineNumber = null) { ErrorLevel = errorLevel; ErrorType = errorType; Message = message; LineNumber = lineNumber; }
internal DaqException(string errorMessage, ErrorCodes errorCode) : base(errorMessage) { m_errorCode = errorCode; m_level = ErrorLevel.Error; m_lastResponse = null; }
public LanguageError(string file, string key, string message, ErrorLevel level = ErrorLevel.MissingString) { File = file; Key = key; Message = message; Level = level; }
public CodeError(ErrorType Type, ErrorLevel Level, CodeLine Line, string Remarks = "") { this.Type = Type; this.Level = Level; this.Line = Line; this.Remarks = Remarks; }
public static void Error(this IEventRegistry registry, IEventSource source, int errorClass, int errorCode, ErrorLevel level, string message, string stackTrace, string errorSource) { var errorEvent = new ErrorEvent(source, errorClass, errorCode, message); errorEvent.ErrorLevel(level); errorEvent.StackTrace(stackTrace); errorEvent.ErrorSource(errorSource); registry.RegisterEvent(errorEvent); }
public static void LogException(object ex, ErrorLevel level) { var e = ex as Exception; if (e != null) { Log(String.Format("{0} - {1}\r\n{2}", level, e.Message, e.StackTrace)); } }
// This is the only thing that needs to be overriden public virtual bool Message(MessageSource source, ErrorLevel level, IToken tok, string msg) { bool discard = (ErrorsOnly && level != ErrorLevel.Error) || // Discard non-errors if ErrorsOnly is set (tok is TokenWrapper && !(tok is NestedToken) && !(tok is RefinementToken)); // Discard wrapped tokens, except for nested and refinement if (!discard) { AllMessages[level].Add(new ErrorMessage { token = tok, message = msg }); } return !discard; }
public Error(IErrorSource source, string message, ErrorLevel errorLevel) { if (source == null) throw new ArgumentNullException(nameof(source)); _source = source; _message = message; _errorLevel = errorLevel; }
public CompilerException(string fileName, int lineNumber, ErrorLevel level, int errorCode, string message) { _fileName = fileName; _lineNumber = lineNumber; _level = level; _errorCode = errorCode; _message = message; }
public LogEntry(string processedString) { string[] parts = processedString.Split(new string[] { " :: " },StringSplitOptions.None); this.errorDateTime = DateTime.Parse(parts[0]); this.errorLevel = (ErrorLevel)Enum.Parse(typeof(ErrorLevel), parts[1]); this.tag = parts[2]; this.message = parts[3]; }
public static void Log(string message, ErrorLevel x, params string[] args) { string msg = Build (string.Format (message, args), x); Console.WriteLine (msg); if (autoFlush) Flush (); }
public ErrorEvent(Exception error, int errorCode, ErrorLevel level) { if (error == null) throw new ArgumentNullException("error"); Error = error; ErrorCode = errorCode; Level = level; }
/// <summary> /// Adds an error message to the Error List. /// </summary> /// <param name="_level">Error level.</param> /// <param name="_errorCode">Error code.</param> /// <param name="_errorText">Error message text.</param> /// <param name="_lineNum">The source code line that raises the error message.</param> public static void Add(ErrorLevel _level, string _errorCode, string _errorText, int _lineNum) { OutputErrorMessage.Instance.Code = _errorCode; OutputErrorMessage.Instance.Level = _level; OutputErrorMessage.Instance.LineNum = _lineNum; OutputErrorMessage.Instance.Text = _errorText; Api.SendMessage(Session.CurrentSession.MDIParent.Handle.ToInt32(), Convert.ToInt32(MessageHelper.Messages.AddErrorMessage), 0, 0); }
public CompilerError () { ErrorLevel = ErrorLevel.None; ErrorMessage = String.Empty; SourceFile = String.Empty; ErrorNumber = 0; SourceColumn = 0; SourceLine = 0; }
/// <summary> /// Creates a new reader /// </summary> /// <param name="stream">The stream to read from</param> /// <param name="errorLevel">When to throw an <see cref="FbxException"/></param> /// <exception cref="ArgumentException"><paramref name="stream"/> does /// not support seeking</exception> public FbxBinaryReader(Stream stream, ErrorLevel errorLevel = ErrorLevel.Checked) { if(stream == null) throw new ArgumentNullException(nameof(stream)); if(!stream.CanSeek) throw new ArgumentException( "The stream must support seeking. Try reading the data into a buffer first"); this.stream = new BinaryReader(stream, Encoding.ASCII); this.errorLevel = errorLevel; }
public static void Log(string message, ErrorLevel x = ErrorLevel.Info) { string msg = Build (message, x); messages.Enqueue (msg); Console.WriteLine (msg); if (autoFlush) Flush (); }
public static void Handle(string exception, string id, ErrorLevel errorLevel = ErrorLevel.Warning) { DebugStreamReader reader = TextFileHelper.LastReader; if (reader != null) { Handle(String.Format("ID: {0}, file: '{1}', line: {2}, exception: '{3}'", id, TextFileHelper.LatestFile, reader.LineNumber, exception), errorLevel); } else { Handle(String.Format("ID: {0}, exception: '{1}'", id, exception), errorLevel); } }
public void LogError(string error, ErrorLevel errorLevel) { if ((int)errorLevel >= _minErrorLevelLogged) { using (var sw = new StreamWriter(_logFilePath, true)) { sw.WriteLine(string.Format("{0} : {1}", errorLevel, error)); } } }
private void defaultErrorDelegate(ErrorKind error, ErrorLevel level, string errormessage) { if (level == ErrorLevel.K_LWARN) { // TODO: use a user supplied callback here or provide some other mechanism to override this // NOTE: if using a callback here, the user _must not_ throw exceptions in that callback /* Console.WriteLine("nlibk warning: {0}", errormessage); */ return; } LastError = error; LastErrorMessage = errormessage; }
public async static void Log(ErrorLevel level, Exception e = null, string message = null) { ErrorLog log; if (e != null) log = new ErrorLog(e, message); else if (message != null) log = new ErrorLog(message); else throw new ArgumentException("Both parameters cannot be null!", "e"); await ExternalApi.Post<bool>(ConfigUtilities.GetString("ErrorLogUrl"), log); }
public BlockStatus(string message, ErrorLevel level) { this.Explanation = message; this.ErrorLevel = level; switch(level) { case Publishing.ErrorLevel.ManualCorrection: Brush = Brushes.Red; break; case Publishing.ErrorLevel.AutoCorrection: Brush = Brushes.Yellow; break; case Publishing.ErrorLevel.Warning: Brush = Brushes.Cyan; break; case Publishing.ErrorLevel.No: Brush = Brushes.Green; break; } }
private static void WriteInLogFile(FileMode fileMode, string filePath, ErrorLevel errorLevel, string message, Exception ex) { using (var stream = new FileStream(filePath, fileMode)) using (var stringWriter = new StreamWriter(stream)) { stringWriter.WriteLine("====================Begin Error===================="); stringWriter.WriteLine("Error level: " + errorLevel.ToString()); stringWriter.WriteLine("Message from app: " + message); stringWriter.WriteLine("Exception: " + ex.ToString()); stringWriter.WriteLine("Time: " + DateTime.UtcNow); stringWriter.WriteLine("====================End Error===================="); } }
private ConsoleColor ColorForLevel(ErrorLevel level) { switch (level) { case ErrorLevel.Error: return ConsoleColor.Red; case ErrorLevel.Warning: return ConsoleColor.Yellow; case ErrorLevel.Info: return ConsoleColor.Green; default: throw new cce.UnreachableException(); } }
public ParserInitializationError(ErrorLevel level, string message) : base(level, message) { }
/// <summary> /// Записать в лог /// </summary> /// <param name="level">Уровень</param> /// <param name="message">Текст</param> public void Log(ErrorLevel level, string message) { Log(new LogEntry { Level = level, Message = message }); }
public static void Log(ErrorLevel level, string message) { errorList.Add(new Error(level, message)); }
// Return value indicates download success static async Task <bool> TryDownloadFile(Func <Task <Stream> > func, string outputFile, ErrorLevel level = ErrorLevel.Info) { try { using (var astrm = await func.Invoke()) using (var sw = File.Create(outputFile)) await astrm.CopyToAsync(sw); return(true); } catch (Exception ex) { if (level == ErrorLevel.Error) { throw; } if (level == ErrorLevel.Info) { Trace.WriteLine($"Failed to download {Path.GetFileName (outputFile)}: {ex.Message}"); } return(false); } }
internal void Error(ErrorCode code, ErrorLevel level = ErrorLevel.Error) { Errors.Add(new Error(level, code, Lexer.LastTokenLine)); CheckTooManyErrors(); }
/// <summary> /// Initializes a new instance of the <see cref="MessageEventArgs"/> class. /// </summary> /// <param name="text">The text for the message.</param> /// <param name="caption">The title (caption) for the message.</param> /// <param name="errorlevel">The error level for the message, or None for no error level information.</param> public MessageEventArgs(string text, string caption, ErrorLevel errorlevel) { this.Text = text; this.Caption = caption; this.ErrorLevel = errorlevel; }
public ValidationRuleEntierRequis(string name, IValidationRule nextValidationRule, string messageValidationRule, ErrorLevel errorLevelValidationRule, ValidationDataEntier validationDataEntier) : base(name, nextValidationRule, messageValidationRule, errorLevelValidationRule) { ValidationDataEntier = validationDataEntier; ValidationDataEntier.Rules.Add(Name); }
public Error(DateTime dateTime, ErrorLevel level, string message) { this.DateTime = dateTime; this.ErrorLevel = level; this.Message = message; }
public static void Handle(Exception err, string exception, string id, int line, ErrorLevel errorLevel) { if (line < 0) { Handle(err, exception, id, errorLevel); return; } Handle(err, String.Format("ID: {0}, file: '{1}', line: {2}, exception: '{3}'", id, TextFileHelper.LatestFile, line, exception), errorLevel); }
/// <summary> /// Initializes a new instance of the <see cref="DataErrorInfo" /> class. /// </summary> /// <param name="message"> /// The message. /// </param> /// <param name="errorLevel"> /// The error level. /// </param> public DataErrorInfo(string message, ErrorLevel errorLevel) : this(message, errorLevel, null) { }
public static void AddMsg(ValidateContext validateContext, ExtendedDataEntity entity, string title, string msg, string displayToFieldKey = "", ErrorLevel errorLevel = 2) { if (displayToFieldKey.IsNullOrEmptyOrWhiteSpace()) { displayToFieldKey = validateContext.BusinessInfo.GetBillNoField().Key; } AddMsg(validateContext, entity, displayToFieldKey, entity["Id"].ToString(), title, msg, errorLevel); }
internal void Error(ErrorCode code, Token token, string description, ErrorLevel level = ErrorLevel.Error) { Errors.Add(new Error(level, code, description, Lexer.LastTokenLine)); CheckTooManyErrors(); }
internal void Error(ErrorCode code, Token token, ErrorLevel level = ErrorLevel.Error) { Errors.Add(new Error(level, code, token.Value.MakeQuoted(), Lexer.LastTokenLine)); CheckTooManyErrors(); }
public void ShowError(string obj, EventHandler okClick = null, bool bCreateButtonEvent = false, int iAddCounterSeconds = 0, ErrorLevel errorLevel = ErrorLevel.Normal) { var errorSettings = new ErrorSettings(); errorSettings.ErrorLevel = errorLevel; errorSettings.OkClick = okClick; errorSettings.CreateButtonEvent = bCreateButtonEvent; errorSettings.AddCounterSeconds = iAddCounterSeconds; if (errorSettings.ErrorLevel == ErrorLevel.Normal) { errorSettings.WarningVisibility = Visibility.Collapsed; } if (errorSettings.ErrorLevel == ErrorLevel.ModalWindow) { errorSettings.ErrorLevel = ErrorLevel.Critical; errorSettings.HideButtons = true; } ShowError(obj, errorSettings); }
public Error(ErrorLevel errorLevel, DateTime dateTime, string message) { this.ErrorLevel = errorLevel; this.DateTime = dateTime; this.Message = message; }
/// <summary> /// Gets all the mods and patches them. /// </summary> private void worker_DoWork(object sender, DoWorkEventArgs e) { _errorLevel = ErrorLevel.NoError; //Gets the list of mods ItemCollection modCollection = null; string lolLocation = null; //Get the data from the UI thread Dispatcher.Invoke(DispatcherPriority.Input, new ThreadStart(() => { modCollection = ModsListBox.Items; lolLocation = LocationTextbox.Text; })); SetStatusLabelAsync("Gathering mods..."); //Gets the list of mods that have been checked. List <LessMod> modsToPatch = new List <LessMod>(); foreach (var x in modCollection) { CheckBox box = (CheckBox)x; bool isBoxChecked = false; Dispatcher.Invoke(DispatcherPriority.Input, new ThreadStart(() => { isBoxChecked = box.IsChecked ?? false; })); if (isBoxChecked) { modsToPatch.Add(_lessMods[box]); } } //Create a new dictionary to hold the SWF definitions in. This stops opening and closing the same SWF file if it's going to be modified more than once. Dictionary <string, SwfFile> swfs = new Dictionary <string, SwfFile>(); //Start the stopwatch to see how long it took to patch (aiming for ~5 sec or less on test machine) timer = Stopwatch.StartNew(); //Go through each modification foreach (var lessMod in modsToPatch) { SetStatusLabelAsync("Patching mod: " + lessMod.Name); //Go through each patch within the mod foreach (var patch in lessMod.Patches) { //If the swf hasn't been loaded, load it into the dictionary. if (!swfs.ContainsKey(patch.Swf)) { string fullPath = Path.Combine(lolLocation, patch.Swf); //Backup the SWF string CurrentLocation = ""; string[] FileLocation = patch.Swf.Split('/', '\\'); foreach (string s in FileLocation.Take(FileLocation.Length - 1)) { CurrentLocation = Path.Combine(CurrentLocation, s); if (!Directory.Exists(Path.Combine(lolLocation, "LESsBackup", BackupVersion, CurrentLocation))) { Directory.CreateDirectory(Path.Combine(lolLocation, "LESsBackup", BackupVersion, CurrentLocation)); } } if (!File.Exists(Path.Combine(lolLocation, "LESsBackup", BackupVersion, patch.Swf))) { File.Copy(Path.Combine(lolLocation, patch.Swf), Path.Combine(lolLocation, "LESsBackup", BackupVersion, patch.Swf)); } swfs.Add(patch.Swf, SwfFile.ReadFile(fullPath)); } //Get the SWF file that is being modified SwfFile swf = swfs[patch.Swf]; //Get the ABC tags (containing the code) from the swf file. List <DoAbcTag> tags = swf.GetDoAbcTags(); bool classFound = false; foreach (var tag in tags) { //check if this tag contains our script ScriptInfo si = tag.GetScriptByClassName(patch.Class); //check next tag if it doesn't if (si == null) { continue; } ClassInfo cls = si.GetClassByClassName(patch.Class); classFound = true; Assembler asm; //Perform the action based on what the patch defines switch (patch.Action) { case "replace_trait": //replace trait (method) //Load the code from the patch and assemble it to be inserted into the code asm = new Assembler(File.ReadAllText(Path.Combine(lessMod.Directory, patch.Code))); TraitInfo newTrait = asm.Assemble() as TraitInfo; int traitIndex = cls.Instance.GetTraitIndexByTypeAndName(newTrait.Type, newTrait.Name.Name); bool classTrait = false; if (traitIndex < 0) { traitIndex = cls.GetTraitIndexByTypeAndName(newTrait.Type, newTrait.Name.Name); classTrait = true; } if (traitIndex < 0) { throw new TraitNotFoundException(String.Format("Can't find trait \"{0}\" in class \"{1}\"", newTrait.Name.Name, patch.Class)); } //Modified the found trait if (classTrait) { cls.Traits[traitIndex] = newTrait; } else { cls.Instance.Traits[traitIndex] = newTrait; } break; case "replace_cinit": //replace class constructor //Load the code from the patch and assemble it to be inserted into the code asm = new Assembler(File.ReadAllText(Path.Combine(lessMod.Directory, patch.Code))); cls.ClassInit = asm.Assemble() as MethodInfo; break; case "replace_iinit": //replace instance constructor //Load the code from the patch and assemble it to be inserted into the code asm = new Assembler(File.ReadAllText(Path.Combine(lessMod.Directory, patch.Code))); cls.Instance.InstanceInit = asm.Assemble() as MethodInfo; break; case "add_class_trait": //add new class trait (method) //Load the code from the patch and assemble it to be inserted into the code asm = new Assembler(File.ReadAllText(Path.Combine(lessMod.Directory, patch.Code))); newTrait = asm.Assemble() as TraitInfo; traitIndex = cls.GetTraitIndexByTypeAndName(newTrait.Type, newTrait.Name.Name); if (traitIndex < 0) { cls.Traits.Add(newTrait); } else { cls.Traits[traitIndex] = newTrait; } break; case "add_instance_trait": //add new instance trait (method) //Load the code from the patch and assemble it to be inserted into the code asm = new Assembler(File.ReadAllText(Path.Combine(lessMod.Directory, patch.Code))); newTrait = asm.Assemble() as TraitInfo; traitIndex = cls.Instance.GetTraitIndexByTypeAndName(newTrait.Type, newTrait.Name.Name); if (traitIndex < 0) { cls.Instance.Traits.Add(newTrait); } else { cls.Instance.Traits[traitIndex] = newTrait; } break; case "remove_class_trait": throw new NotImplementedException(); case "remove_instance_trait": throw new NotImplementedException(); default: throw new NotSupportedException($"Unknown Action \"{patch.Action}\" in mod {lessMod.Name}"); } } if (!classFound) { _errorLevel = ErrorLevel.UnableToPatch; throw new ClassNotFoundException($"Class {patch.Class} not found in file {patch.Swf}"); } } } //Save the modified SWFS to their original location foreach (var patchedSwf in swfs) { try { SetStatusLabelAsync("Applying mods: " + patchedSwf.Key); string swfLoc = Path.Combine(lolLocation, patchedSwf.Key); SwfFile.WriteFile(patchedSwf.Value, swfLoc); } catch { _errorLevel = ErrorLevel.GoodJobYourInstallationIsProbablyCorruptedNow; if (Debugger.IsAttached) { throw; } } } timer.Stop(); }
public ConsoleAppender(ILayout layout, ErrorLevel errorLevel) { this.Layout = layout; this.ErrorLevel = errorLevel; this.MessagesAppended = 0; }
/// <summary> /// Записать в лог с приложением исключения /// </summary> /// <param name="level">Уровень записи</param> /// <param name="message">Текст</param> /// <param name="exception">Исключение</param> public void Exception(ErrorLevel level, string message, Exception exception) { Log(new LogEntry { Level = level, Message = message, Exception = exception }); }
public JsonPacket Create(string project, Exception exception, SentryMessage message = null, ErrorLevel level = ErrorLevel.Error, IDictionary <string, string> tags = null, string[] fingerprint = null, object extra = null) { throw new NotImplementedException(); }
#pragma warning disable 612 public void SetWorkflowTerminated(ProcessInstance processInstance, ErrorLevel level, string errorMessage) #pragma warning restore 612 { SetCustomStatus(processInstance.ProcessId, ProcessStatus.Terminated); }
internal Error(ErrorLevel level, string message) { this.level = level; this.message = message; }
private static void AssertThatFieldHasError(DocField field, ErrorLevel expectedErrorLevel, string expectedErrorText) { Assert.That(field.ErrorLevel, Is.EqualTo(expectedErrorLevel)); Assert.That(field.ErrorText, Is.EqualTo(expectedErrorText)); }
private static void AssertThatTrustDateHasSpecificErrorLevel(TrustDate trustDate, ErrorLevel expectedErrorLevel, string expectedErrorText) { AssertThatFieldHasError(trustDate.Day, expectedErrorLevel, expectedErrorText); AssertThatFieldHasError(trustDate.Month, expectedErrorLevel, expectedErrorText); AssertThatFieldHasError(trustDate.Year, expectedErrorLevel, expectedErrorText); }
public ErrorForm(ErrorFormTemplate errorFormTemplate) { if (null == errorFormTemplate) { throw new ArgumentNullException(nameof(errorFormTemplate)); } if (ApplicationUtility.IsRunningOnMono) { Font = new Font("Arial", 8); } InitializeComponent(); _originalCaption = errorFormTemplate.OriginalCaption ?? throw new BadTemplateException("null == errorFormTemplate.Caption"); Text = errorFormTemplate.Caption; captionLabel.Text = errorFormTemplate.Caption; messageRichTextBox.Text = errorFormTemplate.Message ?? throw new BadTemplateException("null == errorFormTemplate.Message"); if (null != errorFormTemplate.Details) { detailsRichTextBox.Text = errorFormTemplate.Details; } _errorLevel = errorFormTemplate.Level; ((ISupportInitialize)iconPictureBox).BeginInit(); switch (errorFormTemplate.Level) { case ErrorLevel.Error: iconPictureBox.Image = iconImageList.Images[0]; break; case ErrorLevel.Warning: iconPictureBox.Image = iconImageList.Images[1]; break; } ((ISupportInitialize)iconPictureBox).EndInit(); _heightDifference = detailsRichTextBox.Height + detailsRichTextBox.Margin.Top + detailsRichTextBox.Margin.Bottom + separatorLabel.Height + separatorLabel.Margin.Top + separatorLabel.Margin.Bottom + reportButton.Height + reportButton.Margin.Top + reportButton.Margin.Bottom; HideDetails(); _detailsVisible = false; if (null == errorFormTemplate.Details) { detailsButton.Enabled = false; } reportButton.Enabled = null != SupportAction; }
public ConsoleAppender(ILayout layout, ErrorLevel level) { this.Layout = layout; this.Level = level; this.MessagesAppendet = 0; }
public override bool Message(MessageSource source, ErrorLevel level, Bpl.IToken tok, string msg) { return(false); }
/// <summary> /// Overrides the default error level. /// <para>The default error level is "error".</para> /// </summary> /// <param name="level"> /// The error level to use for the captured event /// </param> public SentryEventBuilder SetErrorLevel(ErrorLevel level) { _errorLevel = level; return(this); }
public Diagnostic(string message, TextLocation location, ErrorLevel level) { Message = message; Location = location; Level = level; }
public static void Handle(Exception err, string exception, string id, int line, string file, ErrorLevel level) { Handle(err, String.Format("ID: {0}, file: '{1}', line: {2}, exception: '{3}'", id, file, line, exception), level); }
public static void AddMsg(ValidateContext validateContext, ExtendedDataEntity entity, string displayToFieldKey, string id, string title, string msg, ErrorLevel errorLevel = 2) { ValidationErrorInfo errorInfo = new ValidationErrorInfo(displayToFieldKey, entity.DataEntity["Id"].ToString(), entity.DataEntityIndex, entity.RowIndex, id, msg, title, errorLevel); validateContext.AddError(entity.DataEntity, errorInfo); }