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;
}
