public async Task <IWriterResult <bool> > AdminCreateSupportFaq(string userId, CreateSupportFaqModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var faq = await context.SupportFaq.FirstOrDefaultNoLockAsync(x => x.Question == model.Question);
if (faq != null)
{
return(WriterResult <bool> .ErrorResult("FAQ with question '{0}' already exists.", model.Question));
}
int order = context.SupportFaq.Count() + 1;
context.SupportFaq.Add(new SupportFaq
{
Question = model.Question,
Answer = model.Answer,
Order = order,
IsEnabled = true
});
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > AddUserRole(UserRoleModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var user = await context.Users.FirstOrDefaultNoLockAsync(x => x.UserName == model.UserName);
if (user == null)
{
return(WriterResult <bool> .ErrorResult("User {0} not found.", model.UserName));
}
var role = await context.Roles.FirstOrDefaultNoLockAsync(x => x.Name == model.SecurityRole.ToString());
if (role == null)
{
return(WriterResult <bool> .ErrorResult("{0} role does not exist", model.SecurityRole));
}
var exists = await context.UserRoles.FirstOrDefaultNoLockAsync(x => x.User.UserName == model.UserName && x.Role.Name == model.SecurityRole.ToString());
if (exists != null)
{
return(WriterResult <bool> .ErrorResult("{0} is already assigned to {1} role.", model.UserName, model.SecurityRole));
}
context.UserRoles.Add(new UserRole {
UserId = user.Id, RoleId = role.Id
});
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > CancelWithdraw(string userId, int withdrawId)
{
using (var context = DataContextFactory.CreateContext())
{
var withdraw = await context.Withdraw
.Include(x => x.User)
.Include(x => x.Currency)
.FirstOrDefaultAsync(x => x.Id == withdrawId && x.UserId == userId && x.WithdrawStatus == WithdrawStatus.Unconfirmed);
if (withdraw == null || withdraw.WithdrawStatus != WithdrawStatus.Unconfirmed)
{
return(WriterResult <bool> .ErrorResult("Withdraw #{0} not found or is already canceled.", withdrawId));
}
if (!withdraw.User.IsWithdrawEnabled)
{
return(WriterResult <bool> .ErrorResult("Your withdrawals are currently disabled."));
}
withdraw.WithdrawStatus = WithdrawStatus.Canceled;
await context.SaveChangesAsync();
await AuditService.AuditUserCurrency(context, userId, withdraw.CurrencyId);
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > AdminUpdateSupportFaq(string userId, UpdateSupportFaqModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var faq = await context.SupportFaq.FirstOrDefaultNoLockAsync(x => x.Id == model.Id);
if (faq == null)
{
return(WriterResult <bool> .ErrorResult("FAQ with id '{0}' not found.", model.Id));
}
if (faq.Order != model.Order)
{
var order = Math.Max(Math.Min(context.SupportFaq.Count() - 1, model.Order), 0);
foreach (var item in context.SupportFaq.Where(x => x.Order >= order).ToList())
{
item.Order++;
}
faq.Order = order;
}
faq.Question = model.Question;
faq.Answer = model.Answer;
faq.IsEnabled = model.IsEnabled;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <int> > CreateApiWithdraw(string userId, string currency, string address, decimal amount)
{
int currencyId = 0;
using (var context = DataContextFactory.CreateContext())
{
var currencyEntity = await context.Currency.Where(w => w.Symbol == currency).FirstOrDefaultNoLockAsync();
if (currencyEntity == null)
{
return(WriterResult <int> .ErrorResult("Currency not found."));
}
currencyId = currencyEntity.Id;
}
return(await WithdrawService.QueueWithdraw(new CreateWithdraw
{
IsApi = true,
UserId = userId,
Address = address,
Amount = amount,
ConfirmationToken = "",
CurrencyId = currencyId
}));
}
public async Task <IWriterResult <int> > CreateSupportTicketReply(string userId, CreateSupportTicketReplyModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var ticket = await context.SupportTicket.Include(x => x.Replies).FirstOrDefaultNoLockAsync(x => x.Id == model.TicketId);
if (ticket == null)
{
return(WriterResult <int> .ErrorResult("Support ticket #{0} not found", model.TicketId));
}
var reply = new SupportTicketReply
{
Message = model.Message,
UserId = userId,
TicketId = ticket.Id,
IsPublic = true,
IsAdmin = false,
Created = DateTime.UtcNow
};
ticket.Replies.Add(reply);
ticket.Status = SupportTicketStatus.UserReply;
ticket.LastUpdate = DateTime.UtcNow;
await context.SaveChangesAsync();
return(WriterResult <int> .SuccessResult(reply.Id));
}
}
public async Task <IWriterResult <bool> > CreateVoteItem(string userId, CreateVoteItemModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var voteItem = await context.VoteItem.FirstOrDefaultNoLockAsync(x => x.Name == model.Name);
if (voteItem != null)
{
return(WriterResult <bool> .ErrorResult("VoteItem {0} already exists.", model.Name));
}
voteItem = new VoteItem
{
Name = model.Name,
Symbol = model.Symbol,
Website = model.Website,
Source = model.Source,
AlgoType = model.AlgoType,
Created = DateTime.UtcNow,
UserId = userId,
Status = VoteItemStatus.Pending,
Description = model.Description
};
context.VoteItem.Add(voteItem);
var contextResults = await context.SaveChangesWithLoggingAsync();
return(WriterResult <bool> .ContextResult(contextResults, "Successfully submitted coin for review"));
}
}
public async Task <IWriterResult <bool> > AdminUpdateVoteItem(string userId, UpdateVoteItemModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var voteItem = await context.VoteItem.FirstOrDefaultNoLockAsync(x => x.Id == model.Id);
if (voteItem == null)
{
return(WriterResult <bool> .ErrorResult("VoteItem {0} not found.", model.Id));
}
if (model.Status == VoteItemStatus.Deleted)
{
context.VoteItem.Remove(voteItem);
}
else
{
voteItem.AdminNote = model.Note;
voteItem.Name = model.Name;
voteItem.Source = model.Source;
voteItem.Status = model.Status;
voteItem.Symbol = model.Symbol;
voteItem.Website = model.Website;
voteItem.AlgoType = model.AlgoType;
voteItem.Description = model.Description;
}
var contextResults = await context.SaveChangesWithLoggingAsync();
return(WriterResult <bool> .ContextResult(contextResults));
}
}
public async Task <IWriterResult <bool> > CreatePaidVote(string userId, CreatePaidVoteModel model)
{
if (!await VoteService.CheckVoteItems())
{
return(WriterResult <bool> .ErrorResult("The current vote round has ended."));
}
using (var context = DataContextFactory.CreateContext())
{
var settings = await context.VoteSetting.FirstOrDefaultNoLockAsync();
if (settings == null)
{
return(WriterResult <bool> .ErrorResult("VoteItem not found."));
}
if (model.VoteCount <= 0 || (settings.Price * model.VoteCount) <= 0)
{
return(WriterResult <bool> .ErrorResult("Invalid vote amount."));
}
var voteItem = await context.VoteItem.FirstOrDefaultNoLockAsync(x => x.Id == model.VoteItemId);
if (voteItem == null)
{
return(WriterResult <bool> .ErrorResult("VoteItem not found."));
}
var transferResult = await TradeService.QueueTransfer(new CreateTransferModel
{
UserId = userId,
ToUser = Constants.SystemVoteUserId,
CurrencyId = settings.CurrencyId,
Amount = model.VoteCount *settings.Price,
TransferType = TransferType.Vote
});
if (transferResult.HasError)
{
return(WriterResult <bool> .ErrorResult(transferResult.Error));
}
var vote = new Entity.Vote
{
Created = DateTime.UtcNow,
Count = model.VoteCount,
Type = VoteType.Paid,
Status = VoteStatus.Live,
UserId = userId,
VoteItemId = model.VoteItemId
};
context.Vote.Add(vote);
var contextResults = await context.SaveChangesWithLoggingAsync();
return(WriterResult <bool> .ContextResult(contextResults, "Successfully added {0} vote(s) for {1}", model.VoteCount, voteItem.Name));
}
}
public async Task <WriterResult <bool> > CreateCurrency(string userId, CreateCurrencyModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var existing = await context.Currency.FirstOrDefaultNoLockAsync(c => c.Name == model.Name || c.Symbol == model.Symbol);
if (existing != null)
{
return(WriterResult <bool> .ErrorResult("Currency with {0} already exists.", existing.Name == model.Name?$"Name '{model.Name}'" : $"Symbol '{model.Symbol}'"));
}
existing = await context.Currency.FirstOrDefaultNoLockAsync(c => c.WalletPort == model.WalletPort && c.WalletHost == model.WalletHost);
if (existing != null)
{
return(WriterResult <bool> .ErrorResult("Wallet with RPC settings {0}:{1} already exists.", model.WalletHost, model.WalletPort));
}
var entity = new Entity.Currency
{
IsEnabled = model.IsEnabled,
MaxTrade = model.MaxTrade,
MaxWithdraw = model.MaxWithdraw,
MinBaseTrade = model.MinBaseTrade,
MinConfirmations = model.MinConfirmations,
MinTrade = model.MinTrade,
MinWithdraw = model.MinWithdraw,
Name = model.Name,
Status = model.Status,
StatusMessage = model.StatusMessage,
Symbol = model.Symbol,
TradeFee = model.TradeFee,
TransferFee = model.TransferFee,
WithdrawFee = model.WithdrawFee,
WithdrawFeeType = model.WithdrawFeeType,
WalletHost = model.WalletHost,
WalletPass = model.WalletPass,
WalletPort = model.WalletPort,
WalletUser = model.WalletUser,
ColdBalance = 0m,
MarketSortOrder = model.MarketSortOrder,
Algo = model.Algo,
InterfaceType = model.InterfaceType,
Type = model.Type,
IsFaucetEnabled = model.IsFaucetEnabled,
FaucetMax = model.FaucetMax,
FaucetPayment = model.FaucetPayment
};
context.Currency.Add(entity);
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > CreateTransfer(CreateTransferModel model)
{
var result = await TradeService.QueueTransfer(model);
if (result.HasError)
{
return(WriterResult <bool> .ErrorResult(result.Error));
}
return(WriterResult <bool> .SuccessResult());
}
public async Task <IWriterResult <bool> > CancelTrade(string userId, CancelTradeModel model)
{
model.UserId = userId;
var result = await TradeService.QueueCancel(model);
if (result.HasError)
{
return(WriterResult <bool> .ErrorResult(result.Error));
}
return(WriterResult <bool> .SuccessResult());
}
public async Task <WriterResult <bool> > Claim(string userId, string ipaddress, int currencyId)
{
var result = await TradeService.QueueFaucetPayment(new CreateFaucetPaymentModel
{
UserId = userId,
IPAddress = ipaddress,
CurrencyId = currencyId,
IsApi = false
});
if (result.HasError)
{
return(WriterResult <bool> .ErrorResult(result.Error));
}
return(WriterResult <bool> .SuccessResult(result.Message));
}
public async Task <WriterResult <bool> > AdminUpdateChatMessage(string userId, UpdateChatMessageModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var chatEntity = await context.ChatMessage.FirstOrDefaultNoLockAsync(x => x.Id == model.Id);
if (chatEntity == null)
{
return(WriterResult <bool> .ErrorResult());
}
chatEntity.IsEnabled = model.IsEnabled;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > UpdateSupportTicketStatus(string userId, UpdateSupportTicketStatusModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var ticket = await context.SupportTicket.Include(x => x.Replies).FirstOrDefaultNoLockAsync(x => x.Id == model.TicketId);
if (ticket == null)
{
return(WriterResult <bool> .ErrorResult("Support ticket #{0} not found", model.TicketId));
}
ticket.Status = model.Status;
ticket.LastUpdate = DateTime.UtcNow;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > AdminUpdateSupportCategory(string userId, UpdateSupportCategoryModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var category = await context.SupportCategory.FirstOrDefaultNoLockAsync(x => x.Id == model.Id);
if (category == null)
{
return(WriterResult <bool> .ErrorResult("Category with id '{0}' not found.", model.Id));
}
category.Name = model.Name;
category.IsEnabled = model.IsEnabled;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <WriterResult <bool> > UpdateTradePair(string userId, UpdateTradePairModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var tradePair = await context.TradePair.FirstOrDefaultNoLockAsync(x => x.Id == model.Id);
if (tradePair == null)
{
return(WriterResult <bool> .ErrorResult("TradePair '{0}' not found"));
}
tradePair.Status = model.Status;
tradePair.StatusMessage = model.StatusMessage;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > AdminUpdateSupportReplyStatus(string userId, UpdateSupportReplyStatusModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var reply = await context.SupportTicketReply
.Include(r => r.Ticket)
.FirstOrDefaultNoLockAsync(x => x.Id == model.ReplyId);
if (reply == null)
{
return(WriterResult <bool> .ErrorResult("Support reply #{0} not found", model.ReplyId));
}
reply.IsPublic = model.IsPublic;
reply.Ticket.LastUpdate = DateTime.UtcNow;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <string> > GenerateAddress(string userId, string currency)
{
using (var context = DataContextFactory.CreateContext())
{
var currencyEntity = await context.Currency.FirstOrDefaultNoLockAsync(x => x.Symbol == currency && x.IsEnabled);
if (currencyEntity == null)
{
return(WriterResult <string> .ErrorResult("Currency not found."));
}
var addressAccount = currencyEntity.InterfaceType == Enums.CurrencyInterfaceType.NoAccount ? string.Empty : userId;
var newAddress = await WalletService.GenerateAddress(addressAccount, currencyEntity.WalletHost, currencyEntity.WalletPort, currencyEntity.WalletUser, currencyEntity.WalletPass);
if (newAddress == null)
{
return(WriterResult <string> .ErrorResult("Failed to generate address for {0}.", currencyEntity.Name));
}
var currentAddresses = await context.Address.Where(x => x.UserId == userId && x.CurrencyId == currencyEntity.Id && x.IsActive).ToListNoLockAsync();
foreach (var currentAddress in currentAddresses)
{
currentAddress.IsActive = false;
}
var addressEntity = new Entity.Address
{
AddressHash = newAddress.Address,
PrivateKey = newAddress.PrivateKey,
CurrencyId = currencyEntity.Id,
UserId = userId,
IsActive = true,
};
context.Address.Add(addressEntity);
await context.SaveChangesAsync();
return(WriterResult <string> .SuccessResult(data : newAddress.Address, message : "Successfully generated address"));
}
}
public async Task <IWriterResult <bool> > AdminCreateSupportCategory(string userId, CreateSupportCategoryModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var category = await context.SupportCategory.FirstOrDefaultNoLockAsync(x => x.Name == model.Name);
if (category != null)
{
return(WriterResult <bool> .ErrorResult("Category with name '{0}' already exists.", model.Name));
}
context.SupportCategory.Add(new SupportCategory
{
Name = model.Name,
IsEnabled = true
});
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > UpdateUser(UpdateUserModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var existinguser = await context.Users.FirstOrDefaultNoLockAsync(x => (x.Email == model.Email && x.Id != model.UserId) || (x.UserName == model.UserName && x.Id != model.UserId));
if (existinguser != null)
{
return(WriterResult <bool> .ErrorResult(model.UserName == existinguser.UserName? "Username already in use." : "Email already in use."));
}
var user = await context.Users
.Include(x => x.Profile)
.FirstOrDefaultNoLockAsync(x => x.Id == model.UserId);
if (user == null)
{
return(WriterResult <bool> .ErrorResult("User {0} not found.", model.UserName));
}
user.UserName = model.UserName;
user.Email = model.Email;
user.LockoutEndDateUtc = model.IsLocked ? DateTime.UtcNow.AddYears(10) : DateTime.UtcNow;
user.IsEnabled = model.IsEnabled;
user.IsTradeEnabled = model.IsTradeEnabled;
user.IsWithdrawEnabled = model.IsWithdrawEnabled;
user.IsTransferEnabled = model.IsTransferEnabled;
user.Profile.FirstName = model.FirstName;
user.Profile.LastName = model.LastName;
user.Profile.Address = model.Address;
user.Profile.BirthDate = model.BirthDate;
user.Profile.City = model.City;
user.Profile.Country = model.Country;
user.Profile.PostCode = model.PostCode;
user.Profile.State = model.State;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > CreateFreeVote(string userId, CreateFreeVoteModel model)
{
if (!await VoteService.CheckVoteItems())
{
return(WriterResult <bool> .ErrorResult("The current vote round has ended."));
}
using (var context = DataContextFactory.CreateContext())
{
var voteItem = await context.VoteItem.FirstOrDefaultNoLockAsync(x => x.Id == model.VoteItemId);
if (voteItem == null)
{
return(WriterResult <bool> .ErrorResult("VoteItem not found."));
}
var lastDate = DateTime.UtcNow.AddDays(-1);
if (await context.Vote.AnyAsync(x => x.UserId == userId && x.Created > lastDate))
{
return(WriterResult <bool> .ErrorResult("You have already voted today."));
}
var vote = new Entity.Vote
{
Created = DateTime.UtcNow,
Count = 1,
Type = VoteType.Free,
Status = VoteStatus.Live,
UserId = userId,
VoteItemId = model.VoteItemId
};
context.Vote.Add(vote);
var contextResults = await context.SaveChangesWithLoggingAsync();
return(WriterResult <bool> .ContextResult(contextResults, "Successfully added {0} free vote(s) for {1}", 1, voteItem.Name));
}
}
public async Task <IWriterResult <bool> > RemoveUserRole(UserRoleModel model)
{
if (model.SecurityRole == SecurityRole.Standard)
{
return(WriterResult <bool> .ErrorResult("The {0} role cannot be remove from users.", SecurityRole.Standard));
}
using (var context = DataContextFactory.CreateContext())
{
var role = await context.UserRoles.FirstOrDefaultNoLockAsync(x => x.User.UserName == model.UserName && x.Role.Name == model.SecurityRole.ToString());
if (role == null)
{
return(WriterResult <bool> .ErrorResult("{0} in not assigned to {1} role.", model.UserName, model.SecurityRole));
}
context.UserRoles.Remove(role);
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > UpdateEmailTemplate(EmailTemplateModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var template = await context.EmailTemplates.FirstOrDefaultNoLockAsync(x => x.Type == model.Type);
if (template == null)
{
return(WriterResult <bool> .ErrorResult($"Email template '{model.Type}' not found."));
}
template.Subject = model.Subject;
template.From = model.From;
template.Template = model.Template;
template.IsHtml = model.IsHtml;
template.IsEnabled = model.IsEnabled;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult($"Successfully update email template."));
}
}
public async Task <WriterResult <bool> > CreateTradePair(string userId, CreateTradePairModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var existing = await context.TradePair.Where(t => (t.CurrencyId1 == model.CurrencyId1 && t.CurrencyId2 == model.CurrencyId2) || (t.CurrencyId1 == model.CurrencyId2 && t.CurrencyId2 == model.CurrencyId1)).ToListNoLockAsync();
if (existing.Any())
{
return(WriterResult <bool> .ErrorResult("{0} already exists", existing.Any(x => x.CurrencyId1 == model.CurrencyId1)? "TradePair" : "Inverse TradePair"));
}
var currency = await context.Currency.Where(x => x.Id == model.CurrencyId1).FirstOrDefaultNoLockAsync();
if (currency == null)
{
return(WriterResult <bool> .ErrorResult("Currency '{0}' not found", model.CurrencyId1));
}
var baseCurrency = await context.Currency.Where(x => x.Id == model.CurrencyId2).FirstOrDefaultNoLockAsync();
if (baseCurrency == null)
{
return(WriterResult <bool> .ErrorResult("Currency '{0}' not found", model.CurrencyId2));
}
var entity = new Entity.TradePair
{
CurrencyId1 = model.CurrencyId1,
CurrencyId2 = model.CurrencyId2,
Status = model.Status,
Name = $"{currency.Symbol}_{baseCurrency.Symbol}"
};
context.TradePair.Add(entity);
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
public async Task <IWriterResult <bool> > AdminCreateSupportRequestReply(string userId, CreateSupportRequestReplyModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var ticket = await context.SupportRequest.FirstOrDefaultNoLockAsync(x => x.Id == model.RequestId);
if (ticket == null)
{
return(WriterResult <bool> .ErrorResult("Support request #{0} not found", model.RequestId));
}
var sentEmail = await EmailService.SendRaw($"RE: Support request #{model.RequestId}", model.Message, model.Email);
if (!sentEmail)
{
return(WriterResult <bool> .ErrorResult($"Failed to send email to {model.Email}"));
}
ticket.Replied = true;
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}
private async Task <IWriterResult <int> > ProcessWithdraw(CreateWithdraw model)
{
using (var context = DataContextFactory.CreateContext())
{
var currency = await context.Currency.FirstOrDefaultAsync(x => x.Id == model.CurrencyId);
if (currency == null || !currency.IsEnabled || currency.Status != CurrencyStatus.OK)
{
return(WriterResult <int> .ErrorResult("Currency not found or is currently disabled."));
}
var user = await context.Users.FirstOrDefaultAsync(x => x.Id == model.UserId);
if (user == null || !user.IsWithdrawEnabled)
{
return(WriterResult <int> .ErrorResult("Your withdrawals are currently disabled."));
}
var auditResult = await AuditService.AuditUserCurrency(context, model.UserId, model.CurrencyId);
if (!auditResult.Success || model.Amount > auditResult.Avaliable)
{
return(WriterResult <int> .ErrorResult("Insufficient funds."));
}
if (model.Amount < currency.MinWithdraw || model.Amount > currency.MaxWithdraw)
{
return(WriterResult <int> .ErrorResult("Withdrawal amount must be between {0} and {1} {2}", currency.MinWithdraw, currency.MaxWithdraw, currency.Symbol));
}
var isValidAddress = await WalletService.ValidateAddress(model.Address, currency.WalletHost, currency.WalletPort, currency.WalletUser, currency.WalletPass);
if (!isValidAddress)
{
return(WriterResult <int> .ErrorResult($"Invalid {currency.Symbol} address."));
}
var newWithdraw = new Entity.Withdraw
{
IsApi = model.IsApi,
TimeStamp = DateTime.UtcNow,
TwoFactorToken = model.ConfirmationToken,
Address = model.Address,
CurrencyId = model.CurrencyId,
Amount = Math.Max(0, model.Amount),
Fee = currency.WithdrawFee,
WithdrawType = WithdrawType.Normal,
WithdrawStatus = model.IsApi
? WithdrawStatus.Pending
: WithdrawStatus.Unconfirmed,
UserId = model.UserId
};
context.Withdraw.Add(newWithdraw);
await context.SaveChangesAsync();
await AuditService.AuditUserCurrency(context, model.UserId, model.CurrencyId);
return(WriterResult <int> .SuccessResult(newWithdraw.Id));
}
}
public async Task <WriterResult <bool> > UpdateCurrency(string userId, UpdateCurrencyModel model)
{
using (var context = DataContextFactory.CreateContext())
{
var currency = await context.Currency.FirstOrDefaultNoLockAsync(c => c.Id == model.Id);
if (currency == null)
{
return(WriterResult <bool> .ErrorResult("Currency {0} not found.", model.Id));
}
var existing = await context.Currency.FirstOrDefaultNoLockAsync(c => c.Id != currency.Id && (c.Name == model.Name || c.Symbol == model.Symbol));
if (existing != null)
{
return(WriterResult <bool> .ErrorResult("Currency with {0} already exists.", existing.Name == model.Name?$"Name '{model.Name}'" : $"Symbol '{model.Symbol}'"));
}
currency.IsEnabled = model.IsEnabled;
currency.MaxTrade = model.MaxTrade;
currency.MaxWithdraw = model.MaxWithdraw;
currency.MinBaseTrade = model.MinBaseTrade;
currency.MinConfirmations = model.MinConfirmations;
currency.MinTrade = model.MinTrade;
currency.MinWithdraw = model.MinWithdraw;
currency.Name = model.Name;
currency.Status = model.Status;
currency.StatusMessage = model.StatusMessage;
currency.TradeFee = model.TradeFee;
currency.TransferFee = model.TransferFee;
currency.WithdrawFee = model.WithdrawFee;
currency.WithdrawFeeType = model.WithdrawFeeType;
currency.ColdBalance = model.ColdBalance;
currency.MarketSortOrder = model.MarketSortOrder;
currency.Algo = model.Algo;
currency.InterfaceType = model.InterfaceType;
currency.Type = model.Type;
currency.IsFaucetEnabled = model.IsFaucetEnabled;
currency.FaucetPayment = model.FaucetPayment;
currency.FaucetMax = model.FaucetMax;
// Id the symbol has changed update the tradepair names
if (currency.Symbol != model.Symbol)
{
currency.Symbol = model.Symbol;
var tradePairs = await context.TradePair
.Include(testc => testc.Currency1)
.Include(testc => testc.Currency2)
.Where(t => t.CurrencyId1 == model.Id || t.CurrencyId2 == model.Id)
.ToListNoLockAsync();
foreach (var tradePair in tradePairs)
{
tradePair.Name = tradePair.CurrencyId1 == model.Id
? $"{currency.Symbol}_{tradePair.Currency2.Symbol}"
: $"{tradePair.Currency1.Symbol}_{currency.Symbol}";
}
}
await context.SaveChangesAsync();
return(WriterResult <bool> .SuccessResult());
}
}