public static IQueryable <FullUserSubscriptionInfo> GetActiveSubscription(BitcornContext dbContext, User user, string subscriptionName, int?tier)
{
if (user == null)
{
return(null);
}
if (user.IsBanned)
{
return(null);
}
var now = DateTime.Now;
var query = GetUserSubscriptions(dbContext, user).Join(dbContext.Subscription,
(UserSubcriptionTierInfo info) => info.SubscriptionTier.SubscriptionId,
(Subscription sub) => sub.SubscriptionId,
(info, sub) => new FullUserSubscriptionInfo
{
UserSubcriptionTierInfo = info,
Subscription = sub
}).Where(s => s.Subscription.Name.ToLower() == subscriptionName.ToLower() &&
s.UserSubcriptionTierInfo.UserSubscription.LastSubDate.Value.AddDays(s.Subscription.Duration) > now);
//.Where(s => s.userInfo.UserSubscription.LastSubDate.Value.AddDays(s.subscriptionInfo.Duration) > now)
if (tier != null)
{
return(query.Where(s => s.UserSubcriptionTierInfo.SubscriptionTier.Tier >= tier.Value));
}
else
{
return(query);
}
}
public static async Task <int> SaveAsync(this BitcornContext dbContext, IsolationLevel isolationLevel = IsolationLevel.RepeatableRead)
{
if (!DB_WRITES_ENABLED)
{
return(0);
}
//create execution strategy so the request can retry if it fails to connect to the database
var strategy = dbContext.Database.CreateExecutionStrategy();
return(await strategy.ExecuteAsync(async() =>
{
using (var transaction = dbContext.Database.BeginTransaction(isolationLevel))
{
try
{
int count = await dbContext.SaveChangesAsync();
transaction?.Commit();
return count;
}
catch (Exception e)
{
transaction?.Rollback();
Log.Logger.Error(e.Message, e);
throw new Exception(e.Message, e.InnerException);
}
}
}));
}
public static async Task <decimal> GetCornPriceAsync(BitcornContext dbContext)
{
var cornPrice = dbContext.Price.FirstOrDefault(p => p.Symbol == "CORN");
string sql = null;
try
{
var cornBtc = await GetPrice("CORN-BTC");
var btcUsdt = await GetPrice("BTC-USDT");
var price = cornBtc * btcUsdt;
//cornPrice.LatestPrice = price;
await UpdatePrices(dbContext, price, btcUsdt, cornBtc);
return(price);
}
catch (Exception e)
{
if (cornPrice != null)
{
return(cornPrice.LatestPrice);
}
return(-1);
}
}
public static IQueryable <User> GetUsersForPlatform(PlatformId[] platformId, BitcornContext dbContext)
{
HashSet <string> ids = platformId.Select(p => p.Id).ToHashSet();
switch (platformId[0].Platform)
{
case "auth0":
return(dbContext.Auth0ManyQuery(ids));
case "twitch":
return(dbContext.TwitchManyQuery(ids));
case "discord":
return(dbContext.DiscordManyQuery(ids));
case "twitter":
return(dbContext.TwitterManyQuery(ids));
case "reddit":
return(dbContext.RedditManyQuery(ids));
default:
throw new Exception($"Platform {platformId[0].Platform} could not be found");
}
}
public static async Task <int> GetUserId(ActionExecutingContext context, BitcornContext dbContext)
{
var platformHeaders = LockUserAttributeUtils.GetPlatformHeaders(context);
switch (platformHeaders.Platform)
{
case "auth0":
return(await dbContext.Auth0Query(platformHeaders.Id).Select(u => u.UserId).FirstOrDefaultAsync());
case "twitch":
return(await dbContext.TwitchQuery(platformHeaders.Id).Select(u => u.UserId).FirstOrDefaultAsync());
case "discord":
return(await dbContext.DiscordQuery(platformHeaders.Id).Select(u => u.UserId).FirstOrDefaultAsync());
case "twitter":
return(await dbContext.TwitterQuery(platformHeaders.Id).Select(u => u.UserId).FirstOrDefaultAsync());
case "reddit":
return(await dbContext.RedditQuery(platformHeaders.Id).Select(u => u.UserId).FirstOrDefaultAsync());
default:
return(0);
}
}
public static async Task <string> RefreshToken(BitcornContext dbContext, UserIdentity user, IConfiguration config)
{
var restClient = new RestClient(@"https://id.twitch.tv");
var request = new RestRequest(Method.POST);
request.Resource = "oauth2/token";
request.AddQueryParameter("grant_type", "refresh_token");
request.AddQueryParameter("refresh_token", user.TwitchRefreshToken);
var clientId = config.GetSection("Config").GetSection("TwitchClientIdSub").Value;
request.AddQueryParameter("client_id", clientId);
var clientSecret = config.GetSection("Config").GetSection("TwitchClientSecretSub").Value;
request.AddQueryParameter("client_secret", clientSecret);
request.AddQueryParameter("scope", "openid channel:read:subscriptions channel:read:redemptions channel:manage:redemptions");
var response = restClient.Execute(request);
var twitchRefreshData = JsonConvert.DeserializeObject <TwitchRefreshToken>(response.Content);
//await BITCORNLogger.LogError(dbContext, new Exception("refresh token debug"), response.Content + "::" + user.TwitchRefreshToken+"::"+clientId + "::" + clientSecret.Substring(0, clientSecret.Length / 2));
if (!string.IsNullOrWhiteSpace(twitchRefreshData?.AccessToken) && !string.IsNullOrWhiteSpace(twitchRefreshData?.RefreshToken))
{
//_twitchToken = twitchRefreshData.AccessToken;
//_refreshToken = twitchRefreshData.RefreshToken;
user.TwitchRefreshToken = twitchRefreshData.RefreshToken;
await dbContext.SaveAsync();
}
return(twitchRefreshData.AccessToken);
}
public static async Task TestWalletDownloadWithReferrerInternal(BitcornContext dbContext, string ip, User testUser, bool shouldCompleteBonus)
{
TestUtils.GetBalances(testUser, out decimal? downloadStartBalance, out decimal? referralStartBalance);
var userReferral = dbContext.UserReferral.FirstOrDefault(u => u.UserId == testUser.UserId);
var referrer = dbContext.Referrer.FirstOrDefault(u => u.ReferralId == userReferral.ReferralId);
var controller = new WalletDownloadController(dbContext);
var res = await controller.Download(TestUtils.CreateDownload(ip, DateTime.Now, testUser, referrer.UserId), DateTime.Now);
Assert.Equal(200, (res as StatusCodeResult).StatusCode);
var dbContext2 = TestUtils.CreateDatabase();
try
{
var referralPayoutTotal = await ReferralUtils.TotalReward(dbContext, referrer) + await ReferralUtils.WalletBonusReward(dbContext, referrer, 10);;
TestUtils.GetBalances(testUser, out decimal? downloadEndBalance, out decimal? referralEndBalance);
decimal bonus = 0;
if (shouldCompleteBonus)
{
bonus = ReferralUtils.BONUS_PAYOUT;
}
Assert.Equal(referralStartBalance + referralPayoutTotal + bonus, referralEndBalance);
Assert.Equal(downloadStartBalance + 10 + referrer.Amount + bonus, downloadEndBalance);
}
finally
{
dbContext2.Dispose();
}
}
public static IQueryable <User> GetUserForPlatform(PlatformId platformId, BitcornContext dbContext)
{
switch (platformId.Platform)
{
case "auth0":
return(dbContext.Auth0Query(platformId.Id));
case "twitch":
return(dbContext.TwitchQuery(platformId.Id));
case "stream":
return(dbContext.TwitchQuery(platformId.Id));
case "twitchusername":
return(dbContext.TwitchUsernameQuery(platformId.Id));
case "discord":
return(dbContext.DiscordQuery(platformId.Id));
case "twitter":
return(dbContext.TwitterQuery(platformId.Id));
case "reddit":
return(dbContext.RedditQuery(platformId.Id));
case "userid":
return(dbContext.UserIdQuery(int.Parse(platformId.Id)));
default:
throw new Exception($"User {platformId.Platform}|{platformId.Id} could not be found");
}
}
public static async Task <(decimal, decimal, decimal)> GetPricesAsync(BitcornContext dbContext)
{
var cornPriceCache = dbContext.Price.FirstOrDefault(p => p.Symbol == "CORN");
try
{
if (cornPriceCache.UpdateTime == null || DateTime.Now > cornPriceCache.UpdateTime.Value.AddSeconds(20))
{
var cornBtc = await GetPrice("CORN-BTC");
var btcUsdt = await GetPrice("BTC-USDT");
var cornPrice = cornBtc * btcUsdt;
await UpdatePrices(dbContext, cornPrice, btcUsdt, cornBtc);
return(cornBtc, btcUsdt, cornPrice);
}
else
{
var btcUsdCache = dbContext.Price.FirstOrDefault(p => p.Symbol == "BTC-USD");
var cornBtcCache = dbContext.Price.FirstOrDefault(p => p.Symbol == "CORN-BTC");
return(cornBtcCache.LatestPrice, btcUsdCache.LatestPrice, cornPriceCache.LatestPrice);
}
}
catch
{
var btcUsdCache = dbContext.Price.FirstOrDefault(p => p.Symbol == "BTC-USD");
var cornBtcCache = dbContext.Price.FirstOrDefault(p => p.Symbol == "CORN-BTC");
return(cornBtcCache.LatestPrice, btcUsdCache.LatestPrice, cornPriceCache.LatestPrice);
}
}
public static async Task SetTier(BitcornContext dbContext, Referrer referrer)
{
var banned = await dbContext.User.Where(s => s.UserId == referrer.UserId).Select(u => u.IsBanned).FirstOrDefaultAsync();
if (banned)
{
return;
}
var stats = await dbContext.UserStat.FirstOrDefaultAsync(s => s.UserId == referrer.UserId);
if (stats.TotalReferrals == null)
{
stats.TotalReferrals = 0;
}
if (stats.TotalReferrals < 50 && referrer.Tier < 1)
{
referrer.Tier = 0;
}
if (stats.TotalReferrals >= 50 && referrer.Tier < 1)
{
referrer.Tier = 1;
}
if (stats.TotalReferrals >= 500 && referrer.Tier < 2)
{
referrer.Tier = 2;
}
if (stats.TotalReferrals >= 20000 && referrer.Tier < 3)
{
referrer.Tier = 3;
}
await dbContext.SaveAsync();
}
public static async Task <decimal> CornPrice(BitcornContext dbContext)
{
var cornPrice = dbContext.Price.FirstOrDefault(p => p.Symbol == "CORN");
try
{
if (cornPrice == null)
{
var price = new Price();
price.Symbol = "CORN";
price.LatestPrice = (await ProbitApi.GetCornPriceAsync(dbContext));
dbContext.Price.Add(price);
await dbContext.SaveAsync();
return(price.LatestPrice);
}
cornPrice.LatestPrice = (await ProbitApi.GetCornPriceAsync(dbContext));
await dbContext.SaveAsync();
}
catch (Exception e)
{
await BITCORNLogger.LogError(dbContext, e, null);
}
return(cornPrice.LatestPrice);
}
public const bool DB_WRITES_ENABLED = true;//true;
public static async Task <int> ExecuteSqlRawAsync(BitcornContext dbContext, string sql)
{
if (DB_WRITES_ENABLED)
{
return(await dbContext.Database.ExecuteSqlRawAsync(sql));
}
return(0);
}
public static async Task <decimal> WalletBonusReward(BitcornContext dbContext, Referrer referrer, int amount)
{
await SetTier(dbContext, referrer);
var referralTier = await dbContext.ReferralTier.FirstOrDefaultAsync(r => r.Tier == referrer.Tier);
return(amount * referralTier.Bonus);
}
public static async Task <bool> HasSubscribed(BitcornContext dbContext, User user, string subscriptionName, int?tier)
{
var query = GetActiveSubscription(dbContext, user, subscriptionName, tier);
if (query != null)
{
return(await query.AnyAsync());
}
return(false);
}
public static async Task <User> ReadUser(IConfiguration config, BitcornContext dbContext, HttpContext context)
{
var identity = context.User.Identities.First();
var claim = identity.Claims.FirstOrDefault(c => c.Type == config["Config:IdKey"]);
if (claim == default(Claim))
{
return(null);
}
var split = claim.Value.Split('@');
if (split.Length == 1)
{
var user = await dbContext.Auth0Query(claim.Value).FirstOrDefaultAsync();
if (user != null)
{
context.Items.Add("user", user);
context.Items.Add("usermode", 0);
}
else
{
if (claim.Value.Contains("auth0|"))
{
try
{
user = Controllers.RegisterController.CreateUser(new Auth0User()
{
Auth0Id = claim.Value,
Auth0Nickname = ""
}, 0);
dbContext.User.Add(user);
await dbContext.SaveAsync();
context.Items.Add("user", user);
context.Items.Add("usermode", 0);
}
catch (Exception e)
{
user = null;
await BITCORNLogger.LogError(dbContext, e, claim.Value);
return(null);
}
}
}
//await BITCORNLogger.LogError(dbContext, new Exception(""),
//Newtonsoft.Json.JsonConvert.SerializeObject(new { userId = claim.Value, isNull=user==null }));
return(user);
}
else
{
return(null);
}
}
private static async Task <bool> TrySharePaymentWithReferrer(BitcornContext dbContext,
SubscriptionResponse output,
SubRequest subRequest,
Subscription subInfo,
SubscriptionTier requestedTierInfo,
User user,
int subscriptionPaymentRecipientId,
decimal cost,
SubscriptionState previousSubState,
SubTx subTx)
{
//if (previousSubState != SubscriptionState.None) return false;
//if subscription referrar share is defined and its between 0 and 1
//get subscriber userreferral info
var userReferral = await dbContext.UserReferral.FirstOrDefaultAsync(r => r.UserId == user.UserId);
if (userReferral != null && userReferral.ReferralId != 0)
{
//get info of the person who referred the subscriber
var referrer = await dbContext.Referrer.FirstOrDefaultAsync(u => u.ReferralId == userReferral.ReferralId);
//check if referrer can get rewards
if (ReferralUtils.IsValidReferrer(referrer))
{
var referrerUser = await dbContext.JoinUserModels().FirstOrDefaultAsync(u => u.UserId == referrer.UserId);
if (referrerUser != null && !referrerUser.IsBanned)
{
bool success = false;
if (subInfo.ReferrerPercentage != null && subInfo.ReferrerPercentage > 0 && subInfo.ReferrerPercentage <= 1)
{
//get the user who received the subscription payment
var subscriptionPaymentRecipient = await dbContext.JoinUserModels().FirstOrDefaultAsync(u => u.UserId == subscriptionPaymentRecipientId);
success = await ShareSubscriptionPaymentWithReferrer(dbContext,
subInfo,
cost,
subTx,
referrer,
referrerUser,
subscriptionPaymentRecipient);
}
if (previousSubState == SubscriptionState.None && subInfo.Name == "BITCORNFarms")
{
await ReferralUtils.BonusPayout(dbContext, userReferral, referrer, user, referrerUser, referrerUser.UserStat);
}
return(success);
}
}
}
return(false);
}
public static async Task BonusPayout(BitcornContext dbContext, UserReferral userReferral, Referrer referrer, User user, User referrerUser,
UserStat referrerStat)
{
if (userReferral != null &&
userReferral.SignupReward != null &&
userReferral.MinimumBalanceDate != null &&
userReferral.WalletDownloadDate != null &&
userReferral.SyncDate != null &&
userReferral.Bonus == null &&
userReferral.ReferrerBonus == null &&
userReferral.UserSubscriptionId == null &&
referrer != null &&
!user.IsBanned &&
!referrerUser.IsBanned)
{
var subQuery = SubscriptionUtils.GetActiveSubscription(dbContext, user, "BITCORNFarms", 1);
if (subQuery == null)
{
return;
}
var userSubInfo = await subQuery.FirstOrDefaultAsync();
if (userSubInfo == null)
{
return;
}
userReferral.UserSubscriptionId = userSubInfo.UserSubcriptionTierInfo.UserSubscription.UserSubscriptionId;
var amount = BONUS_PAYOUT;
var bonusReward = await TxUtils.SendFromBitcornhub(user, amount, "BITCORNFarms", "Referral bonus reward", dbContext);
if (IsValidReferrer(referrer))
{
if (bonusReward)
{
userReferral.Bonus = DateTime.Now;
await LogReferralTx(dbContext, user.UserId, amount, "Recruit bonus reward");
var referrerBonusReward = await TxUtils.SendFromBitcornhub(referrerUser, amount, "BITCORNFarms", "Referral bonus reward", dbContext);
if (referrerBonusReward)
{
await UpdateYtdTotal(dbContext, referrer, amount);
await LogReferralTx(dbContext, referrerUser.UserId, amount, "Referral bonus reward");
referrerStat.TotalReferralRewardsCorn += amount;
referrerStat.TotalReferralRewardsUsdt += (amount * await ProbitApi.GetCornPriceAsync(dbContext));
userReferral.ReferrerBonus = DateTime.Now;
}
}
}
}
}
public static void AddUser(this BitcornContext context, UserIdentity identity, UserWallet wallet)
{
var user = new User();
user.UserWallet = wallet;
user.UserIdentity = identity;
user.UserStat = new UserStat();
context.User.Add(user);
context.SaveChanges();
}
public static IQueryable <UserSubcriptionTierInfo> GetUserSubscriptions(BitcornContext dbContext, User user)
{
return((from userSubscription in dbContext.UserSubscription
join subscriptionTier in dbContext.SubscriptionTier
on userSubscription.SubscriptionTierId equals subscriptionTier.SubscriptionTierId
select new UserSubcriptionTierInfo
{
UserSubscription = userSubscription,
SubscriptionTier = subscriptionTier
}).Where(t => t.UserSubscription.UserId == user.UserId));
}
public static async Task <TxRecordOutput[]> ListSentTransactions(BitcornContext dbContext, int user, HashSet <string> transactions)
{
List <TxRecordOutput> records = new List <TxRecordOutput>();
var sentQuery = dbContext.CornTx.Where(tx => tx.SenderId == user && transactions.Contains(tx.TxGroupId))
//.Join(dbContext.User,(tx)=>tx.ReceiverId (u)=>u.UserId,(tx,u)=>new { tx,u})
.Join(dbContext.UserIdentity,
(CornTx tx) => tx.ReceiverId, (UserIdentity user) => user.UserId, (CornTx tx, UserIdentity user) => new ReceivedTx
{
BlockchainTxId = tx.BlockchainTxId,
Platform = tx.Platform,
Timestamp = tx.Timestamp,
CornTxId = tx.CornTxId,
Amount = tx.Amount,
TxType = tx.TxType,
TxGroupId = tx.TxGroupId,
CornAddy = tx.CornAddy,
TwitchUsername = user.TwitchUsername,
DiscordUsername = user.DiscordUsername,
TwitterUsername = user.TwitterUsername,
RedditUsername = user.RedditUsername,
Auth0Id = user.Auth0Id,
Auth0Nickname = user.Auth0Nickname,
Username = user.Username,
});
var sent = await sentQuery.ToArrayAsync();
var sentGrouping = sent.GroupBy(data => data.TxGroupId);
foreach (var tx in sentGrouping)
{
var output = new TxRecordOutput();
foreach (var received in tx)
{
output.Action = "sent";
output.BlockchainTxId = received.BlockchainTxId;
output.CornAddy = received.CornAddy;
output.Platform = received.Platform;
output.Time = received.Timestamp.Value;
output.Amount += received.Amount.Value;
output.TxType = received.TxType;
output.Recipients.Add(GetUsername(received));
output.GroupId = received.TxGroupId;
output.RecipientIds.Add(received.Auth0Id);
}
records.Add(output);
}
return(records.ToArray());
}
static async Task <bool> ShareSubscriptionPaymentWithReferrer(BitcornContext dbContext,
Subscription subInfo,
decimal cost,
SubTx subTx,
Referrer referrer,
User referrerUser,
User subscriptionPaymentRecipient)
{
if (referrer.EnableSubscriptionRewards)
{
//get referrer user info
if (!subInfo.RestrictReferralRewards || (subInfo.RestrictReferralRewards && (referrerUser.Level == "BEST" ||
referrerUser.Level == "BAIT" ||
referrerUser.IsAdmin() ||
referrer.Tier >= 3)))
{
//calculate amount that will be sent to the referrer
var referralShare = cost * subInfo.ReferrerPercentage.Value;
//prepare transaction to the referrer
var referralShareTx = await TxUtils.PrepareTransaction(subscriptionPaymentRecipient, referrerUser, referralShare, "BITCORNFarms", "$sub referral share", dbContext);
//make sure stat tracking values have been initialized
if (referrerUser.UserStat.TotalReferralRewardsCorn == null)
{
referrerUser.UserStat.TotalReferralRewardsCorn = 0;
}
//make sure stat tracking values have been initialized
if (referrerUser.UserStat.TotalReferralRewardsUsdt == null)
{
referrerUser.UserStat.TotalReferralRewardsUsdt = 0;
}
//increment total received corn rewards
referrerUser.UserStat.TotalReferralRewardsCorn += referralShare;
//inceremnt total received usdt rewards
referrerUser.UserStat.TotalReferralRewardsUsdt +=
((referralShare) * (await ProbitApi.GetCornPriceAsync(dbContext)));
//execute transaction
if (await TxUtils.ExecuteTransaction(referralShareTx, dbContext))
{
//if transaction was made, log & update ytd total
await ReferralUtils.UpdateYtdTotal(dbContext, referrer, referralShare);
var referralTx = await ReferralUtils.LogReferralTx(dbContext, referrerUser.UserId, referralShare, "$sub referral share");
subTx.ReferralTxId = referralTx.ReferralTxId;
await dbContext.SaveAsync();
return(true);
}
}
}
return(false);
}
public static void CreateSubscription(BitcornContext dbContext, Subscription sub, params SubscriptionTier[] tiers)
{
dbContext.Subscription.Add(sub);
dbContext.SaveChanges();
foreach (var tier in tiers)
{
tier.SubscriptionId = sub.SubscriptionId;
dbContext.SubscriptionTier.Add(tier);
}
dbContext.SaveChanges();
}
public static async Task <ErrorLogs> LogError(BitcornContext dbContext, Exception e, string code = null)
{
var logEntry = new ErrorLogs();
logEntry.Message = e.Message;
logEntry.Application = "BITCORNService";
logEntry.Code = code;
logEntry.StackTrace = e.StackTrace;
logEntry.Timestamp = DateTime.Now;
dbContext.ErrorLogs.Add(logEntry);
await dbContext.SaveChangesAsync();
return(logEntry);
}
public static async Task ReferralRewards(BitcornContext dbContext, WalletDownload walletDownload, UserReferral userReferral, User referrerUser,
User user, string type)
{
if (user.IsBanned || referrerUser.IsBanned)
{
return;
}
var referrer = await dbContext.Referrer
.FirstOrDefaultAsync(w => w.UserId == walletDownload.ReferralUserId);
userReferral.WalletDownloadDate = DateTime.Now;
if (IsValidReferrer(referrer))
{
var referralPayoutTotal = await ReferralUtils.TotalReward(dbContext, referrer) + await ReferralUtils.WalletBonusReward(dbContext, referrer, 10);;
var referrerReward = await TxUtils.SendFromBitcornhub(referrerUser, referralPayoutTotal, "BITCORNFarms",
type, dbContext);
var referreeReward = await TxUtils.SendFromBitcornhub(user, referrer.Amount + 10, "BITCORNFarms",
type, dbContext);
if (referrerReward && referreeReward)
{
await ReferralUtils.LogReferralTx(dbContext, referrerUser.UserId, referralPayoutTotal,
type);
await ReferralUtils.LogReferralTx(dbContext, user.UserId, referrer.Amount + 10,
$"Recruit {type}");
await ReferralUtils.UpdateYtdTotal(dbContext, referrer, referralPayoutTotal);
if (referrerUser.UserStat.TotalReferralRewardsCorn == null)
{
referrerUser.UserStat.TotalReferralRewardsCorn = 0;
}
if (referrerUser.UserStat.TotalReferralRewardsUsdt == null)
{
referrerUser.UserStat.TotalReferralRewardsUsdt = 0;
}
referrerUser.UserStat.TotalReferralRewardsCorn += referralPayoutTotal;
referrerUser.UserStat.TotalReferralRewardsUsdt +=
((referralPayoutTotal) * (await ProbitApi.GetCornPriceAsync(dbContext)));
userReferral.WalletDownloadDate = DateTime.Now;
await ReferralUtils.BonusPayout(dbContext, userReferral, referrer, user, referrerUser,
referrerUser.UserStat);
}
}
}
/// <summary>
/// This method is used to get the index of the wallet server
/// that new users should get a new BITCORN address on.
/// Servers will be assigned to new users when they register for a
/// wallet address in a round robin fashion.
/// </summary>
/// <returns>(int) The index of the wallet server to create the new address on</returns>
public static async Task <int> GetWalletIndexAsync(BitcornContext dbContext)
{
var count = dbContext.WalletServer.Count();
var currentIndex = dbContext.WalletIndex.FirstOrDefault(x => x.Id == 1);
if (currentIndex != null)
{
currentIndex.Index = (currentIndex.Index + 1) % count;
// TODO: proper logging
await dbContext.SaveAsync();
return(currentIndex.Index.Value);
}
return(1);
}
public static async Task <ReferralTx> LogReferralTx(BitcornContext dbContext, int referrerUserId, decimal amount, string type)
{
var referralTx = new ReferralTx();
referralTx.UserId = referrerUserId;
referralTx.Amount = amount;
referralTx.TimeStamp = DateTime.Now;
referralTx.UsdtPrice = await CornPrice(dbContext);
referralTx.TotalUsdtValue = referralTx.Amount * referralTx.UsdtPrice;
referralTx.Type = type;
dbContext.ReferralTx.Add(referralTx);
await dbContext.SaveAsync();
return(referralTx);
}
public static async Task <BitcornResponse> CreateCornaddy(BitcornContext dbContext, UserWallet userWallet, IConfiguration configuration)
{
var cornResponse = new BitcornResponse();
cornResponse.WalletAvailable = true;
try
{
var index = await GetWalletIndexAsync(dbContext);
var server = await dbContext.GetWalletServer(index);
if (server == null)
{
cornResponse.WalletAvailable = false;
return(cornResponse);
}
//wallet server has been disabled, find the first server that has been enabled
if (!server.Enabled)
{
server = await dbContext.WalletServer.FirstOrDefaultAsync(s => s.Enabled);
//server is still null, return
if (server == null)
{
cornResponse.WalletAvailable = false;
return(cornResponse);
}
}
string accessToken = await GetWalletServerAccessToken(configuration);
//failed to fetch access token
if (!CheckAccessTokenExists(accessToken))
{
throw new UnauthorizedAccessException("Failed to fetch wallet server access token");
}
await CreateCornaddyInternal(cornResponse, dbContext, server, userWallet, accessToken);
}
catch (Exception e)
{
throw e;
}
return(cornResponse);
}
public static SupportedPlatform AllocateController(BitcornContext dbContext, PlatformId platformId, IConfiguration configuration)
{
var registerationControllers = SupportedPlatform.GetSupportedPlatforms();
//try to find registeration controller from mapped out controllers
if (registerationControllers.TryGetValue(platformId.Platform, out Type registerControllerType))
{
//create instance from type
var registerController = (SupportedPlatform)Activator.CreateInstance(registerControllerType);
//setup dependencies
registerController.Setup(dbContext, configuration);
return(registerController);
}
else
{
throw new ArgumentException($"Unsupported platform:{platformId.Platform}");
}
}
static async Task PopuplateUserResponse(BitcornContext dbContext, SubRequest subRequest, SubscriptionResponse output, User user)
{
var selectableUser = new SelectableUser(user);
var columns = await UserReflection.GetColumns(dbContext, subRequest.Columns, new int[] {
selectableUser.UserId
});
if (columns != null && columns.Count > 0)
{
foreach (var column in columns.First().Value)
{
selectableUser.Add(column.Key, column.Value);
}
}
output.User = selectableUser;
}
public static IQueryable <User> JoinUserModels(this BitcornContext dbContext)
{
return(from identity in dbContext.UserIdentity
join wallet in dbContext.UserWallet on identity.UserId equals wallet.UserId
join userStat in dbContext.UserStat on identity.UserId equals userStat.UserId
join user in dbContext.User on identity.UserId equals user.UserId
select new User
{
UserId = user.UserId,
Level = user.Level,
Username = user.Username,
SubTier = user.SubTier,
Avatar = user.Avatar,
IsBanned = user.IsBanned,
UserWallet = wallet,
UserStat = userStat,
UserIdentity = identity,
});
}
