public BinanceExchange(ExchangeDTO exchangeSettings, UserExchangeSecretDTO secrets, ExchangeLogService logService) : base(true, true, exchangeSettings, secrets, logService) { this.api = new BinanceApi(exchangeSettings, logService, secrets); this.wss = new BinanceWSS(); this.reader = new BinanceReader(); }
public KuCoinExchange(ExchangeDTO exchangeSettings, UserExchangeSecretDTO secrets, ExchangeLogService logService) : base(true, true, exchangeSettings, secrets, logService) { this.api = new KuCoinApi(exchangeSettings, logService, secrets); this.wss = new KuCoinWSS(); this.reader = new KuCoinReader(); }
public async Task <ISpotExchangeFacade> CreateExchanges(ExchangeDTO exx) { ISpotExchangeFacade fac = null; if (exx.Name == ExchangeName.Binance.ToString() && this.exchanges.FirstOrDefault(x => x.ExchangeName == ExchangeName.Binance) != null) { UserExchangeSecretDTO secrets = await this.repoExchangeSecrets.GetByExchangeId(exx.ID); fac = new BinanceExchange(exx, secrets, logger); } else if (exx.Name == ExchangeName.HitBTC.ToString() && this.exchanges.FirstOrDefault(x => x.ExchangeName == ExchangeName.Binance) != null) { UserExchangeSecretDTO secrets = await this.repoExchangeSecrets.GetByExchangeId(exx.ID); fac = new HitBTCExchange(exx, secrets, logger); } else if (exx.Name == ExchangeName.KuCoin.ToString() && this.exchanges.FirstOrDefault(x => x.ExchangeName == ExchangeName.Binance) != null) { UserExchangeSecretDTO secrets = await this.repoExchangeSecrets.GetByExchangeId(exx.ID); fac = new KuCoinExchange(exx, secrets, logger); } if (fac != null) { this.exchanges.Add(fac); } else { fac = this.exchanges.FirstOrDefault(x => x.ExchangeName.ToString() == exx.Name); } return(fac); }
public void UpdateExchange(ExchangeDTO exchangedto) { var Inputexchange = Mapper.Map <ExchangeDTO, Exchange>(exchangedto); if (Inputexchange == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } var exchange = _context.Exchange.SingleOrDefault(c => c.Id == exchangedto.Id); var priority = Inputexchange.Priority; if (priority == 3) { exchange.LastContact = DateTime.Now; exchange.NextContact = DateTime.Now.AddDays(exchangedto.Frequency); exchange.LastTryAttempt = DateTime.Now; exchange.NextTryAttempt = DateTime.Now.AddDays(exchangedto.Frequency); } if (priority == 2) { exchange.LastTryAttempt = DateTime.Now; exchange.NextTryAttempt = DateTime.Now.AddDays(2); } if (priority == 1) { exchange.LastTryAttempt = DateTime.Now; exchange.NextTryAttempt = DateTime.Now.AddDays(1); } _context.SaveChanges(); }
public HitBTCExchange(ExchangeDTO exchangeSettings, UserExchangeSecretDTO secrets, ExchangeLogService logService) : base(true, true, exchangeSettings, secrets, logService) { this.api = new HitBTCApi(exchangeSettings, logService, secrets); this.wss = new HitBTCWSS(); this.reader = new HitBTCReader(); }
private TransactionHistoryDTO convertToTH(ExchangeDTO dto, string status) { var th = new TransactionHistoryDTO(); th.Currency = dto.Currency; th.TransactionCost = dto.Amount; th.TransactionType = dto.From; th.TransactionTarget = dto.To; th.TransactionStatus = status; return(th); }
public async Task <ISpotExchangeFacade> GetExchange(ExchangeDTO exx) { ISpotExchangeFacade ex = this.exchanges.FirstOrDefault(x => x.ExchangeName.ToString() == exx.Name); if (ex != null) { return(ex); } else { return(await this.CreateExchanges(exx)); } }
public async Task <IActionResult> GetById(int id) { try { ExchangeDTO dto = await this.repo.GetById(id); return(Ok(dto)); } catch (Exception ex) { log.Log(ex); return(BadRequest()); } }
public async Task <IActionResult> Update([FromBody] ExchangeDTO dto) { try { string userId = this.User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value; await this.repo.Update(dto, userId); return(Ok()); } catch (Exception ex) { log.Log(ex); return(BadRequest()); } }
//[Fact] public async Task Should_Return_OK_When_PostAsync() { HttpClientFactory client = new HttpClientFactory(MockStartup <Startup> .Instance.GetCliente()); await client.AddAuthorizationAsync(); var entity = new ExchangeDTO() { Name = "Teste", APIUrl = "api", Website = "website" }; var result = await client.PostAsync(ROUTE_PATH, entity); Assert.Equal(HttpStatusCode.OK, result.StatusCode); }
public IHttpActionResult CreateExchange(ExchangeDTO exchangedto) { exchangedto.LastContact = DateTime.Now; exchangedto.NextContact = DateTime.Now.AddDays(exchangedto.Frequency); exchangedto.Priority = 3; exchangedto.NextTryAttempt = exchangedto.NextContact; exchangedto.LastTryAttempt = exchangedto.LastContact; var exchange = Mapper.Map <ExchangeDTO, Exchange>(exchangedto); _context.Exchange.Add(exchange); _context.SaveChanges(); exchangedto.Id = exchange.Id; return(Created(new Uri(Request.RequestUri + "/" + exchangedto.Id), exchangedto)); }
public ExchangeDTO ExchangeFromAccount(string username, ExchangeDTO dto) { var account = accountService.GetAccountForUser(username); if (!planService.CanExchange(account.PlanId, dto.Amount, false)) { var th = convertToTH(dto, "failed"); account.Transactions.Add(TransactionHistoryConverter.ToEntity(th)); accountService.Save(account); throw new Exception("Couldn't complete transaction. The desired sum is bigger than the max allowed for the current plan"); } account.Balance = account.Balance - dto.Amount; if (account.Balance < 0.00) { throw new Exception("not enough balance in the account"); } var recipient = accountService.GetAccountForUser(dto.To); if (recipient == null) { throw new Exception("Couldn't find such a user"); } recipient.Balance += dto.Amount; var transaction = convertToTH(dto, "success"); transaction.Name = "Account"; var originTransaction = transaction.ShallowCopy(); originTransaction.TransactionCost *= -1; // we need to make the transaction cost negative since its a withdraw from the sender`s account originTransaction.Name = "Account"; account.Transactions.Add(TransactionHistoryConverter.ToEntity(originTransaction)); recipient.Transactions.Add(TransactionHistoryConverter.ToEntity(transaction)); accountService.Save(account); accountService.Save(recipient); return(dto); }
//[Fact] public async Task Should_Return_OK_When_DeleteAsync() { HttpClientFactory client = new HttpClientFactory(MockStartup <Startup> .Instance.GetCliente()); await client.AddAuthorizationAsync(); var entity = new ExchangeDTO() { Name = "Teste", APIUrl = "api", Website = "website" }; var result = await client.PostAsync(ROUTE_PATH, entity); Assert.Equal(HttpStatusCode.OK, result.StatusCode); entity = JsonConvert.DeserializeObject <ExchangeDTO>(await result.Content.ReadAsStringAsync()); result = await client.DeleteAsync($"{ROUTE_PATH}/{entity.Id}"); Assert.Equal(HttpStatusCode.OK, result.StatusCode); }
public void CanConvert(int coinsPerGem, int quantity, DateTime date) { var value = new ExchangeDTO { CoinsPerGem = coinsPerGem, Quantity = quantity }; var state = new Response <ExchangeDTO> { Content = value, Date = date }; // MEMO: property 'result.Send' is not tested, because it is not included in the data contract var result = this.exchangeConverter.Convert(value, state); Assert.NotNull(result); Assert.Equal(coinsPerGem, result.CoinsPerGem); Assert.Equal(quantity, result.Receive); Assert.Equal(date, result.Timestamp); }
public ExchangeDTO ExchangeFromVirtualCard(string username, string virtualCardName, ExchangeDTO dto) { var account = accountService.GetAccountForUser(username); var vc = virtualCardService.GetVirtualCard(username, virtualCardName); if (!planService.CanExchange(account.PlanId, dto.Amount, false)) { var th = convertToTH(dto, "failed"); account.Transactions.Add(TransactionHistoryConverter.ToEntity(th)); accountService.Save(account); throw new Exception("Couldn't complete transaction. The desired sum is bigger than the max allowed for the current plan or you dont have any more transactions permitted"); } vc.Balance = vc.Balance - dto.Amount; if (vc.Balance < 0.00) { throw new Exception("not enough balance in the virtual card"); } var recipient = accountService.GetAccountForUser(dto.To); if (recipient == null) { throw new Exception("Couldn't find such a user"); } recipient.Balance += dto.Amount; var transaction = convertToTH(dto, "success"); transaction.Name = "Account"; var originTransaction = transaction.ShallowCopy(); originTransaction.TransactionCost *= -1; // we need to make the transaction cost negative since its a withdraw from the sender`s account originTransaction.Name = vc.CardNumber; originTransaction.AccountId = account.Id; transaction.AccountId = recipient.Id; historyService.Save(originTransaction); historyService.Save(transaction); planService.ExecuteTransaction(account.PlanId); virtualCardService.Save(vc); return(dto); }
public SpotExchange_API(bool ObserveAllSymbolsMode, bool ObserveAllBalancesMode, ExchangeDTO exchangeSettings, UserExchangeSecretDTO secrets, ExchangeLogService logService) : base(ObserveAllSymbolsMode, ObserveAllBalancesMode, exchangeSettings, secrets, logService) { }
public IHttpActionResult Exchange(string username, string cardname, ExchangeDTO dto) { return(Json(exchangeService.ExchangeFromVirtualCard(username, cardname, dto))); }
public BinanceApi(ExchangeDTO exchangeSettings, ExchangeLogService logger, UserExchangeSecretDTO secrets) : base(exchangeSettings, logger, secrets) { }
public async Task <IActionResult> Post([FromBody] ExchangeDTO entity) { return(Ok(_mapper.Map <ExchangeDTO>(await _repository.InsertAsync(_mapper.Map <Exchange>(entity))))); }
public IHttpActionResult Exchange(string username, ExchangeDTO dto) { return(Json(_exchangeService.ExchangeFromAccount(username, dto)));; }
public async Task <IActionResult> Put([FromBody] ExchangeDTO entity) { await _repository.UpdateAsync(_mapper.Map <Exchange>(entity)); return(Ok()); }