public async Task <IWriterResult> UpdateTradePair(string adminUserId, UpdateTradePairModel model)
{
using (var context = ExchangeDataContextFactory.CreateContext())
{
var tradePair = await context.TradePair
.Include(x => x.Currency1)
.Include(x => x.Currency2)
.Where(x => x.Id == model.Id)
.FirstOrDefaultNoLockAsync().ConfigureAwait(false);
if (tradePair == null)
{
return(new WriterResult(false, $"TradePair {model.Id} not found."));
}
var oldStatus = tradePair.Status;
tradePair.Status = model.Status;
tradePair.StatusMessage = model.StatusMessage;
using (var dataContext = DataContextFactory.CreateContext())
{
dataContext.LogActivity(adminUserId, $"Updating Trade Pair:{tradePair.Currency1.Symbol}_{tradePair.Currency2.Symbol} Old Status: {oldStatus}, New status {tradePair.Status}.");
await dataContext.SaveChangesAsync().ConfigureAwait(false);
}
await context.SaveChangesAsync().ConfigureAwait(false);
await CacheService.InvalidateAsync(CacheKey.AllTradePairs(), CacheKey.TradePairs()).ConfigureAwait(false);
return(new WriterResult(true, $"Successfully updated tradepair."));
}
}
private async Task <List <TradePairModel> > GetOrCacheAllTradePairs()
{
var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.AllTradePairs(), TimeSpan.FromMinutes(5), async() =>
{
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var summary = await context.TradePair
.AsNoTracking()
.Select(t => new TradePairModel
{
TradePairId = t.Id,
Market = string.Concat(t.Currency1.Symbol, "_", t.Currency2.Symbol),
CurrencyId = t.CurrencyId1,
Symbol = t.Currency1.Symbol,
Name = t.Currency1.Name,
BaseCurrencyId = t.CurrencyId2,
BaseSymbol = t.Currency2.Symbol,
BaseName = t.Currency2.Name,
BaseFee = t.Currency2.TradeFee,
BaseMinTrade = t.Currency2.MinBaseTrade,
Change = t.Change,
LastTrade = t.LastTrade,
Status = t.Status,
StatusMessage = t.StatusMessage
}).ToListNoLockAsync().ConfigureAwait(false);
return(summary);
}
}).ConfigureAwait(false);
return(cacheResult);
}
public async Task <IWriterResult> AdminUpdateTradePair(UpdateTradePairModel model)
{
using (var context = ExchangeDataContextFactory.CreateContext())
{
var tradePair = await context.TradePair
.Include(x => x.Currency1)
.Include(x => x.Currency2)
.Where(x => x.Id == model.Id)
.FirstOrDefaultNoLockAsync().ConfigureAwait(false);
if (tradePair == null)
{
return(new WriterResult(false, $"TradePair {model.Id} not found."));
}
tradePair.Status = model.Status;
tradePair.StatusMessage = model.StatusMessage;
await context.SaveChangesAsync().ConfigureAwait(false);
await CacheService.InvalidateAsync(CacheKey.AllTradePairs(), CacheKey.TradePairs()).ConfigureAwait(false);
return(new WriterResult(true, $"Successfully updated tradepair."));
}
}
public async Task <IWriterResult> CreateTradePair(string adminUserId, CreateTradePairModel model)
{
using (var context = ExchangeDataContextFactory.CreateContext())
{
if (!model.CurrencyId1.HasValue || !model.CurrencyId2.HasValue || model.CurrencyId1 == model.CurrencyId2)
{
return(new WriterResult(false, $"Retarded TradePair warning."));
}
var currency1 = await context.Currency
.Where(x => x.Id == model.CurrencyId1.Value)
.FirstOrDefaultNoLockAsync().ConfigureAwait(false);
if (currency1 == null)
{
return(new WriterResult(false, $"Currency1 {model.CurrencyId1.Value} not found"));
}
var currency2 = await context.Currency
.Where(x => x.Id == model.CurrencyId2.Value)
.FirstOrDefaultNoLockAsync().ConfigureAwait(false);
if (currency2 == null)
{
return(new WriterResult(false, $"Currency2 {model.CurrencyId1.Value} not found"));
}
var tradePair = await context.TradePair
.Include(x => x.Currency1)
.Include(x => x.Currency2)
.Where(x => x.CurrencyId1 == model.CurrencyId1.Value && x.CurrencyId2 == model.CurrencyId2.Value)
.FirstOrDefaultNoLockAsync().ConfigureAwait(false);
if (tradePair != null)
{
return(new WriterResult(false,
$"TradePair {tradePair.Currency1.Symbol}/{tradePair.Currency2.Symbol} already exists."));
}
tradePair = await context.TradePair
.Include(x => x.Currency1)
.Include(x => x.Currency2)
.Where(x => x.CurrencyId1 == model.CurrencyId2.Value && x.CurrencyId2 == model.CurrencyId1.Value)
.FirstOrDefaultNoLockAsync().ConfigureAwait(false);
if (tradePair != null)
{
return(new WriterResult(false,
$"Inverse TradePair {tradePair.Currency1.Symbol}/{tradePair.Currency2.Symbol} already exists."));
}
var newTradePair = new Entity.TradePair
{
CurrencyId1 = currency1.Id,
CurrencyId2 = currency2.Id,
Status = model.Status ?? Enums.TradePairStatus.OK,
StatusMessage = model.StatusMessage,
LastTrade = 0,
Change = 0,
};
context.TradePair.Add(newTradePair);
using (var dataContext = DataContextFactory.CreateContext())
{
dataContext.LogActivity(adminUserId, $"Creating new Trade Pair: {newTradePair.Currency1.Symbol}_{newTradePair.Currency2.Symbol}");
await dataContext.SaveChangesAsync().ConfigureAwait(false);
}
await context.SaveChangesAsync().ConfigureAwait(false);
await CacheService.InvalidateAsync(CacheKey.AllTradePairs(), CacheKey.TradePairs()).ConfigureAwait(false);
return(new WriterResult(true, $"Successfully created new tradepair {currency1.Symbol}/{currency2.Symbol}."));
}
}
public async Task <IWriterResult> BeginDelistingCurrency(string adminUserId, UpdateListingStatusModel model)
{
model.ListingStatus = CurrencyListingStatus.Delisting;
if (model.DelistOn == null)
{
return(new WriterResult(false, "Delist date cannot be null"));
}
var writerResult = await UpdateListingStatus(adminUserId, model);
if (!writerResult.Success)
{
return(writerResult);
}
using (var context = ExchangeDataContextFactory.CreateContext())
{
// Checks for open trade pairs only to avoid accidentally relisting delisted currencies.
var tradePairs = await context.TradePair.Where(t => (t.Status == TradePairStatus.OK || t.Status == TradePairStatus.Paused) && (t.CurrencyId1 == model.CurrencyId || t.CurrencyId2 == model.CurrencyId)).ToListNoLockAsync();
foreach (var tradePair in tradePairs)
{
tradePair.Status = TradePairStatus.Closing;
}
using (var adminContext = DataContextFactory.CreateContext())
{
adminContext.LogActivity(adminUserId, "Closing TradePair due to delisting");
await adminContext.SaveChangesAsync().ConfigureAwait(false);
}
await context.SaveChangesAsync().ConfigureAwait(false);
await CacheService.InvalidateAsync(CacheKey.AllTradePairs(), CacheKey.TradePairs()).ConfigureAwait(false);
}
writerResult.Message = "Successfully started the delisting process.";
try
{
var email = new EmailMessageModel
{
EmailType = EmailTemplateType.CoinDelisting,
BodyParameters = new object[0],
SystemIdentifier = model.Symbol
};
using (var context = ExchangeDataContextFactory.CreateReadOnlyContext())
{
var balances = await context.Balance.Include(b => b.User).Where(b => b.Currency.Name == model.Name && b.Total > 0).OrderBy(b => b.User.Email).ToListNoLockAsync();
if (!balances.Any())
{
writerResult.Message = "Successfully started the delisting process but no non zero balances found so no emails were sent.";
return(writerResult);
}
var personalisations = new List <IEmailPersonalisation>(balances.Select(balance => new EmailPersonalisation {
Tos = new List <string> {
balance.User.Email
},
Substitutions = new Dictionary <string, string>
{
{ "-name-", balance.User.UserName },
{ "-coinName-", model.Name },
{ "-coinSymbol-", model.Symbol },
{ "-delistDate-", model.DelistOn.Value.ToString("R") },
{ "-delistReason-", model.StatusMessage },
{ "-balance-", balance.Total.ToString(CultureInfo.InvariantCulture) }
}
})
.ToList());
var hasSentSuccessfully = await EmailService.SendEmails(email, personalisations);
if (!hasSentSuccessfully)
{
writerResult.Success = false;
writerResult.Message = "Successfully started the delisting process but emails failed to send.";
return(writerResult);
}
}
using (var adminContext = DataContextFactory.CreateContext())
{
adminContext.LogActivity(adminUserId, $"Started Currency Delisting Process for: {model.Name}");
await adminContext.SaveChangesAsync().ConfigureAwait(false);
}
}
catch (Exception)
{
return(new WriterResult(false, "Sending emails failed"));
}
return(writerResult);
}