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