public async Task <IActionResult> ResetPassword([FromBody] ResetPasswordViewModel model) { if (!ModelState.IsValid) { return(BadRequest()); } try { var user = await _userManager.FindByNameAsync(model.Email); if (user == null) { return(BadRequest(HttpErrorHandler.AddError("Failure", "User not found", ModelState))); } var result = await _userManager.ResetPasswordAsync(user, model.Code, model.Password); if (!result.Succeeded) { return(BadRequest(HttpErrorHandler.AddErrors(result, ModelState))); } return(new OkResult()); } catch (Exception e) { return(StatusCode(500, $"En error occurred :{e.Message}")); } }
private void HandleWebExceptionError(WebException e) { var response = (HttpWebResponse)e.Response; if (!response.StatusCode.Equals(HttpStatusCode.OK)) { ErrorHandler?.Invoke(e); HttpErrorHandler?.Invoke(response.StatusCode); switch (response.StatusCode) { case HttpStatusCode.BadRequest: BadRequestErrorHandler?.Invoke(); break; case HttpStatusCode.InternalServerError: InternalServerErrorHandler?.Invoke(); break; case HttpStatusCode.RequestTimeout: TimeOutHandler?.Invoke(); break; case HttpStatusCode.NotFound: NotFoundHandler?.Invoke(); break; case HttpStatusCode.Unauthorized: UnauthorizeHandler?.Invoke(); break; } } RequestCompletedHandler?.Invoke(); }
public async Task <IActionResult> ForgotPassword([FromBody] ForgotPasswordViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var user = await _userManager.FindByNameAsync(model.Email); if (user == null || !(await _userManager.IsEmailConfirmedAsync(user))) { return(BadRequest(HttpErrorHandler.AddError("Failure", "Confirm your email", ModelState))); } string resetUrl = GetPasswordResetUrl(user, await _userManager.GeneratePasswordResetTokenAsync(user)); await EmailHelper.SendEmailAsync(user.Email, "Reset Password", EmailHelper.GetResetPasswordMessage(resetUrl)); return(new OkResult()); } catch (Exception e) { return(StatusCode(500, $"En error occurred :{e.Message}")); } }
/// <summary> /// Initializes a new instance of the <see cref="InstanceIdClient"/> class. /// </summary> /// <param name="clientFactory">A default implentation of the HTTP client factory.</param> /// <param name="credential">An instance of the <see cref="GoogleCredential"/> GoogleCredential class.</param> public InstanceIdClient(HttpClientFactory clientFactory, GoogleCredential credential) { this.httpClient = clientFactory.ThrowIfNull(nameof(clientFactory)) .CreateAuthorizedHttpClient(credential); this.errorHandler = new MessagingErrorHandler(); }
public async Task <IActionResult> Register([FromBody] RegistrationViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } User user = new User() { UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(HttpErrorHandler.AddErrors(result, ModelState))); } string confirmUrl = GetEmailConfirmationUrl(user, await _userManager.GenerateEmailConfirmationTokenAsync(user)); try { await EmailHelper.SendEmailAsync(user.Email, "Email confirmation", EmailHelper.GetEmailConfirmationMessage(confirmUrl)); } catch (Exception e) { return(StatusCode(500, $"Can't sent email")); } return(new OkResult()); }
public async Task <IActionResult> GetSmartContractTransactionsByName(string contractName) { try { var token = _dbContext.Erc20Tokens.ToList().FirstOrDefault(t => t.Name?.Equals(contractName, StringComparison.CurrentCultureIgnoreCase) ?? false); if (token == null) { return(NotFound()); } var res = _dbContext.BlockChainTransactions.Where(t => t.ContractAddress.Equals(token.Address)) .OrderByDescending(t => t.Date).Take(40); return(new OkObjectResult( new TransactionsViewModel() { SkipElementsNumber = 40, Transactions = await res.ToListAsync() } )); } catch (Exception e) { return(BadRequest(HttpErrorHandler.AddError("Failure", e.Message, ModelState))); } }
/// <summary> /// Constructor. /// </summary> /// <param name="serviceOptions">Configuration parameters.</param> internal ServiceBusRestProxy(ServiceConfiguration serviceOptions) { Debug.Assert(serviceOptions != null); ServiceConfig = serviceOptions; HttpMessageHandler chain = new HttpErrorHandler( new WrapAuthenticationHandler(serviceOptions)); Channel = new HttpClient(chain); }
/// <summary> /// Constructor. /// </summary> /// <param name="serviceConfig">Configuration of the service.</param> internal WrapAuthenticationHandler(ServiceConfiguration serviceConfig) { ServiceConfig = serviceConfig; Tokens = new Dictionary<string, WrapToken>(StringComparer.OrdinalIgnoreCase); SyncObject = new object(); HttpMessageHandler handlers = new HttpErrorHandler( new HttpClientHandler()); Channel = new HttpClient(handlers); }
public async Task <IActionResult> LogIn([FromBody] LoginViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } var result = await GetClaimsIdentity(model.Email, model.Password); if (result == null) { return(BadRequest(HttpErrorHandler.AddError("Failure", "Invalid username or password.", ModelState))); } var jwt = await Tokens.GenerateJwt(result, _jwtFactory, model.Email, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented }); return(new OkObjectResult(jwt)); }
public FirebaseMessagingClient( HttpClientFactory clientFactory, GoogleCredential credential, string projectId) { if (string.IsNullOrEmpty(projectId)) { throw new ArgumentException( "Project ID is required to access messaging service. Use a service account " + "credential or set the project ID explicitly via AppOptions. Alternatively " + "you can set the project ID via the GOOGLE_CLOUD_PROJECT environment " + "variable."); } this.httpClient = clientFactory.ThrowIfNull(nameof(clientFactory)) .CreateAuthorizedHttpClient(credential); this.sendUrl = string.Format(FcmSendUrl, projectId); this.restPath = this.sendUrl.Substring(FcmBaseUrl.Length); this.fcmClientService = new FCMClientService(this.httpClient); this.errorHandler = new MessagingErrorHandler(); }
public void NonJsonResponse(HttpStatusCode statusCode, ErrorCode expected) { var text = "not json"; var resp = new HttpResponseMessage() { StatusCode = statusCode, Content = new StringContent(text, Encoding.UTF8, "text/plain"), }; var handler = new HttpErrorHandler(); var error = Assert.Throws <FirebaseException>(() => handler.ThrowIfError(resp, text)); Assert.Equal(expected, error.ErrorCode); Assert.Equal( $"Unexpected HTTP response with status: {(int)statusCode} ({statusCode})\n{text}", error.Message); Assert.Same(resp, error.HttpResponse); Assert.Null(error.InnerException); }
public void UnknownHttpStatusCode() { var json = "{}"; var resp = new HttpResponseMessage() { StatusCode = HttpStatusCode.MethodNotAllowed, Content = new StringContent(json, Encoding.UTF8, "application/json"), }; var handler = new HttpErrorHandler(); var error = Assert.Throws <FirebaseException>(() => handler.ThrowIfError(resp, json)); Assert.Equal(ErrorCode.Unknown, error.ErrorCode); Assert.Equal( $"Unexpected HTTP response with status: 405 (MethodNotAllowed)\n{json}", error.Message); Assert.Same(resp, error.HttpResponse); Assert.Null(error.InnerException); }
public async Task <IActionResult> Register([FromBody] RegistrationViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } User user = new User() { UserName = model.Email, Email = model.Email }; var result = await _userManager.CreateAsync(user, model.Password); if (!result.Succeeded) { return(BadRequest(HttpErrorHandler.AddErrors(result, ModelState))); } return(new OkResult()); }
public async Task <IActionResult> StatusSyncTransactions() { try { var lastBlockNumber = (int)(await _explorer.GetLastAvailableBlockNumber()).Value; var lastCheckedBlockNumber = _dbContext.BlockChainTransactions .Max(w => w.BlockNumber); return(new OkObjectResult( new StatusSyncTransaction() { CurrentBlock = lastCheckedBlockNumber, LastBlockBl = lastBlockNumber })); } catch (Exception ex) { return(BadRequest(HttpErrorHandler.AddError("Failure", ex.Message, ModelState))); } }
public async Task <IActionResult> GetWalletInfo(string accountAddress) { WalletInfoViewModel model = new WalletInfoViewModel(); Task <HexBigInteger> getBalance = _explorer.BalanceETH(accountAddress); var tasks = new List <Task <ERC20TokenViewModel> >(); List <ERC20TokenViewModel> tokens = new List <ERC20TokenViewModel>(); foreach (var token in _dbContext.Erc20Tokens) { if (token.Address != accountAddress) { Task <ERC20TokenViewModel> task = _explorer.BalanceToken(token, accountAddress); tasks.Add(task); } else { break; } } try { model.Balance = Web3.Convert.FromWei(await getBalance, 18); await Task.WhenAll(tasks.ToArray()); foreach (var listtask in tasks) { tokens.Add(listtask.Result); } model.Tokens = tokens.Where(x => x.Balance != 0).ToList(); } catch (Exception e) { return(BadRequest(HttpErrorHandler.AddError("Failure", e.Message, ModelState))); } return(new OkObjectResult(model)); }
public async Task <IActionResult> LogIn([FromBody] LoginViewModel model) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } try { var user = await _userManager.FindByNameAsync(model.Email); if (user == null) { return(BadRequest(HttpErrorHandler.AddError("Failure", "User not found", ModelState))); } if (!await _userManager.IsEmailConfirmedAsync(user)) { return(BadRequest(HttpErrorHandler.AddError("Failure", "Confirm your email", ModelState))); } var result = await GetClaimsIdentity(model.Email, model.Password); if (result == null) { return(BadRequest(HttpErrorHandler.AddError("Failure", "Invalid username or password.", ModelState))); } var jwt = await Tokens.GenerateJwt(result, _jwtFactory, model.Email, _jwtOptions, new JsonSerializerSettings { Formatting = Formatting.Indented }); return(new OkObjectResult(jwt)); } catch (Exception e) { return(StatusCode(500, $"En error occurred :{e.Message}")); } }
public async Task <IActionResult> GetSmartContractTransactions(int?skipElementsNumber, string accountAddress) { try { skipElementsNumber = skipElementsNumber ?? 0; var res = _dbContext.BlockChainTransactions.Where(t => t.ContractAddress.Equals(accountAddress)) .OrderByDescending(t => t.Date).Skip(skipElementsNumber.Value).Take(40); return(new OkObjectResult( new TransactionsViewModel() { SkipElementsNumber = skipElementsNumber.Value + 40, Transactions = await res.ToListAsync() } )); } catch (Exception e) { return(BadRequest(HttpErrorHandler.AddError("Failure", e.Message, ModelState))); } }
public void HandleError_Test() { // Arange HttpErrorHandler handler = new HttpErrorHandler(); ExceptionDefaults defaults = new ExceptionDefaults { ApplicationName = "ApplicationName", Host = "Host", Token = "Token" }; Mock<ExceptionWritterBase> writterMock = new Mock<ExceptionWritterBase>(); writterMock.Setup(x => x.Write(defaults.Token, It.IsAny<ErrorInfo>())).Verifiable(); ExceptionHandler.Configure(writterMock.Object, defaults, null); // Act bool result = handler.HandleError(new Exception("Test-Exception")); // Assert Assert.False(result); writterMock.Verify(); }
public HttpErrorHandlerBehavior(HttpErrorHandler errorHandler) { this.errorHandler = errorHandler; }
public HttpBehaviorWithErrorHandler(HttpErrorHandler httpErrorHandler) { this.httpErrorHandler = httpErrorHandler; }
public HttpErrorHandlerBehavior(HttpErrorHandler errorHandler) { this.errorHandler = errorHandler; }
IHttpHostConfigurationBuilder IHttpHostConfigurationBuilder.SetErrorHandler(HttpErrorHandler handler) { this.ErrorHandler = handler; return(this); }
IHttpHostConfigurationBuilder IHttpHostConfigurationBuilder.SetErrorHandler(Func <Exception, bool> handleError, Func <Exception, HttpResponseMessage> provideResponse) { this.ErrorHandler = new DelegateErrorHandler(handleError, provideResponse); return(this); }
public HttpBehaviorWithErrorHandler(HttpErrorHandler httpErrorHandler) { this.httpErrorHandler = httpErrorHandler; }