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