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