public async Task <DataTablesResponse> GetPaytopiaHistory(DataTablesModel model) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var query = context.PaytopiaPayments .AsNoTracking() .Where(x => x.Status == PaytopiaPaymentStatus.Complete && x.PaytopiaItem.Type != PaytopiaItemType.Shares) .Select(payment => new PaytopiaDatatableModel { Id = payment.Id, CurrencyId = payment.PaytopiaItem.CurrencyId, Type = payment.PaytopiaItem.Type, Amount = payment.Amount, Timestamp = payment.Timestamp }); var currencies = await CurrencyReader.GetCurrencies().ConfigureAwait(false); var nameMap = currencies.ToDictionary(k => k.CurrencyId, v => v.Name); var symbolMap = currencies.ToDictionary(k => k.CurrencyId, v => v.Symbol); return(await query.GetDataTableResultNoLockAsync(model, (item) => { item.Name = nameMap[item.CurrencyId]; item.Symbol = symbolMap[item.CurrencyId]; }).ConfigureAwait(false)); } }
public async Task <UserVerificationModel> GetVerification(string userId) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var user = await context.Users.FirstOrDefaultNoLockAsync(x => x.Id == userId); if (user == null) { return(null); } var result = new UserVerificationModel { Email = user.Email, VerificationLevel = user.VerificationLevel }; var userVerification = await context.UserVerification.FirstOrDefaultNoLockAsync(x => x.UserId == userId); if (userVerification != null) { result.FirstName = userVerification.FirstName; result.LastName = userVerification.LastName; result.Birthday = userVerification.Birthday; result.Gender = userVerification.Gender; result.Address = userVerification.Address; result.City = userVerification.City; result.State = userVerification.State; result.Postcode = userVerification.Postcode; result.Country = userVerification.Country; } return(result); } }
public async Task <DataTablesResponse> GetOpenTickets(string username, DataTablesModel model) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var user = await context.Users.FirstOrDefaultNoLockAsync(x => x.UserName == username); if (user == null) { return(model.GetEmptyDataTableResult()); } var query = context.SupportTicket .AsNoTracking() .Where(x => x.UserId == user.Id && x.Status != SupportTicketStatus.Closed) .Select(x => new { Id = x.Id, Category = x.Category.ToString(), Title = x.Title, Status = x.Status.ToString(), Created = x.Created, Queue = x.Queue.Name }); return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false)); } }
public async Task <UserProfileInfoModel> GetProfileInfo(string userId) { try { using (var context = DataContextFactory.CreateReadOnlyContext()) { var info = await context.Users .AsNoTracking() .Where(u => u.Id == userId) .Select(u => new UserProfileInfoModel { UserName = u.UserName, TrustRrating = u.TrustRating, KarmaPoints = u.KarmaTotal, UnreadMessages = u.Messages.Count(x => x.IsInbound && !x.IsRead), UnreadNotifications = u.Notifications.Count(x => !x.Acknowledged) }).FirstOrDefaultNoLockAsync().ConfigureAwait(false); return(info); } } catch (Exception) { return(new UserProfileInfoModel()); } }
public async Task <AdminUserSettingsUpdateModel> GetSettingsUpdate(string username) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var user = await context.Users .Include(x => x.Settings) .FirstOrDefaultNoLockAsync(x => x.UserName == username); if (user == null) { return(null); } return(new AdminUserSettingsUpdateModel { Id = user.Id, UserName = user.UserName, HideZeroBalance = user.Settings.HideZeroBalance, ShowFavoriteBalance = user.Settings.ShowFavoriteBalance, ChatDisableEmoticons = user.ChatDisableEmoticons, DisableLogonEmail = user.DisableLogonEmail, DisableRewards = user.DisableRewards, DisableTips = user.DisableTips, Theme = user.Settings.Theme }); } }
public async Task <DataTablesResponse> GetPayments(DataTablesModel model) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var query = context.PaytopiaPayments .AsNoTracking() .Select(payment => new PaymentDatatableModel { Id = payment.Id, Type = payment.PaytopiaItem.Type, Symbol = payment.PaytopiaItem.CurrencyId.ToString(), CurrencyId = payment.PaytopiaItem.CurrencyId, Amount = payment.Amount, Status = payment.Status, UserName = payment.User.UserName, IsAnonymous = payment.IsAnonymous, Begins = payment.Begins, Ends = payment.Ends, Timestamp = payment.Timestamp, TransferId = payment.TransferId, RefundId = payment.RefundId }); return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false)); } }
public async Task <UserProfileModel> GetProfile(string userId) { try { using (var context = DataContextFactory.CreateReadOnlyContext()) { var user = await context.Users .AsNoTracking() .Include(x => x.Profile) .Include(x => x.Settings) .Where(x => x.Id == userId) .FirstOrDefaultNoLockAsync().ConfigureAwait(false); if (user == null) { return(null); } return(new UserProfileModel { IsPublic = user.Profile.IsPublic, AboutMe = user.Profile.AboutMe, AccountEmail = user.Email, Birthday = user.Profile.Birthday, ChatHandle = user.ChatHandle, ContactEmail = user.Profile.ContactEmail, Education = user.Profile.Education, Facebook = user.Profile.Facebook, Gender = user.Profile.Gender, Hobbies = user.Profile.Hobbies, LinkedIn = user.Profile.LinkedIn, MiningHandle = user.MiningHandle, Occupation = user.Profile.Occupation, TrustRating = user.TrustRating, Twitter = user.Profile.Twitter, Website = user.Profile.Website, FirstName = user.Profile.FirstName, LastName = user.Profile.LastName, VerificationLevel = user.VerificationLevel, Address = user.Profile.Address, City = user.Profile.City, Country = user.Profile.Country, Postcode = user.Profile.Postcode, State = user.Profile.State, ReferralDetails = await ReferralReader.GetActiveReferral(user.Id).ConfigureAwait(false) }); } } catch (Exception) { return(new UserProfileModel()); } }
public async Task <DataTablesResponse> GetUserLogins(string username, DataTablesModel model) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var query = context.UserLogons .AsNoTracking() .Where(x => x.User.UserName == username) .Select(x => new { Currency = x.IPAddress, Amount = x.Timestamp }); return(await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false)); } }
public async Task <AdminUserSecurityModel> GetUserSecurity(string username) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var data = await context.Users .AsNoTracking() .Include(x => x.TwoFactor) .Where(u => u.UserName == username) .Select(user => new AdminUserSecurityModel { UserName = user.UserName, DisableLogonEmail = user.DisableLogonEmail, IsApiEnabled = user.IsApiEnabled, IsApiWithdrawEnabled = user.IsApiWithdrawEnabled, IsUnsafeWithdrawEnabled = user.IsUnsafeWithdrawEnabled, IsApiUnsafeWithdrawEnabled = user.IsApiUnsafeWithdrawEnabled, DisableWithdrawEmailConfirmation = user.DisableWithdrawEmailConfirmation, TwoFactor = user.TwoFactor.Select(tfa => new AdminUserTwoFactorItemModel { Name = tfa.Component.ToString(), Component = tfa.Component, Type = tfa.Type.ToString() }).ToList(), }).FirstOrDefaultNoLockAsync(); if (data == null) { return(null); } foreach (var item in Enum.GetValues(typeof(Enums.TwoFactorComponent)).OfType <Enums.TwoFactorComponent>()) { if (data.TwoFactor.Any(x => x.Component == item)) { continue; } data.TwoFactor.Add(new AdminUserTwoFactorItemModel { Component = item, Name = item.ToString(), Type = "None" }); } data.TwoFactor = data.TwoFactor.OrderBy(x => x.Component).ToList(); return(data); } }
public async Task <DataTablesResponse> GetIncompleteWithdrawals(DataTablesModel model) { var newest = DateTime.Now.AddHours(-2.0); List <int> pendingApprovalIds = null; using (var approvalContext = DataContextFactory.CreateReadOnlyContext()) { var approvals = await approvalContext.ApprovalQueue .Where(a => a.Type == ApprovalQueueType.WithdrawalReprocessing && a.Status == ApprovalQueueStatus.Pending) .Select(a => a) .ToListNoLockAsync().ConfigureAwait(false); pendingApprovalIds = approvals.Select(a => { int id; bool success = int.TryParse(JsonConvert.DeserializeObject <ReprocessingApprovalDataModel>(a.Data).WithdrawalId, out id); return(new { success, id }); }) .Where(x => x.success) .Select(x => x.id).ToList(); } using (var context = ExchangeDataContextFactory.CreateReadOnlyContext()) { var query = context.Withdraw .AsNoTracking() .Where(w => w.Status == Enums.WithdrawStatus.Processing && w.Confirmed <= newest && !pendingApprovalIds.Contains(w.Id)) .Select(x => new { Id = x.Id, UserName = x.User.UserName, Currency = x.Currency.Symbol, Amount = x.Amount, Address = x.Address, Confirmed = x.Confirmed, RetryCount = x.RetryCount }); var result = await query.GetDataTableResultNoLockAsync(model).ConfigureAwait(false); return(result); } }
public async Task <ReprocessingApprovalsModel> GetApproval(int id) { using (var context = DataContextFactory.CreateReadOnlyContext()) { return(await context.ApprovalQueue .AsNoTracking() .Where(a => a.Id == id) .Select(x => new ReprocessingApprovalsModel { Id = x.Id, Type = x.Type, RequestedBy = x.RequestUser.UserName, Requested = x.Created, Status = x.Status, Approved = x.Approved, ApprovedBy = x.ApproveUser == null ? string.Empty : x.ApproveUser.UserName }).FirstOrDefaultNoLockAsync(x => x.Id == id).ConfigureAwait(false)); } }
private async Task <List <ShareholderFeeInfo> > GetPaytopiaFeeInfo(DateTime lastPayout, DateTime nextPayout, decimal referralExpenses) { var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.ShareholderPaytopiaFeeInfo(), TimeSpan.FromHours(6), async() => { var currencies = await CurrencyReader.GetCurrencies().ConfigureAwait(false); using (var context = DataContextFactory.CreateReadOnlyContext()) { var paytopia = await context.PaytopiaPayments .AsNoTracking() .Where(x => x.Status == PaytopiaPaymentStatus.Complete && x.PaytopiaItem.Type != PaytopiaItemType.Shares && x.Timestamp > lastPayout && x.Timestamp <= nextPayout) .GroupBy(x => x.PaytopiaItem.CurrencyId) .Select(x => new { CurrencyId = x.Key, Total = x.Sum(p => p.Amount) }).ToListNoLockAsync().ConfigureAwait(false); var results = new List <ShareholderFeeInfo>(); foreach (var item in paytopia) { var currency = currencies.FirstOrDefault(x => x.CurrencyId == item.CurrencyId); if (currency == null) { continue; } results.Add(new ShareholderFeeInfo { Name = currency.Name, Symbol = currency.Symbol, TotalFees = item.Total, Expenses = referralExpenses, SharePrice = item.Total > referralExpenses ? ((item.Total - referralExpenses) / 20000.0m) : 0 }); } return(results); } }).ConfigureAwait(false); return(cacheResult); }
public async Task <AdminUserUpdateModel> GetUserUpdate(string username) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var user = await context.Users.FirstOrDefaultNoLockAsync(x => x.UserName == username); if (user == null) { return(null); } return(new AdminUserUpdateModel { Id = user.Id, UserName = user.UserName, EmailConfirmed = user.EmailConfirmed, RoleCss = user.RoleCss, ShareCount = user.ShareCount }); } }
public async Task <DataTablesResponse> GetPendingApprovals(DataTablesModel model) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var query = context.ApprovalQueue .Where(a => a.Type == ApprovalQueueType.WithdrawalReprocessing && a.Status == ApprovalQueueStatus.Pending) .Select(x => new { Id = x.Id, Type = x.Type, User = x.DataUser.UserName, RequestBy = x.RequestUser.UserName, Requested = x.Created, Status = x.Status, Approved = x.Approved, ApprovedBy = x.ApproveUser == null ? string.Empty : x.ApproveUser.UserName, }).OrderByDescending(x => x.Id); return(await query.GetDataTableResultNoLockAsync(model)); } }
public async Task <AdminUserApiUpdateModel> GetApiUpdate(string username) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var user = await context.Users.FirstOrDefaultNoLockAsync(x => x.UserName == username); if (user == null) { return(null); } return(new AdminUserApiUpdateModel { Id = user.Id, UserName = user.UserName, IsApiEnabled = user.IsApiEnabled, IsApiUnsafeWithdrawEnabled = user.IsApiUnsafeWithdrawEnabled, IsApiWithdrawEnabled = user.IsApiWithdrawEnabled }); } }
public async Task <AdminUserProfileUpdateModel> GetProfileUpdate(string username) { using (var context = DataContextFactory.CreateReadOnlyContext()) { var user = await context.Users .Include(x => x.Profile) .FirstOrDefaultNoLockAsync(x => x.UserName == username); if (user == null) { return(null); } return(new AdminUserProfileUpdateModel { Id = user.Id, UserName = user.UserName, AboutMe = user.Profile.AboutMe, Address = user.Profile.Address, Birthday = user.Profile.Birthday, City = user.Profile.City, ContactEmail = user.Profile.ContactEmail, Country = user.Profile.Country, Education = user.Profile.Education, Facebook = user.Profile.Facebook, FirstName = user.Profile.FirstName, Gender = user.Profile.Gender, Hobbies = user.Profile.Hobbies, LastName = user.Profile.LastName, LinkedIn = user.Profile.LinkedIn, Occupation = user.Profile.Occupation, Postcode = user.Profile.Postcode, State = user.Profile.State, Twitter = user.Profile.Twitter, Website = user.Profile.Website, IsPublic = user.Profile.IsPublic, }); } }
private async Task <List <SiteExpenseModel> > GetSiteExpenses(decimal btcPerDollar) { var cacheResult = await CacheService.GetOrSetHybridAsync(CacheKey.ShareholderSiteExpenses(), TimeSpan.FromHours(1), async() => { using (var context = DataContextFactory.CreateReadOnlyContext()) { var expenses = await context.SiteExpenses .AsNoTracking() .Where(x => x.IsEnabled) .ToListNoLockAsync().ConfigureAwait(false); return(expenses.Select(x => new SiteExpenseModel { Name = x.Name, Price = x.Price, BTCPrice = Math.Round(btcPerDollar *x.Price, 8) }).ToList()); } }).ConfigureAwait(false); return(cacheResult); }
public async Task <ShareholderModel> GetShareInfo(string userId) { var result = new ShareholderModel(); var referralExpenses = await GetReferralExpenses().ConfigureAwait(false); var btcPerDollar = await ExternalApiService.ConvertDollarToBTC(1, ConvertDollarToBTCType.USD).ConfigureAwait(false); var siteExpenses = await GetSiteExpenses(btcPerDollar).ConfigureAwait(false); using (var context = DataContextFactory.CreateReadOnlyContext()) { var user = await context.Users .AsNoTracking() .Where(x => x.Id == userId && x.ShareCount > 0) .FirstOrDefaultNoLockAsync().ConfigureAwait(false); if (user == null) { return(null); } var settings = await context.Settings.FirstOrDefaultNoLockAsync().ConfigureAwait(false); result.LastPayout = settings.LastSharePayout; result.NextPayout = settings.NextSharePayout; result.ShareCount = user.ShareCount; } result.BTCDollar = btcPerDollar; result.SiteExpenses = siteExpenses; result.TotalExpense = siteExpenses.Sum(x => x.Price); result.TotalBTCExpense = siteExpenses.Sum(x => x.BTCPrice); result.FeeInfo = await GetTradeFeeInfo(result.LastPayout, result.NextPayout, result.TotalBTCExpense).ConfigureAwait(false); result.PaytopiaInfo = await GetPaytopiaFeeInfo(result.LastPayout, result.NextPayout, referralExpenses).ConfigureAwait(false); return(result); }
public async Task <PaytopiaPaymentModel> GetPayment(int id) { PaytopiaPaymentModel item; string currencySymbol; dynamic refCurrency; Entity.Pool refPool; using (var context = DataContextFactory.CreateReadOnlyContext()) { item = await context.PaytopiaPayments .AsNoTracking() .Where(x => x.Id == id) .Select(payment => new PaytopiaPaymentModel { Id = payment.Id, Type = payment.PaytopiaItem.Type, CurrencyId = payment.PaytopiaItem.CurrencyId, Amount = payment.Amount, Status = payment.Status, UserName = payment.User.UserName, IsAnonymous = payment.IsAnonymous, Begins = payment.Begins, Ends = payment.Ends, Timestamp = payment.Timestamp, TransferId = payment.TransferId, RefundId = payment.RefundId, ReferenceCode = payment.ReferenceCode, ReferenceId = payment.ReferenceId, RefundReason = payment.RefundReason, RequestData = payment.RequestData, }).FirstOrDefaultNoLockAsync().ConfigureAwait(false); } using (var exchangeContext = ExchangeDataContextFactory.CreateReadOnlyContext()) { currencySymbol = await exchangeContext.Currency.Where(c => c.Id == item.CurrencyId).Select(c => c.Symbol).FirstOrDefaultNoLockAsync(); refCurrency = await exchangeContext.Currency.Where(c => c.Id == item.ReferenceId).Select(c => new { Name = c.Name, AlgoType = c.Info.AlgoType, Symbol = c.Symbol }).FirstOrDefaultNoLockAsync(); } using (var poolContext = PoolDataContextFactory.CreateContext()) { refPool = await poolContext.Pool.Where(p => p.IsEnabled && p.Id == item.ReferenceId).FirstOrDefaultNoLockAsync(); } item.Symbol = currencySymbol; if (item.ReferenceId > 0) { if (item.Type == PaytopiaItemType.FeaturedCurrency || item.Type == PaytopiaItemType.LottoSlot || item.Type == PaytopiaItemType.RewardSlot || item.Type == PaytopiaItemType.TipSlot) { if (refCurrency != null) { item.ReferenceName = refCurrency.Name; item.ReferenceAlgo = refCurrency.AlgoType; item.ReferenceSymbol = refCurrency.Symbol; } } else if (item.Type == PaytopiaItemType.FeaturedPool || item.Type == PaytopiaItemType.PoolListing) { if (refPool != null) { item.ReferenceName = refPool.Name; item.ReferenceAlgo = refPool.AlgoType; item.ReferenceSymbol = refPool.Symbol; } } } return(item); }
public async Task <CreateTipResponseModel> SubmitUserTip(ApiSubmitUserTipRequest request) { var currency = request.CurrencyId.HasValue ? await CurrencyReader.GetCurrency(request.CurrencyId.Value).ConfigureAwait(false) : await CurrencyReader.GetCurrency(request.Currency).ConfigureAwait(false); if (currency == null) { return new CreateTipResponseModel { Error = "Currency not found." } } ; var now = DateTime.UtcNow; if (currency.TippingExpires < now) { return new CreateTipResponseModel { Error = $"Tipping is not currently enabled for {currency.Symbol}." } } ; if (request.ActiveUsers < 2) { return new CreateTipResponseModel { Error = "Minimum 'ActiveUsers' is 2" } } ; if (request.ActiveUsers > 100) { return new CreateTipResponseModel { Error = "Maximum 'ActiveUsers' is 100" } } ; using (var context = DataContextFactory.CreateReadOnlyContext()) { var sender = await context.Users .AsNoTracking() .FirstOrDefaultAsync(x => x.Id == request.UserId.ToString()).ConfigureAwait(false); if (sender == null) { return new CreateTipResponseModel { Error = "Unauthorized." } } ; if (sender.ChatTipBanEndTime.HasValue && sender.ChatTipBanEndTime.Value > DateTime.UtcNow) { return new CreateTipResponseModel { Error = $"You are currently banned from tipping for {(sender.ChatTipBanEndTime.Value - DateTime.UtcNow).TotalSeconds} seconds" } } ; var chatBotId = Constant.SYSTEM_USER_CHATBOT.ToString(); var ignoreList = new List <string> { sender.UserName }; if (!string.IsNullOrEmpty(sender.ChatTipIgnoreList)) { ignoreList.AddRange(sender.ChatTipIgnoreList.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries).Select(x => x.Trim())); } var usersToTip = await context.ChatMessages .AsNoTracking() .Where(x => !x.User.DisableTips && !(x.User.ChatTipBanEndTime.HasValue && x.User.ChatTipBanEndTime.Value > DateTime.UtcNow) && !ignoreList.Contains(x.User.UserName) && x.UserId != chatBotId) .OrderByDescending(x => x.Timestamp) .Select(x => x.UserId) .Distinct() .Take(request.ActiveUsers) .ToListNoLockAsync().ConfigureAwait(false); if (!usersToTip.Any()) { return new CreateTipResponseModel { Error = "No valid users found to tip" } } ; if (request.Amount < (currency.TipMin * usersToTip.Count)) { return new CreateTipResponseModel { Error = $"Minimum tip amount is {currency.TipMin:F8} {currency.Symbol} per user." } } ; var response = await TradeService.CreateTip(request.UserId.ToString(), new CreateTipModel { Amount = request.Amount, CurrencyId = currency.CurrencyId, UserTo = usersToTip.Select(Guid.Parse).ToList() }, true).ConfigureAwait(false); return(response); } }