public async Task <IActionResult> GetBalances([FromQuery] int take, [FromQuery] string continuation)
{
if (take <= 0)
{
ModelState.AddModelError(nameof(take), "Must be greater than zero");
}
ModelState.IsValidContinuationToken(continuation);
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
var padedResult = await _balanceService.GetBalances(take, continuation);
return(Ok(PaginationResponse.From(padedResult.Continuation, padedResult.Items.Select(p => new WalletBalanceContract
{
Address = p.Address,
Balance = MoneyConversionHelper.ToContract(p.Balance, p.AssetId),
AssetId = p.AssetId,
Block = p.UpdatedAtBlockHeight
}).ToList().AsReadOnly())));
}
public override void OnActionExecuting(ActionExecutingContext context)
{
var descriptor = context.ActionDescriptor as ControllerActionDescriptor;
if (descriptor != null)
{
var parameters = descriptor.MethodInfo.GetParameters();
foreach (var parameter in parameters)
{
var argument = context.ActionArguments.ContainsKey(parameter.Name)
? context.ActionArguments[parameter.Name]
: null;
EvaluateValidationAttributes(parameter, argument, context.ModelState);
}
}
base.OnActionExecuting(context);
if (!context.ModelState.IsValid)
{
context.Result = new BadRequestObjectResult(ErrorResponseFactory.Create(context.ModelState));
}
}
public OperacionesController(IOperacionService operacionService, IControlService controlService,
ErrorResponseFactory errorResponseFactory)
{
this.operacionService = operacionService;
this.controlService = controlService;
this.errorResponseFactory = errorResponseFactory;
}
static async Task <long?> PlaceMarketOrder(string side = "buy")
{
WriteNewLine("Creating a EUR_USD market BUY order ...");
var oandaInstrument = (await Rest20.GetAccountInstrumentsAsync(AccountID, INSTRUMENT)).First();
long orderUnits = side == "buy" ? 10 : -10;
var request = new MarketOrderRequest(oandaInstrument)
{
units = orderUnits
};
OrderPostResponse response = null;
try
{
response = await Rest20.PostOrderAsync(AccountID, request);
WriteNewLine("Congrats! You've put on a trade! Let it run! :)");
}
catch (Exception ex)
{
var errorResponse = ErrorResponseFactory.Create(ex.Message);
WriteNewLine("Oops. Order creation failed.");
WriteNewLine($"The failure message is: {errorResponse.errorMessage}.");
WriteNewLine("Try again later.");
}
return(response?.orderFillTransaction?.tradeOpened?.tradeID);
}
public static ObjectResult Problems(this ControllerBase controller)
{
ErrorResponseFactory errorResponseFactory = new ErrorResponseFactory(controller.HttpContext);
ErrorResponse errorResponse = errorResponseFactory.CreateErrorResponse();
return(new ObjectResult(errorResponse));
}
public IActionResult Write([FromBody] LogRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
var logFactory = _logFactoryStorage.GetLogFactoryOrDefault(request.AppName);
if (logFactory == null)
{
_log.Warning(nameof(Write), $"Logger for appName {request.AppName} not found", context: request);
return(BadRequest(ErrorResponse.Create($"Logger for appName {request.AppName} not found")));
}
var logInformation = request.MapToLogInformationDto();
if (request.LogLevel == LogLevelContract.Monitor)
{
var healthNotifier = _healthNotifierStorage.GetOrCreateHealthNotifier(request.AppName,
request.AppVersion,
request.EnvInfo,
logFactory);
_healthNotificationWriter.SendNotification(healthNotifier, logInformation);
return(Ok());
}
_logWriter.Write(logFactory, request.LogLevel.MapToMicrosoftLoglevel(), logInformation);
return(Ok());
}
public PerfilesController(ErrorResponseFactory errorResponseFactory, IVehiculoService vehiculoService,
UsuarioVehiculoValidator usuarioVehiculoValidator, VehiculoMapper vehiculoMapper)
{
this.errorResponseFactory = errorResponseFactory;
this.vehiculoService = vehiculoService;
this.usuarioVehiculoValidator = usuarioVehiculoValidator;
this.vehiculoMapper = vehiculoMapper;
}
public VehiculosController(IVehiculoService vehiculoService,
ParametrosBusquedaVehiculoValidator parametrosValidator, ErrorResponseFactory errorResponseFactory,
VehiculoMapper vehiculoMapper)
{
this.vehiculoService = vehiculoService;
this.parametrosValidator = parametrosValidator;
this.errorResponseFactory = errorResponseFactory;
this.vehiculoMapper = vehiculoMapper;
}
public void OnActionExecuting(ActionExecutingContext context)
{
if (!context.ModelState.IsValid)
{
var errorResponse = ErrorResponseFactory.Create(context.ModelState);
errorResponse.ErrorMessage = context.ModelState.GetErrorMessage();
throw new ValidationApiException(errorResponse);
}
}
public GlobalExceptionFilter(
ErrorResponseFactory errorResponseFactory,
IHostingEnvironment hostingEnvironment,
ILogger <GlobalExceptionFilter> logger)
{
this.ErrorResponseFactory = errorResponseFactory;
this.HostingEnvironment = hostingEnvironment;
this.Logger = logger;
}
public override void OnException(HttpActionExecutedContext actionExecutedContext)
{
var jsonMediaTypeFormatter = actionExecutedContext.ActionContext.ActionDescriptor.Configuration.Formatters.JsonFormatter;
var exception = actionExecutedContext.Exception;
var exceptionType = exception.GetType();
actionExecutedContext.Response = _exceptions.ContainsKey(exceptionType)
? ErrorResponseFactory.New(_exceptions[exceptionType], exception.Message, jsonMediaTypeFormatter)
: ErrorResponseFactory.New(HttpStatusCode.InternalServerError, "Ha ocurrido un error en la aplicación.", jsonMediaTypeFormatter);
}
public IActionResult GetPaged([FromQuery] int take, [FromQuery] string continuation)
{
if (!ModelState.IsValid ||
!ModelState.IsValidContinuationToken(continuation) ||
!ModelState.IsValidTakeParameter(take))
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
return(Ok(PaginationResponse.From(null, Storage.Take(take).ToList())));
}
public async Task <IActionResult> AddOrUpdateEmailTemplate([FromBody] EmailTemplateAddOrUpdateRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
await _emailTemplateService.AddOrUpdateTemplateAsync(request.EmailTemplate, request.Username);
return(Ok());
}
public async Task <IActionResult> SendEmail([FromBody] EmailDataModel emailData)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
await _emailService.EnqueueEmailAsync(emailData);
return(Ok());
}
public async Task <IActionResult> HandleTransactions([FromBody] TransactionModel[] transactions)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
var payInCount = await _transactionService.HandleTransactionsAsync(transactions);
return(Ok(payInCount));
}
public void OnException(ExceptionContext context)
{
var exception = context.Exception;
Logger.CaughtException(exception);
if (!HostingEnvironment.IsDevelopment())
{
context.Result = ErrorResponseFactory.InternalServerError(exception);
}
}
public UsuariosController(HigoContext ctx, IUsuarioService usuarioService,
UsuarioRequestValidator parametrosValidator, IOperacionService operacionService,
OperacionesClasificadasDTOBuilder operacionesClasificadasDtoBuilder,
ErrorResponseFactory errorResponseFactory)
{
this.ctx = ctx;
this.usuarioService = usuarioService;
this.parametrosValidator = parametrosValidator;
this.operacionService = operacionService;
this.operacionesClasificadasDtoBuilder = operacionesClasificadasDtoBuilder;
this.errorResponseFactory = errorResponseFactory;
}
public async Task <IActionResult> RemoveObservableOperation(Guid operationId)
{
if (!ModelState.IsValid ||
!ModelState.IsValidOperationId(operationId))
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
await _observableOperationRepository.DeleteIfExist(operationId);
return(Ok());
}
public async Task <IActionResult> Login([FromForm] LoginModel model, [FromQuery] string returnUrl = null)
{
ViewData[ReturnUrlParam] = returnUrl;
if (!ModelState.IsValid || model == null)
{
return(View(model));
}
model.Normalize();
returnUrl = returnUrl.NullIfWhiteSpace() ?? "/";
if (User.Identities.Any(i => i.IsAuthenticated))
{
return(Redirect(returnUrl));
}
Logger.LoginAttempted(model.Email);
var user = await UserManager.FindByEmailAsync(model.Email);
if (user == null)
{
var error = ErrorResponseFactory.GenerateModel(ErrorCode.FailedLogin);
return(View(ViewName));
}
var signInResult = await SignInManager.PasswordSignInAsync(
user, model.Password, model.RememberMe,
Options.LockoutOnFailedLogin
);
if (!signInResult.Succeeded)
{
ErrorModel error;
if (signInResult.RequiresTwoFactor)
{
error = ErrorResponseFactory.GenerateModel(ErrorCode.TwoFactorRequired);
}
else
{
error = ErrorResponseFactory.GenerateModel(ErrorCode.FailedLogin);
}
return(View(ViewName));
}
Logger.LoginSuccessful(model.Email);
return(Redirect(returnUrl));
}
public LoginController(
ErrorResponseFactory errorResponseFactory,
IOptions <LoginOptions> optionsAccessor,
ILogger <LoginController> logger,
SignInManager <IdentityUser <Guid> > signInManager,
UserManager <IdentityUser <Guid> > userManager)
{
this.ErrorResponseFactory = errorResponseFactory;
this.Options = optionsAccessor.Value;
this.Logger = logger;
this.SignInManager = signInManager;
this.UserManager = userManager;
}
public async Task <IActionResult> DeletePayInAddress(
[FromRoute] string address,
[FromRoute] CurrencyType currency)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
await _addressRepository.DeleteAsync(address, currency);
await _log.WriteInfoAsync(nameof(AddPayInAddress), $"Address: {address}, Currency: {Enum.GetName(typeof(CurrencyType), currency)}",
"Pay-in address deleted");
return(Ok());
}
public async Task <IActionResult> GetObservableSingleOperation(Guid operationId)
{
if (!ModelState.IsValid ||
!ModelState.IsValidOperationId(operationId))
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
var result = await _observableOperationRepository.GetById(operationId);
if (result == null)
{
return(new StatusCodeResult((int)HttpStatusCode.NoContent));
}
BroadcastedTransactionState MapState(BroadcastStatus status)
{
switch (status)
{
case BroadcastStatus.Completed:
return(BroadcastedTransactionState.Completed);
case BroadcastStatus.Failed:
return(BroadcastedTransactionState.Failed);
case BroadcastStatus.InProgress:
return(BroadcastedTransactionState.InProgress);
default:
throw new InvalidCastException($"Unknown mapping from {status} ");
}
}
return(Ok(new BroadcastedSingleTransactionResponse
{
Amount = MoneyConversionHelper.ToContract(result.Amount, result.AssetId),
Fee = MoneyConversionHelper.ToContract(result.Fee, result.AssetId),
OperationId = result.OperationId,
Hash = result.TxHash,
Timestamp = result.Updated,
State = MapState(result.Status),
Block = result.UpdatedAtBlockHeight
}));
}
public IActionResult Sign([FromBody] SignTransactionRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
try
{
var txWrapper = TransactionSerializer.Deserialize(request.TransactionContext);
var tx = txWrapper.transaction;
var keyPair = new KeyPair(Wallet.GetPrivateKeyFromWif(request.PrivateKeys.Single()));
var signature = Transaction.Sign(keyPair, tx, false);
var invocationScript = NeoModules.Core.Helper.HexToBytes(("40" + signature.ToHexString()));
var verificationScript = Helper.CreateSignatureRedeemScript(keyPair.PublicKey);
tx.Witnesses = new[]
{
new Witness
{
InvocationScript = invocationScript,
VerificationScript = verificationScript
}
};
return(Ok(new SignedTransactionResponse
{
SignedTransaction = TransactionSerializer.Serialize(tx, txWrapper.type)
}));
}
catch (Exception e)
{
return(BadRequest(ErrorResponse.Create(e.ToAsyncString())));
}
}
public async Task <IActionResult> AddPayInAddress([FromBody] PayInAddressModel payInAddress)
{
if (!ModelState.IsValid)
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
var entity = await _addressRepository.GetAsync(payInAddress.Address, payInAddress.Currency);
if (entity != null)
{
return(StatusCode(StatusCodes.Status409Conflict,
ErrorResponse.Create($"Pay-in address {payInAddress.Address} is already in use")));
}
await _addressRepository.InsertAsync(payInAddress);
await _log.WriteInfoAsync(nameof(AddPayInAddress), payInAddress.ToJson(),
"Pay-in address added");
return(Ok());
}
static IServiceCollection ConfigureInvalidModelStateResponse(this IServiceCollection services)
{
services.Configure <ApiBehaviorOptions>(options =>
{
options.InvalidModelStateResponseFactory = actionContext =>
new BadRequestObjectResult(ErrorResponseFactory.Create(actionContext.ModelState));
});
return(services);
}
public async Task <IActionResult> BuildSingle([FromBody] BuildSingleTransactionRequest request)
{
if (request == null)
{
return(BadRequest(ErrorResponse.Create("Unable to deserialize request")));
}
if (!new [] { Constants.Assets.Neo.AssetId, Constants.Assets.Gas.AssetId }.Contains(request.AssetId))
{
return(BadRequest(ErrorResponse.Create("Invalid assetId")));
}
var amount = MoneyConversionHelper.FromContract(request.Amount, request.AssetId);
if (amount <= 0)
{
return(BadRequest(ErrorResponse.Create($"Amount can't be less or equal to zero: {amount}")));
}
if (request.AssetId == Constants.Assets.Neo.AssetId && amount % 1 != 0)
{
return(BadRequest($"The minimum unit of NEO is 1 and tokens cannot be subdivided.: {amount}"));
}
var toAddressValid = _addressValidator.IsAddressValid(request.ToAddress);
if (!toAddressValid)
{
return(BadRequest(ErrorResponse.Create("Invalid toAddress")));
}
var fromAddressValid = _addressValidator.IsAddressValid(request.FromAddress);
if (!fromAddressValid)
{
return(BadRequest(ErrorResponse.Create("Invalid fromAddress")));
}
if (!ModelState.IsValidOperationId(request.OperationId))
{
return(BadRequest(ErrorResponseFactory.Create(ModelState)));
}
if ((await _operationRepository.GetOrDefault(request.OperationId))?.IsBroadcasted ?? false)
{
return(Conflict());
}
Transaction tx;
decimal fee = 0;
switch (request.AssetId)
{
case Constants.Assets.Neo.AssetId:
(tx, fee) = await _transactionBuilder.BuildNeoContractTransactionAsync(request.FromAddress,
request.ToAddress,
amount,
request.IncludeFee);
break;
case Constants.Assets.Gas.AssetId:
tx = await _transactionBuilder.BuildGasTransactionAsync(request.FromAddress,
request.ToAddress,
amount);
break;
default:
throw new ArgumentException("Unknown switch", nameof(request.AssetId));
}
await _operationRepository.GetOrInsert(request.OperationId,
() => OperationAggregate.StartNew(request.OperationId,
fromAddress: request.FromAddress,
toAddress: request.ToAddress,
amount: amount,
assetId: request.AssetId,
fee: fee,
includeFee: request.IncludeFee));
return(Ok(new BuildTransactionResponse
{
TransactionContext = TransactionSerializer.Serialize(tx, TransactionType.ContractTransaction)
}));
}
