public void CheckArg(ParserRuleContext context, out ErrorInformation error) { error = null; var identifierContext = ((Arg_declarationContext)context).identifier(); if (identifierContext != null) { _identifier = identifierContext.GetText(); if (_identifier == UppercaseFirst(_identifier)) { List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>() { new ReplaceCodeInfomation() { Start = identifierContext.Start.StartIndex, Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1, ReplaceCode = LowercaseFirst(_identifier) } }; error = new ErrorInformation { StartIndex = identifierContext.Start.StartIndex, Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1, ErrorCode = "IF0006", DisplayText = string.Format("Fix name violation: {0}", replaceCodes[0].ReplaceCode), ReplaceCode = replaceCodes, ErrorMessage = "UIT: Naming rule violation: argument should begin with lower case characters." }; } } }
public void CheckConditionalStatement(ParserRuleContext context, out ErrorInformation error) { error = null; var relationalExpressionContext = ((Equality_expressionContext)context).relational_expression(); bool isBoolConditional = (context.GetText().Contains("true") || context.GetText().Contains("false")); if (isBoolConditional && relationalExpressionContext.Length == 2) { List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>() { new ReplaceCodeInfomation() { Start = context.Start.StartIndex, Length = context.Stop.StopIndex - context.Start.StartIndex + 1, ReplaceCode = ReplaceCode(context.GetText()) } }; error = new ErrorInformation() { ErrorCode = "IF0001", ReplaceCode = replaceCodes, DisplayText = "Simply statement", ErrorMessage = "UIT: Bool return type in conditional statement could be simplied", StartIndex = context.Start.StartIndex, Length = context.Stop.StopIndex - context.Start.StartIndex + 1 }; } }
protected Exception BuildExceptionForResponse(IRestResponse response) { if (response is null) { return(new IgdbClientException(ERR_MSG_UNKNOWN)); } if (response.StatusCode != 0 && response.StatusCode != System.Net.HttpStatusCode.OK && response.StatusCode != System.Net.HttpStatusCode.Accepted && response.StatusCode != System.Net.HttpStatusCode.Created) { JsonDeserializer jsonDeserializer = new JsonDeserializer(); ErrorInformation errorInformation = jsonDeserializer.Deserialize <List <ErrorInformation> >(response)?.FirstOrDefault(); Exception ex = errorInformation != null && errorInformation.Status != 0 ? new IgdbClientBadStatusException(errorInformation) : new IgdbClientBadStatusException(ERR_MSG_BAD_STATUS); return(ex); } return(response.IsSuccessful ? null : new IgdbClientException(response.ErrorMessage, response.ErrorException)); }
public async Task Error_ERROR_on_generating_PROJECT(ErrorInformation error, string project) { await Runner.AddSteps( _ => Given_is_the_project(project), _ => When_I_generate_all_metafiles(), _ => Then_the_error_is_shown(error)).RunAsyncWithTimeout(); }
/// <summary> /// Plays the prompt specified by <see cref="currentMenu"/> on the <paramref name="flow"/>. /// </summary> /// <param name="flow"><see cref="AudioVideoFlow"/> on which the prompt is to be played.</param> /// <returns>void; it is an <i>async</i> method.</returns> private async Task PlayPromptAsync(IAudioVideoFlow flow) { if (flow == null) { throw new ArgumentNullException(nameof(flow)); } string resourceName = currentMenu.Prompt; Logger.Instance.Information("[AudioVideoIVRJob] Playing prompt : {0}.", resourceName); try { var resourceUri = new Uri(string.Format(azureApplication.ResourceUriFormat, resourceName)); await flow.PlayPromptAsync(resourceUri, loggingContext).ConfigureAwait(false); } catch (CapabilityNotAvailableException ex) { Logger.Instance.Error("[AudioVideoIVRJob] PlayPrompt api is not available!", ex); } catch (RemotePlatformServiceException ex) { ErrorInformation error = ex.ErrorInformation; if (error != null && error.Code == ErrorCode.Informational && error.Subcode == ErrorSubcode.CallTerminated) { Logger.Instance.Information("[AudioVideoIVRJob] Call terminated while playing prompt."); } else { throw; } } }
public void ErrorHandler(object sender, ErrorInformation errorInformation) { var cmdlet = _cmdlet; if (cmdlet == null) { return; } var exceptionName = errorInformation.Exception.InnerException?.GetType().Name ?? errorInformation.Exception.GetType().Name; var errorMessage = $"Perry ({exceptionName}): {errorInformation.ErrorMessage}"; if (_options?.IncludeVariable == true) { var variables = VariableParser.GetVariables(errorInformation.ErrorMessage); foreach (var variable in variables) { var variableValue = cmdlet.GetVariableValue(variable).ToString(); errorMessage += $"{Environment.NewLine} Variable: ${variable} = {variableValue}"; } } if (_options?.IncludeException == true) { errorMessage += $"{Environment.NewLine}{errorInformation.Exception}"; } cmdlet.WriteWarning(errorMessage); }
/// <summary> /// Invokes a remote method synchronously. /// </summary> /// <typeparam name="T">Type of the return value.</typeparam> /// <param name="client">Client that will invoke the methpd.</param> /// <param name="method">Method name.</param> /// <param name="args">Arguments of the method.</param> /// <returns>Remote call's return value.</returns> public static T Invoke <T>(this Client client, string method, params object[] args) { var mre = new ManualResetEvent(false); ErrorInformation errorInfo = null; object resultObj = null; void Callback(ErrorInformation error, object result, bool stream) { errorInfo = error; resultObj = result; mre.Set(); } client.InvokeAsync(method, args, Callback); mre.WaitOne(); if (errorInfo != null) { throw new RemoteException(errorInfo.Name, errorInfo.Message, errorInfo.StackTrace); } if (resultObj is T resultVal) { return(resultVal); } return(default(T)); }
public void CheckError(ParserRuleContext context, out ErrorInformation error) { error = null; var identifierContext = ((Local_variable_declaratorContext)context).identifier(); var currentScope = identifierContext.Scope.GetEnclosingScope(); var text = identifierContext.GetText(); //check symbol exist var existSymbol = currentScope.Resolve(identifierContext.GetText()); if (existSymbol != null && existSymbol.GetScope().GetName() != "local") { List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>() { new ReplaceCodeInfomation() { Start = identifierContext.Start.StartIndex, Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1, ReplaceCode = identifierContext.GetText() + "1" } }; //warning error = new ErrorInformation() { ErrorCode = "WA0001", ErrorMessage = "UIT: You should declare variable " + identifierContext.GetText() + " with difference name to avoid override value", StartIndex = identifierContext.Start.StartIndex, DisplayText = string.Format("Rename {0} to {1}", identifierContext.GetText(), replaceCodes[0].ReplaceCode), ReplaceCode = replaceCodes, Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1 }; } }
internal void AddError(ErrorInformation errorInformation) { using (TimedLock lck = TimedLock.Lock(_lockObject)) { _errorList.Add(errorInformation); } }
public void CheckConstant(ParserRuleContext context, out ErrorInformation error) { error = null; var identifierContext = ((Constant_declaratorContext)context).identifier(); var identifier = identifierContext.GetText(); if (!IsUpperCase(identifier) || identifier[0] == '_') { List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>() { new ReplaceCodeInfomation() { Start = identifierContext.Start.StartIndex, Length = identifierContext.Stop.StopIndex - context.Start.StartIndex + 1, ReplaceCode = UppercaseFirst(identifier) } }; error = new ErrorInformation { ErrorCode = "IF0008", StartIndex = identifierContext.Start.StartIndex, DisplayText = string.Format("Fix name violation: {0}", replaceCodes[0].ReplaceCode), ReplaceCode = replaceCodes, Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1, ErrorMessage = "UIT: Naming rule violation: Constant should begin with upper case characters" }; } }
private async Task PlayPromptAsync(IAudioVideoFlow flow, AudioVideoIVRAction action) { string wavFile = promptMap.GetOrNull(action); Logger.Instance.Information("[AudioVideoIVRJob] playing prompt: {0}.", wavFile); var resourceUri = new Uri(string.Format("{0}://{1}/resources/{2}", m_callbackUri.Scheme, m_callbackUri.Host, wavFile)); try { await flow.PlayPromptAsync(resourceUri, m_loggingContext).ConfigureAwait(false); } catch (CapabilityNotAvailableException ex) { Logger.Instance.Error("[AudioVideoIVRJob] PlayPrompt api is not available!", ex); } catch (RemotePlatformServiceException ex) { ErrorInformation error = ex.ErrorInformation; if (error != null && error.Code == ErrorCode.Informational && error.Subcode == ErrorSubcode.CallTerminated) { Logger.Instance.Information("[AudioVideoIVRJob] Call terminated while playing prompt."); } else { throw; } } }
public void CheckNamespace(ParserRuleContext context, out ErrorInformation error) { error = null; IdentifierContext[] identifierContexts = ((NamespaceContext)context).qualified_identifier().identifier(); foreach (var identifierContext in identifierContexts) { var identifier = identifierContext.GetText(); if (!IsUpperCase(identifier)) { List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>() { new ReplaceCodeInfomation() { Start = identifierContext.Start.StartIndex, Length = identifierContext.Stop.StopIndex - context.Start.StartIndex + 1, ReplaceCode = UppercaseFirst(identifier) } }; error = new ErrorInformation { ErrorCode = "IF0012", StartIndex = identifierContext.Start.StartIndex, DisplayText = string.Format("Fix name violation: {0}", replaceCodes[0].ReplaceCode), ReplaceCode = replaceCodes, Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1, ErrorMessage = "UIT: Naming rule violation: Namespace should begin with upper case characters" }; } } }
// Puts a character into the DB // ID and character.ID are a little redundant, not sure how I feel about that // I figure we might want a char copy function at some point, so maybe it makes sense to // apply the id to the char as we put them, but I'd probably wanna figure out use cases first public async Task <ErrorInformation> PutCharacter(string id, Character character) { if (String.IsNullOrEmpty(id)) { return(ErrorInformation.InvalidParameterError()); } if (character == null) { return(ErrorInformation.InvalidParameterError()); } if (id == null) { return(ErrorInformation.InvalidParameterError()); } if (!id.Equals(character.Id)) { return(ErrorInformation.InvalidParameterError()); } ErrorInformation result = null; CharacterSchema characterData; if (CharacterExists(id)) { characterData = await Characters.FindAsync(id); if (characterData != null) { characterData.CharacterJsonRepresentation = JsonSerializer.Serialize(character); } } else { characterData = new CharacterSchema() { Id = character.Id, CharacterJsonRepresentation = JsonSerializer.Serialize(character) }; Characters.Add(characterData); } try { await SaveChangesAsync(); } catch (DbUpdateException) { if (CharacterExists(character.Id)) { result = ErrorInformation.DuplicateCharacterError(); } else { throw; } } return(result); }
public async Task <IResult <ILoginResponse> > Login(ILoginRequest login, CancellationToken cancel = default) { Result <ILoginResponse> result; var user = await _userManager.FindByNameAsync(login.UserName); if (user == null) { result = new ErrorInformation($"The user with the name {login.UserName} was not found"); return(result); } var loginResult = await _signInManager.CheckPasswordSignInAsync(user, login.Password, false); if (loginResult.Succeeded) { _logger.LogInformation("The user {0} has been successfully logged in", login.UserName); result = new LoginResponse() { Token = _jwtGenerator.CreateToken(user) }; return(result); } _logger.LogInformation("User {0} authentication error", login.UserName); result = new ErrorInformation("Authentication error"); return(result); }
protected void Application_Error(object sender, EventArgs e) { var exception = Server.GetLastError(); if (exception == null) { return; } var errorLogger = new ErrorLoggerService(HttpContext.Current.User); errorLogger.InsertError(exception); // Clear the error Server.ClearError(); var errorInformation = new ErrorInformation { Message = "We apologize but an unexpected error occured.", ErrorDate = DateTime.UtcNow }; Response.ClearHeaders(); Response.ClearContent(); Response.Status = "500 Internal Server Error"; Response.StatusCode = 500; Response.Write(JsonConvert.SerializeObject(errorInformation)); Response.Flush(); }
private void AddError(ErrorInformation error) { if (errorTable != null) { errorTable.Add(error); } }
public void CheckLocalVariable(ParserRuleContext context, out ErrorInformation error) { error = null; var identifierContext = ((Local_variable_declaratorContext)context).identifier(); if (identifierContext != null) { _identifier = identifierContext.GetText(); if (!IsLowerCase(_identifier) || _identifier[0] == '_') { List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>() { new ReplaceCodeInfomation() { Start = identifierContext.Start.StartIndex, Length = identifierContext.Stop.StopIndex - context.Start.StartIndex + 1, ReplaceCode = LowercaseFirst(_identifier) } }; error = new ErrorInformation { StartIndex = identifierContext.Start.StartIndex, ErrorCode = "IF0005", ReplaceCode = replaceCodes, DisplayText = string.Format("Fix name violation: {0}", replaceCodes[0].ReplaceCode), Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1, ErrorMessage = "UIT: Naming rule violation: Local variable should begin with lower case characters." }; } } }
public void Test_NoRateLimiter_TooManyRequest_Error() { ConnectionSettings.UseRateLimiter = false; var connector = new CustomerConnector(); ErrorInformation error = null; int i; for (i = 0; i < 200; i++) { connector.Search.City = TestUtils.RandomString(); connector.Find(); if (connector.HasError) { error = connector.Error; break; } } //Restore settings ConnectionSettings.UseRateLimiter = true; //Assert //Assert.IsTrue(failed > 0); Console.WriteLine($@"Succesful requests: {i}"); Assert.IsNotNull(error); Assert.IsTrue(error.Message.Contains("Too Many Requests")); }
public async Task <JsonResult> NewCharacter(Character character) { if (!validateNewCharacter(character)) { return(new JsonResult(new NewCharacterResponse() { Error = ErrorInformation.InvalidCharacterError() })); } NewCharacterResponse response = new NewCharacterResponse(); ErrorInformation dbError = await _characterDbContext.PutCharacter(character.Id, character); if (dbError != null) { response.Error = dbError; } else { response.Character = character; } return(new JsonResult(response)); }
private bool ParseResponse(string response) { JObject jo; try { jo = JObject.Parse(response); } catch (Exception e) { ErrorInformation.Add(e.ToString()); return(false); } ParseId(jo); ParseName(jo); ParseCreatedAt(jo); ParseUpdatedAt(jo); ParsePasswordDigest(jo); ParseRememberDigest(jo); ParseActivatedDigest(jo); ParseAdmin(jo); ParseActivated(jo); ParseActivatedAt(jo); ParseResetDigest(jo); ParseResetRequestedAt(jo); return(true); }
private void ErrorHandler(object sender, ErrorInformation e) { if (_options == null) { return; } var client = _telemetryClient; if (client == null) { return; } var exception = e.Exception.InnerException ?? e.Exception; var properties = new Dictionary <string, string> { { "ErrorMessage", e.ErrorMessage } }; if (e.ErrorRecord != null) { properties.Add("ScriptStackTrace", e.ErrorRecord.ScriptStackTrace); } if (e.ErrorRecord?.InvocationInfo != null) { properties.Add("PSCommandPath", e.ErrorRecord.InvocationInfo.PSCommandPath); } client.TrackException(exception, properties); }
private static ErrorInformation GetExceptionHandlingInformation(HttpContext httpContext, Exception exception) { ErrorInformation errorInformation = new ErrorInformation { Exception = exception }; if (exception is OrgIdMailboxRecentlyCreatedException) { OrgIdMailboxRecentlyCreatedException ex = exception as OrgIdMailboxRecentlyCreatedException; errorInformation.Message = ex.Message; errorInformation.MessageId = new Strings.IDs?(ex.ErrorMessageStringId); errorInformation.AddMessageParameter(ex.UserName); errorInformation.AddMessageParameter(ex.HoursBetweenAccountCreationAndNow.ToString()); errorInformation.Mode = ex.ErrorMode; } else if (exception is OrgIdMailboxNotFoundException) { OrgIdMailboxNotFoundException ex2 = exception as OrgIdMailboxNotFoundException; errorInformation.Message = ex2.Message; errorInformation.MessageId = new Strings.IDs?(ex2.ErrorMessageStringId); errorInformation.AddMessageParameter(ex2.UserName); errorInformation.Mode = ex2.ErrorMode; } else if (exception is OrgIdLogonException) { OrgIdLogonException ex3 = exception as OrgIdLogonException; errorInformation.Message = ex3.Message; errorInformation.MessageId = new Strings.IDs?(ex3.ErrorMessageStringId); errorInformation.MessageParameter = ex3.UserName; } else if (exception is AppPasswordAccessException) { AppPasswordAccessException ex4 = exception as AppPasswordAccessException; errorInformation.Message = ex4.Message; errorInformation.MessageId = new Strings.IDs?(ex4.ErrorMessageStringId); } else if (exception is LiveClientException || exception is LiveConfigurationException || exception is LiveTransientException || exception is LiveOperationException) { errorInformation.Message = exception.Message; errorInformation.MessageId = new Strings.IDs?(1317300008); string text = httpContext.Request.QueryString["realm"]; if (!string.IsNullOrEmpty(text)) { errorInformation.AddMessageParameter(text); } } else if (exception is AccountTerminationException) { AccountTerminationException ex5 = exception as AccountTerminationException; errorInformation.Message = ex5.Message; errorInformation.MessageId = new Strings.IDs?(ex5.ErrorMessageStringId); errorInformation.MessageParameter = ex5.AccountState.ToString(); } return(errorInformation); }
public void CheckField(ParserRuleContext context, out ErrorInformation error) { error = null; var identifierContext = ((Field_declarationContext)context).variable_declarators().variable_declarator()[0].identifier(); var identifier = identifierContext.GetText(); var varSymbol = identifierContext.Symbol as FieldSymbol; if (varSymbol.HaveModifier("private") || varSymbol.HaveModifier("internal")) { if (!IsUnderScoreAndLowerCase(identifier)) { List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>() { new ReplaceCodeInfomation() { Start = identifierContext.Start.StartIndex, Length = identifierContext.Stop.StopIndex - context.Start.StartIndex + 1, ReplaceCode = string.Format("_{0}", LowercaseFirst(identifier)) } }; error = new ErrorInformation { ErrorCode = "IF0007", DisplayText = string.Format("Fix name violation: {0}", replaceCodes[0].ReplaceCode), StartIndex = identifierContext.Start.StartIndex, ReplaceCode = replaceCodes, Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1, ErrorMessage = "UIT: Naming rule violation: private, internal field member should be begin with _ and lower case character" }; } } else if ((varSymbol.HaveModifier("public") || varSymbol.HaveModifier("protected"))) { if (!IsUpperCase(identifier)) { List <ReplaceCodeInfomation> replaceCodes = new List <ReplaceCodeInfomation>() { new ReplaceCodeInfomation() { Start = identifierContext.Start.StartIndex, Length = identifierContext.Stop.StopIndex - context.Start.StartIndex + 1, ReplaceCode = UppercaseFirst(identifier) } }; error = new ErrorInformation { ErrorCode = "IF0011", StartIndex = identifierContext.Start.StartIndex, DisplayText = string.Format("Fix name violation: {0}", replaceCodes[0].ReplaceCode), ReplaceCode = replaceCodes, Length = identifierContext.Stop.StopIndex - identifierContext.Start.StartIndex + 1, ErrorMessage = "UIT: Naming rule violation: public, protected Field member should be begin with uppercase character " }; } } }
private void ParsePasswordDigest(JObject jo) { try { PasswordDigest = (string)jo.SelectToken("password_digest"); } catch (Exception e) { ErrorInformation.Add(e.ToString()); } }
private void ParseResetDigest(JObject jo) { try { ResetDigest = (string)jo.SelectToken("reset_digest"); } catch (Exception e) { ErrorInformation.Add(e.ToString()); } }
private void ParseActivated(JObject jo) { try { Activated = (bool)jo.SelectToken("activated"); } catch (Exception e) { ErrorInformation.Add(e.ToString()); } }
private void ParseAdmin(JObject jo) { try { Admin = (bool)jo.SelectToken("admin"); } catch (Exception e) { ErrorInformation.Add(e.ToString()); } }
private void ParseActivatedDigest(JObject jo) { try { ActivationDigest = (string)jo.SelectToken("activation_digest"); } catch (Exception e) { ErrorInformation.Add(e.ToString()); } }
private void ParseName(JObject jo) { try { Name = (string)jo.SelectToken("name"); } catch (Exception e) { ErrorInformation.Add(e.ToString()); } }
private void CaptureCounterExamples(ErrorInformation errorInfo) { if (errorInfo.Model is StringWriter modelString) { // We do not know a-priori how many errors we'll receive. Therefore we capture all models // in a custom stringbuilder and reset the original one to not duplicate the outputs. serializedCounterExamples ??= new StringBuilder(); serializedCounterExamples.Append(modelString.ToString()); modelString.GetStringBuilder().Clear(); } }
protected override void OnError(ErrorInformation errorInformation) { string msg = string.Format(errorInformation.Message, errorInformation.Arguments.ToArray()); throw new ParserErrorException(errorInformation.Location.Span.Start.Line, errorInformation.Location.Span.Start.Column, errorInformation.Location.Span.Length, msg); //throw new FormatException( // string.Format("Syntax error at [{0}, {1}]: {2}", // errorInformation.Location.Span.Start.Line, // errorInformation.Location.Span.Start.Column, // msg)); }
protected override void OnError(ErrorInformation errorInformation) { this.Errors.Add(errorInformation); }
public ParserErrorException(ISourceLocation location, ErrorInformation information) { Error = information; Location = location; }
protected override void OnError(ErrorInformation errorInformation) { Errors.Add(new ErrorInfo { Location = errorInformation.Location, Info = errorInformation }); }
protected override void OnError(ErrorInformation errorInformation) { throw new ParserErrorException(errorInformation.Location, errorInformation); }
protected override void OnError(ISourceLocation sourceLocation, ErrorInformation errorInformation) { Errors.Add(new ErrorInfo { Location = sourceLocation, Info = errorInformation }); }