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 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 <bool> ExecuteTransaction(this TxProcessInfo processInfo, BitcornContext dbContext) { var sql = new StringBuilder(); if (processInfo.WriteTransactionOutput(sql)) { var rows = await DbOperations.ExecuteSqlRawAsync(dbContext, sql.ToString()); if (rows > 0) { await dbContext.SaveAsync(); try { await OnPostTransaction(processInfo, dbContext); } catch (Exception ex) { await BITCORNLogger.LogError(dbContext, ex, "failed to handle tx callback"); } } return(rows > 0); } return(false); }
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 <CornTx> DebitWithdrawTx(string cornaddy, string txId, User user, WalletServer server, decimal amount, BitcornContext dbContext, string platform, int emptyUser) { if (user.UserWallet.Balance >= amount) { var sql = new StringBuilder(); sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), amount, '-', nameof(UserWallet.UserId), user.UserId)); sql.Append(TxUtils.ModifyNumber(nameof(WalletServer), nameof(WalletServer.ServerBalance), amount, '-', nameof(WalletServer.Id), server.Id)); await DbOperations.ExecuteSqlRawAsync(dbContext, sql.ToString()); var log = new CornTx(); log.BlockchainTxId = txId; log.Amount = amount; log.Timestamp = DateTime.Now; log.TxType = "$withdraw"; log.TxGroupId = Guid.NewGuid().ToString(); log.Platform = platform; log.ReceiverId = emptyUser; log.SenderId = user.UserId; log.CornAddy = cornaddy; var price = log.UsdtPrice = await ProbitApi.GetCornPriceAsync(dbContext); log.TotalUsdtValue = price * amount; dbContext.CornTx.Add(log); await dbContext.SaveAsync(); return(log); } return(null); }
public async Task <ActionResult> Download(WalletDownload walletDownload, DateTime now) { var user = await _dbContext.User.FirstOrDefaultAsync(r => r.UserId == walletDownload.UserId); var userReferral = await _dbContext.UserReferral.FirstOrDefaultAsync(r => r.UserId == walletDownload.UserId); if (userReferral != null && !UserLockCollection.Lock(userReferral.UserId)) { return(StatusCode(UserLockCollection.UserLockedReturnCode)); } try { var downloads = _dbContext.WalletDownload.Where(w => w.TimeStamp.AddDays(7) > now).Where(d => d.IPAddress == walletDownload.IPAddress); if (!downloads.Any() && userReferral != null && (userReferral.ReferralId != 0 && userReferral.WalletDownloadDate == null)) { try { walletDownload.ReferralUserId = _dbContext.Referrer .FirstOrDefault(r => r.ReferralId == Convert.ToInt32(userReferral.ReferralId))?.UserId; walletDownload.ReferralCode = userReferral.ReferralId.ToString(); } catch (Exception e) { throw new Exception($"could not convert referral code: {walletDownload.ReferralCode} to an integer"); } var referrerUser = await _dbContext.JoinUserModels().FirstOrDefaultAsync(u => u.UserId == walletDownload.ReferralUserId); if (referrerUser != null && userReferral != null && userReferral?.WalletDownloadDate == null) { if (!referrerUser.IsBanned && !user.IsBanned) { await ReferralUtils.ReferralRewards(_dbContext, walletDownload, userReferral, referrerUser, user, "Wallet download"); } } } walletDownload.TimeStamp = now; _dbContext.WalletDownload.Add(walletDownload); await _dbContext.SaveAsync(); return(StatusCode((int)HttpStatusCode.OK)); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(walletDownload)); return(StatusCode((int)HttpStatusCode.InternalServerError)); } finally { if (userReferral != null) { UserLockCollection.Release(userReferral.UserId); } } }
public async Task <HttpStatusCode> Post([FromBody] ReferralUpload referralUpload) { var platformId = BitcornUtils.GetPlatformId(referralUpload.UserId); var user = await BitcornUtils.GetUserForPlatform(platformId, _dbContext).FirstOrDefaultAsync(); if (user != null) { if (!_dbContext.Referrer.Any(r => r.UserId == user.UserId)) { try { if (referralUpload == null) { throw new ArgumentNullException(nameof(referralUpload)); } var referrer = new Referrer(); referrer.Amount = 10; referrer.UserId = user.UserId; referrer.Tier = 0; referrer.YtdTotal = 0; referrer.ETag = referralUpload.W9.ETag; referrer.Key = referralUpload.W9.Key; _dbContext.Referrer.Add(referrer); await _dbContext.SaveAsync(); return(HttpStatusCode.OK); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(referralUpload)); throw; } } var referrer1 = await _dbContext.Referrer.FirstOrDefaultAsync(r => r.UserId == user.UserId); referrer1.ETag = referralUpload.W9.ETag; referrer1.Key = referralUpload.W9.Key; await _dbContext.SaveAsync(); return(HttpStatusCode.OK); } return(HttpStatusCode.BadRequest); }
public async Task <ActionResult <FullUser> > CreateCornaddy([FromBody] CreateCornaddyRequest request) { try { if (this.GetCachedUser() != null) { throw new InvalidOperationException(); } if (string.IsNullOrWhiteSpace(request.Id)) { throw new ArgumentNullException("id"); } var platformId = BitcornUtils.GetPlatformId(request.Id); var user = await BitcornUtils.GetUserForPlatform(platformId, _dbContext).FirstOrDefaultAsync(); if (user != null) { var walletResponse = await WalletUtils.CreateCornaddy(_dbContext, user.UserWallet, _configuration); if (!walletResponse.WalletAvailable) { user.UserWallet.CornAddy = "<no enabled wallets found>"; await _dbContext.SaveAsync(); return(StatusCode(200)); //return StatusCode((int)HttpStatusCode.ServiceUnavailable); } return(BitcornUtils.GetFullUser(user, user.UserIdentity, user.UserWallet, user.UserStat)); } else { return(StatusCode(500)); } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(request)); throw e; } }
public async Task <ActionResult <object> > Ban([FromBody] BanUserRequest request) { if (string.IsNullOrWhiteSpace(request.Sender)) { throw new ArgumentNullException("Sender"); } if (string.IsNullOrWhiteSpace(request.BanUser)) { throw new ArgumentNullException("BanUser"); } var senderPlatformId = BitcornUtils.GetPlatformId(request.Sender); var senderUser = await BitcornUtils.GetUserForPlatform(senderPlatformId, _dbContext).FirstOrDefaultAsync(); if (senderUser != null && senderUser.Level == "5000") { var banPlatformId = BitcornUtils.GetPlatformId(request.BanUser); var primaryKey = -1; var banUser = await BitcornUtils.GetUserForPlatform(banPlatformId, _dbContext).FirstOrDefaultAsync(); if (banUser != null) { primaryKey = banUser.UserId; banUser.IsBanned = true; _dbContext.Update(banUser); await _dbContext.SaveAsync(); } var users = await UserReflection.GetColumns(_dbContext, new string[] { "*" }, new[] { primaryKey }); if (users.Count > 0) { return(users.First()); } return(null); } else { return(StatusCode((int)HttpStatusCode.Forbidden)); } }
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); } }
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 virtual async Task OnSyncSuccess(DateTime?socialAccountCreationDate, PlatformId platformId) { await TxUtils.TryClaimTx(platformId, null, _dbContext); var key = $"{platformId.Platform}|{platformId.Id}"; if (!(await _dbContext.SocialIdentity.AnyAsync(s => s.PlatformId == key))) { if (socialAccountCreationDate != null && DateTime.Now > socialAccountCreationDate.Value.AddDays(7)) { await ReferralUtils.UpdateReferralSync(_dbContext, platformId); } _dbContext.SocialIdentity.Add(new SocialIdentity() { PlatformId = key, Timestamp = DateTime.Now }); await _dbContext.SaveAsync(); } }
public static async Task <UserIdentity> DeleteIdForPlatform(UserIdentity userIdentity, PlatformId platformId, BitcornContext dbContext) { switch (platformId.Platform.ToLower()) { case "auth0": userIdentity.Auth0Id = null; await dbContext.SaveAsync(); break; case "twitch": userIdentity.TwitchId = null; await dbContext.SaveAsync(); break; case "discord": userIdentity.DiscordId = null; await dbContext.SaveAsync(); break; case "twitter": userIdentity.TwitterId = null; await dbContext.SaveAsync(); break; case "reddit": userIdentity.RedditId = null; await dbContext.SaveAsync(); break; default: throw new Exception($"User {platformId.Platform}|{platformId.Id} could not be found"); } return(userIdentity); }
/// <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 async Task <bool> Post([FromBody] ErrorLogs data) { try { _dbContext.ErrorLogs.Add(data); await _dbContext.SaveAsync(); return(true); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, null); return(false); } }
public static async Task <(SignedTx, TxReceipt)?> CreateSignedTx(BitcornContext dbContext, User from, decimal amount, string platform, string txType, int?gameId = null) { var bitcornhub = await GetBitcornhub(dbContext); var result = await SendFromGetReceipt(from, bitcornhub, amount, platform, txType, dbContext); if (result != null) { var tx = new SignedTx(); tx.Id = Guid.NewGuid().ToString(); tx.Amount = amount; tx.InCornTxId = result.TxId.Value; tx.SenderUserId = from.UserId; tx.Timestamp = DateTime.Now; tx.TxType = txType; tx.GameInstanceId = gameId; dbContext.SignedTx.Add(tx); await dbContext.SaveAsync(); return(tx, result); } return(null); }
public static async Task RefundUnclaimed(BitcornContext dbContext, int addExpirationMinutes = 60) { var now = DateTime.Now; var txs = await dbContext.UnclaimedTx.Where(t => t.Expiration.AddMinutes(addExpirationMinutes) < now && !t.Claimed && !t.Refunded) .Join(dbContext.UserWallet, tx => tx.SenderUserId, user => user.UserId, (tx, wallet) => new { Tx = tx, Wallet = wallet }) .ToArrayAsync(); if (txs.Length == 0) { return; } var pk = nameof(UserWallet.UserId); var sql = new StringBuilder(); foreach (var entry in txs) { entry.Tx.Refunded = true; sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), entry.Tx.Amount, '+', pk, entry.Wallet.UserId)); } await DbOperations.ExecuteSqlRawAsync(dbContext, sql.ToString()); await dbContext.SaveAsync(); }
static async Task CreateCornaddyInternal(BitcornResponse cornResponse, BitcornContext dbContext, WalletServer walletServer, UserWallet userWallet, string accessToken) { using (var client = new WalletClient(walletServer.Endpoint, accessToken)) { var response = await client.GetNewAddressAsync("main"); if (!response.IsError) { var address = response.GetParsedContent(); userWallet.CornAddy = address; userWallet.WalletServer = walletServer.Index; cornResponse.WalletObject = address; await dbContext.SaveAsync(); } //we got an error, fetch the internal wallet error code and figure out what to do else { //get wallet error response //var error = response.GetError(); cornResponse.WalletAvailable = false; } } }
public static async Task <CornTx> DebitWithdrawTx(string txId, User user, WalletServer server, decimal amount, BitcornContext dbContext, string platform) { if (user.UserWallet.Balance >= amount) { var sql = new StringBuilder(); sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), amount, '-', nameof(UserWallet.UserId), user.UserId)); sql.Append(TxUtils.ModifyNumber(nameof(WalletServer), nameof(WalletServer.ServerBalance), amount, '-', nameof(WalletServer.Id), server.Id)); await dbContext.Database.ExecuteSqlRawAsync(sql.ToString()); var log = new CornTx(); log.BlockchainTxId = txId; log.Amount = amount; log.Timestamp = DateTime.Now; log.TxType = "$withdraw"; log.TxGroupId = Guid.NewGuid().ToString(); log.Platform = platform; log.ReceiverId = user.UserId; dbContext.CornTx.Add(log); await dbContext.SaveAsync(); return(log); } return(null); }
public async Task <FullUser> RegisterNewUser([FromBody] Auth0User auth0User) { if (auth0User == null) { throw new ArgumentNullException(); } var existingUserIdentity = await _dbContext.Auth0Query(auth0User.Auth0Id).Select(u => u.UserIdentity).FirstOrDefaultAsync(); if (existingUserIdentity?.Auth0Id == auth0User.Auth0Id) { var user = _dbContext.User.FirstOrDefault(u => u.UserId == existingUserIdentity.UserId); var userWallet = _dbContext.UserWallet.FirstOrDefault(u => u.UserId == existingUserIdentity.UserId); var userStat = _dbContext.UserStat.FirstOrDefault(u => u.UserId == existingUserIdentity.UserId); return(BitcornUtils.GetFullUser(user, existingUserIdentity, userWallet, userStat)); } try { var user = new User { UserIdentity = new UserIdentity { Auth0Id = auth0User.Auth0Id, Auth0Nickname = auth0User.Auth0Nickname }, UserWallet = new UserWallet(), UserStat = new UserStat() }; _dbContext.User.Add(user); await _dbContext.SaveAsync(); return(BitcornUtils.GetFullUser(user, user.UserIdentity, user.UserWallet, user.UserStat)); } catch (Exception e) { Console.WriteLine(e); throw; } }
public static async Task <CornTx[]> Deposit(BitcornContext dbContext, WalletDepositRequest request) { var receipts = new List <CornTx>(); try { var server = dbContext.WalletServer.FirstOrDefault((s) => s.Index == request.Index); int newDeposits = 0; var sql = new StringBuilder(); foreach (var payment in request.Payments) { decimal amount = payment.Amount; string address = payment.Address; string txid = payment.TxId; bool isLogged = await dbContext.IsDepositRegistered(txid); if (!isLogged) { newDeposits++; var wallet = await dbContext.WalletByAddress(address); if (wallet != null) { var cornTx = new CornTx(); cornTx.Amount = amount; cornTx.BlockchainTxId = txid; cornTx.ReceiverId = wallet.UserId; cornTx.SenderId = null; cornTx.Timestamp = DateTime.Now; cornTx.TxType = TransactionType.receive.ToString(); cornTx.Platform = "wallet-server"; cornTx.TxGroupId = Guid.NewGuid().ToString(); var deposit = new CornDeposit(); deposit.TxId = txid; deposit.UserId = wallet.UserId; sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), amount, '+', nameof(UserWallet.UserId), wallet.UserId)); sql.Append(TxUtils.ModifyNumber(nameof(WalletServer), nameof(WalletServer.ServerBalance), amount, '+', nameof(WalletServer.Id), server.Id)); dbContext.CornTx.Add(cornTx); dbContext.CornDeposit.Add(deposit); receipts.Add(cornTx); } } } if (newDeposits > 0) { server.LastBalanceUpdateBlock = request.Block; int count = await dbContext.Database.ExecuteSqlRawAsync(sql.ToString()); await dbContext.SaveAsync(); } } catch (Exception e) { await BITCORNLogger.LogError(dbContext, e); } return(receipts.ToArray()); }
public async Task <ActionResult <TxReceipt[]> > Rain([FromBody] RainRequest rainRequest) { try { if (rainRequest == null) { throw new ArgumentNullException(); } if (rainRequest.From == null) { throw new ArgumentNullException(); } if (rainRequest.To == null) { throw new ArgumentNullException(); } if (rainRequest.Amount <= 0) { return(StatusCode((int)HttpStatusCode.BadRequest)); } var processInfo = await TxUtils.ProcessRequest(rainRequest, _dbContext); var transactions = processInfo.Transactions; if (transactions != null && transactions.Length > 0) { StringBuilder sql = new StringBuilder(); if (processInfo.WriteTransactionOutput(sql)) { string pk = nameof(UserStat.UserId); string table = nameof(UserStat); var recipients = processInfo.ValidRecipients; var fromId = transactions[0].From.UserId; var recipientStats = new List <ColumnValuePair>(); recipientStats.Add(new ColumnValuePair(nameof(UserStat.RainedOn), 1)); recipientStats.Add(new ColumnValuePair(nameof(UserStat.RainedOnTotal), rainRequest.Amount)); sql.Append(TxUtils.ModifyNumbers(table, recipientStats, '+', pk, recipients)); sql.Append(TxUtils.UpdateNumberIfTop(table, nameof(UserStat.TopRainedOn), rainRequest.Amount, pk, recipients)); var senderStats = new List <ColumnValuePair>(); senderStats.Add(new ColumnValuePair(nameof(UserStat.Rained), 1)); senderStats.Add(new ColumnValuePair(nameof(UserStat.RainTotal), processInfo.TotalAmount)); sql.Append(TxUtils.ModifyNumbers(table, senderStats, '+', pk, fromId)); sql.Append(TxUtils.UpdateNumberIfTop(table, nameof(UserStat.TopRain), processInfo.TotalAmount, pk, fromId)); await _dbContext.Database.ExecuteSqlRawAsync(sql.ToString()); await _dbContext.SaveAsync(IsolationLevel.RepeatableRead); } await TxUtils.AppendTxs(transactions, _dbContext, rainRequest.Columns); } return(processInfo.Transactions); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); throw e; } }
public static async Task UpdateReferralSync(BitcornContext dbContext, PlatformId platformId) { var user = BitcornUtils.GetUserForPlatform(platformId, dbContext).FirstOrDefault(); try { if (user != null && user.UserId != 0) { if (user.IsBanned) { return; } if (!UserLockCollection.Lock(user.UserId)) { throw new Exception("User is locked"); } var userReferral = await dbContext.UserReferral.FirstOrDefaultAsync(u => u.UserId == user.UserId); if (userReferral != null && userReferral.SyncDate == null) { var referrer = await dbContext.Referrer.FirstOrDefaultAsync(r => r.ReferralId == userReferral.ReferralId); if (referrer != null && (referrer.YtdTotal < 600 || (referrer.ETag != null && referrer.Key != null))) { var referralPayoutTotal = await ReferralUtils.TotalReward(dbContext, referrer); var referrerUser = await dbContext.User.FirstOrDefaultAsync(u => u.UserId == referrer.UserId); if (referrerUser.IsBanned) { if (user != null) { UserLockCollection.Release(user.UserId); } return; } var referreeReward = await TxUtils.SendFromBitcornhub(user, referrer.Amount, "BITCORNfarms", "Recruit social sync", dbContext); var referrerReward = await TxUtils.SendFromBitcornhub(referrerUser, referralPayoutTotal, "BITCORNfarms", "Social sync", dbContext); if (referrerReward && referreeReward) { userReferral.SyncDate = DateTime.Now; await UpdateYtdTotal(dbContext, referrer, referralPayoutTotal); await LogReferralTx(dbContext, referrer.UserId, referralPayoutTotal, "Social Sync"); await LogReferralTx(dbContext, user.UserId, referralPayoutTotal, "Recruit social Sync"); var userStat = await dbContext.UserStat.FirstOrDefaultAsync(s => s.UserId == referrer.UserId); userStat.TotalReferralRewardsCorn += referralPayoutTotal; userStat.TotalReferralRewardsUsdt += (referralPayoutTotal * (await ProbitApi.GetCornPriceAsync(dbContext))); await ReferralUtils.BonusPayout(dbContext, userReferral, referrer, user, referrerUser, userStat); } } } await dbContext.SaveAsync(); } } catch (Exception e) { await BITCORNLogger.LogError(dbContext, e, null); throw; } finally { if (user != null) { UserLockCollection.Release(user.UserId); } } }
public static async Task UpdateYtdTotal(BitcornContext dbContext, Referrer referrer, decimal amount) { referrer.YtdTotal += (amount * (await ProbitApi.GetCornPriceAsync(dbContext))); await dbContext.SaveAsync(); }
public async Task Post([FromBody] ErrorLogs errorLogs) { _dbContext.ErrorLogs.Add(errorLogs); await _dbContext.SaveAsync(); }
public static async Task <int> TryClaimTx(PlatformId platformId, User user, BitcornContext dbContext) { if (user == null) { user = await BitcornUtils.GetUserForPlatform(platformId, dbContext).FirstOrDefaultAsync(); } if (user == null) { return(0); } bool lockApplied = false; try { if (UserLockCollection.Lock(user)) { lockApplied = true; } else { return(0); } var now = DateTime.Now; var txs = await dbContext.UnclaimedTx.Where(u => u.Platform == platformId.Platform && u.ReceiverPlatformId == platformId.Id && !u.Claimed && !u.Refunded && u.Expiration > now).ToArrayAsync(); var sql = new StringBuilder(); var pk = nameof(UserWallet.UserId); foreach (var tx in txs) { tx.Claimed = true; var log = new CornTx(); log.Amount = tx.Amount; log.Platform = tx.Platform; log.ReceiverId = user.UserId; log.SenderId = tx.SenderUserId; log.Timestamp = tx.Timestamp; log.TxGroupId = Guid.NewGuid().ToString(); log.TxType = tx.TxType; log.UnclaimedTx.Add(tx); dbContext.CornTx.Add(log); sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), tx.Amount, '+', pk, user.UserId)); sql.Append(TxUtils.ModifyNumber(nameof(UserStat), nameof(UserStat.AmountOfTipsReceived), 1, '+', pk, user.UserId)); sql.Append(TxUtils.ModifyNumber(nameof(UserStat), nameof(UserStat.TotalReceivedBitcornTips), tx.Amount, '+', pk, user.UserId)); sql.Append(TxUtils.UpdateNumberIfTop(nameof(UserStat), nameof(UserStat.LargestReceivedBitcornTip), tx.Amount, pk, user.UserId)); sql.Append(TxUtils.ModifyNumber(nameof(UserStat), nameof(UserStat.AmountOfTipsSent), 1, '+', pk, tx.SenderUserId)); sql.Append(TxUtils.ModifyNumber(nameof(UserStat), nameof(UserStat.TotalSentBitcornViaTips), tx.Amount, '+', pk, tx.SenderUserId)); sql.Append(TxUtils.UpdateNumberIfTop(nameof(UserStat), nameof(UserStat.LargestSentBitcornTip), tx.Amount, pk, tx.SenderUserId)); } if (txs.Length > 0) { await DbOperations.ExecuteSqlRawAsync(dbContext, sql.ToString()); await dbContext.SaveAsync(); } return(txs.Length); } catch (Exception e) { await BITCORNLogger.LogError(dbContext, e, JsonConvert.SerializeObject(platformId)); return(0); } finally { if (lockApplied) { UserLockCollection.Release(user); } } }
private static async Task <SubscriptionResponse> ProcessSubscription(BitcornContext dbContext, SubscriptionResponse output, SubRequest subRequest, Subscription subInfo, SubscriptionTier requestedTierInfo, User user) { decimal cost = 0; //if tier usdt cost has been initialized, the corn cost has to be calculated if (requestedTierInfo.CostUsdt != null && requestedTierInfo.CostUsdt > 0) { cost = await CalculateUsdtToCornCost(dbContext, requestedTierInfo); } // check if cost is initialized properly else if (requestedTierInfo.CostCorn != null && requestedTierInfo.CostCorn > 0) { cost = requestedTierInfo.CostCorn.Value; } else { throw new ArgumentException($"Invalid cost setting on subscription tier id:{requestedTierInfo.SubscriptionId}"); } //set the amount that will be removed from subscriber to the response object output.Cost = cost; //initialize array of existing subscriptions UserSubcriptionTierInfo[] existingSubscriptions = new UserSubcriptionTierInfo[0]; if (user != null) { //set data to existing subscriptions array existingSubscriptions = await GetUserSubscriptions(dbContext, user) .Where(t => t.SubscriptionTier.SubscriptionId == subInfo.SubscriptionId).ToArrayAsync(); } //initialize reference to existing subtierinfo UserSubcriptionTierInfo existingSubscription = null; //initialize current substate var subState = SubscriptionState.None; //if any subscriptions were found if (existingSubscriptions.Any()) { //set existing subtierinfo existingSubscription = existingSubscriptions[0]; //if sub has expired, set substate to expired if (subInfo.HasExpired(existingSubscription.UserSubscription)) { subState = SubscriptionState.Expired; } //if existing sub has not expired, but the tier is below, set subState to TierDown else if (existingSubscription.SubscriptionTier.Tier < requestedTierInfo.Tier) { subState = SubscriptionState.TierDown; } //else, the user is subscribed else { subState = SubscriptionState.Subscribed; } } //initialize reference to usersubscription & tx request UserSubscription sub = null; TxRequest txRequest = null; //if current user sub state is not subscribed & the client confirmed the cost to be equal to the cost amount, attempt to subscribe var costDiff = Math.Abs(subRequest.Amount - cost); if (subState != SubscriptionState.Subscribed && costDiff <= 100000)//subRequest.Amount == cost) { //initialize recipient of the transaction string[] to = new string[1]; //default to bitcornhub if no subscription owner has been set int recipientId = TxUtils.BitcornHubPK; //if subscription owner is set, overwrite bitcornhub if (subInfo.OwnerUserId != null && subInfo.OwnerUserId > 0) { recipientId = subInfo.OwnerUserId.Value; } to[0] = $"userid|{recipientId}"; //initialize tx request txRequest = new TxRequest(user, cost, subRequest.Platform, "$sub", to); //prepare transaction for saving var processInfo = await TxUtils.ProcessRequest(txRequest, dbContext); var transactions = processInfo.Transactions; if (transactions != null && transactions.Length > 0) { StringBuilder sql = new StringBuilder(); //check if transaction can be executed if (processInfo.WriteTransactionOutput(sql)) { //transaction is ready to be saved switch (subState) { case SubscriptionState.None: //user was previously not subscribed, create instance of usersubscription and point it to the user sub = new UserSubscription(); sub.SubscriptionId = subInfo.SubscriptionId; sub.SubscriptionTierId = requestedTierInfo.SubscriptionTierId; sub.UserId = user.UserId; sub.FirstSubDate = DateTime.Now; sub.SubCount = 1; dbContext.UserSubscription.Add(sub); break; case SubscriptionState.TierDown: case SubscriptionState.Expired: //previous subscription was found, update subscription tier existingSubscription.UserSubscription.SubscriptionTierId = requestedTierInfo.SubscriptionTierId; existingSubscription.UserSubscription.SubCount += 1; sub = existingSubscription.UserSubscription; break; default: break; } //set subscription date to now sub.LastSubDate = DateTime.Now; await DbOperations.ExecuteSqlRawAsync(dbContext, sql.ToString()); await dbContext.SaveAsync(IsolationLevel.RepeatableRead); //create subtx that will link user, corntx and usersubscription together var subTx = new SubTx(); subTx.UserId = user.UserId; subTx.SubTxId = transactions[0].TxId.Value; subTx.UserSubscriptionId = sub.UserSubscriptionId; dbContext.SubTx.Add(subTx); //if user was not subscribed before, attempt to share the payment with a referrer if (!await TrySharePaymentWithReferrer(dbContext, output, subRequest, subInfo, requestedTierInfo, user, recipientId, cost, subState, subTx)) { await dbContext.SaveAsync(); } subState = SubscriptionState.Subscribed; } //append receipt object with what client requested await TxUtils.AppendTxs(transactions, dbContext, subRequest.Columns); var tx = transactions[0]; output.TxId = tx.TxId; output.User = tx.From; } } //couldn't process transaction if (txRequest == null) { //fill out response object await PopuplateUserResponse(dbContext, subRequest, output, user); if (existingSubscription != null) { sub = existingSubscription.UserSubscription; } } if (subState == SubscriptionState.Subscribed && sub != null) { var end = output.SubscriptionEndTime = sub.LastSubDate.Value.AddDays(subInfo.Duration); //calculate days left output.DaysLeft = Math.Ceiling((end.Value - DateTime.Now).TotalDays); //setup sub info output.UserSubscriptionInfo = await GetUserSubscriptions(dbContext, user) .Where(t => t.SubscriptionTier.SubscriptionId == subInfo.SubscriptionId).FirstOrDefaultAsync(); } return(output); }
public async Task <ActionResult <FullUser> > RegisterNewUser([FromBody] Auth0User auth0User, [FromQuery] string referral = null) { if (this.GetCachedUser() != null) { throw new InvalidOperationException(); } if (auth0User == null) { throw new ArgumentNullException(); } if (!StaticLockCollection.Lock(auth0User.Auth0Id)) { return(StatusCode(UserLockCollection.UserLockedReturnCode)); } var existingUserIdentity = await _dbContext.Auth0Query(auth0User.Auth0Id).Select(u => u.UserIdentity).FirstOrDefaultAsync(); if (existingUserIdentity?.Auth0Id == auth0User.Auth0Id) { var user = _dbContext.User.FirstOrDefault(u => u.UserId == existingUserIdentity.UserId); var userWallet = _dbContext.UserWallet.FirstOrDefault(u => u.UserId == existingUserIdentity.UserId); var userStat = _dbContext.UserStat.FirstOrDefault(u => u.UserId == existingUserIdentity.UserId); StaticLockCollection.Release(auth0User.Auth0Id); return(BitcornUtils.GetFullUser(user, existingUserIdentity, userWallet, userStat)); } int referralId; try { referralId = Convert.ToInt32(referral); } catch (Exception e) { referralId = 0; } try { var user = CreateUser(auth0User, referralId); _dbContext.User.Add(user); if (referral != null && referralId != 0) { var referrer = await _dbContext.Referrer.FirstOrDefaultAsync(r => r.ReferralId == referralId); if (ReferralUtils.IsValidReferrer(referrer)) { var referrerUser = await _dbContext.User.FirstOrDefaultAsync(u => u.UserId == referrer.UserId); if (referrerUser != null && !referrerUser.IsBanned) { var referralPayoutTotal = await ReferralUtils.TotalReward(_dbContext, referrer); var referrerRegistrationReward = await TxUtils.SendFromBitcornhub(referrerUser, referralPayoutTotal, "BITCORNFarms", "Registrations reward", _dbContext); var userRegistrationReward = await TxUtils.SendFromBitcornhub(user, referrer.Amount, "BITCORNFarms", "Recruit registrations reward", _dbContext); if (referrerRegistrationReward && userRegistrationReward) { await ReferralUtils.UpdateYtdTotal(_dbContext, referrer, referralPayoutTotal); await ReferralUtils.LogReferralTx(_dbContext, referrer.UserId, referralPayoutTotal, "Registration reward"); await ReferralUtils.LogReferralTx(_dbContext, user.UserId, referrer.Amount, "Recruit registration reward"); var referrerStat = await _dbContext.UserStat.FirstOrDefaultAsync(s => s.UserId == referrer.UserId); if (referrerStat != null) { if (referrerStat.TotalReferrals == null) { referrerStat.TotalReferrals = 0; } referrerStat.TotalReferrals++; if (referrerStat.TotalReferralRewardsCorn == null) { referrerStat.TotalReferralRewardsCorn = 0; } referrerStat.TotalReferralRewardsCorn += referralPayoutTotal; if (referrerStat.TotalReferralRewardsUsdt == null) { referrerStat.TotalReferralRewardsUsdt = 0; } referrerStat.TotalReferralRewardsUsdt += (referralPayoutTotal * (await ProbitApi.GetCornPriceAsync(_dbContext))); } user.UserReferral.SignupReward = DateTime.Now; } } } } await _dbContext.SaveAsync(); return(BitcornUtils.GetFullUser(user, user.UserIdentity, user.UserWallet, user.UserStat)); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(auth0User)); throw e; } finally { StaticLockCollection.Release(auth0User.Auth0Id); } }
/// <summary> /// reads stored order by id /// </summary> public async Task <ActionResult <object> > ReadOrder([FromBody] ReadOrderRequest orderRequest) { try { var user = (this.GetCachedUser()); if (this.GetUserMode() != null && this.GetUserMode() == 1) { throw new NotImplementedException(); } if (user != null && user.IsBanned) { return(StatusCode((int)HttpStatusCode.Forbidden)); } var checkOrder = await GetOrder(orderRequest.OrderId); if (checkOrder == null) { return(StatusCode((int)HttpStatusCode.NotFound)); } var(order, client) = checkOrder.Value; if (client.ClientId != orderRequest.ClientId) { return(StatusCode(400)); } if (order.OrderState != 0) { return(StatusCode((int)HttpStatusCode.Gone)); } if (order.ReadBy != user.UserId) { order.ReadBy = user.UserId; await _dbContext.SaveAsync(); } var orderItems = await _dbContext.OrderItem.Where(e => e.OrderId == order.OrderId).ToArrayAsync(); if (orderItems.Length > client.OrderMaxSize) { return(StatusCode((int)HttpStatusCode.NotAcceptable)); } if (orderItems.Sum(e => e.CornAmount) > client.OrderMaxCost) { return(StatusCode((int)HttpStatusCode.NotAcceptable)); } var cornPrice = await ProbitApi.GetCornPriceAsync(_dbContext); var cornOrderSum = orderItems.Select(e => e.CornAmount).Sum(); var cornCurrentSum = orderItems.Select(e => e.UsdAmount / cornPrice).Sum(); var costDiff = Math.Abs(cornCurrentSum - cornOrderSum); if (costDiff > client.AcceptedCostDiff) { foreach (var orderItem in orderItems) { orderItem.CornAmount = orderItem.UsdAmount / cornPrice; } await _dbContext.SaveAsync(); /*var cornAmount = usdAmount / cornPrice; * orderItem.CornAmount = cornAmount;*/ } var username = user.Username; if (string.IsNullOrEmpty(username)) { username = user.UserIdentity.Auth0Nickname; } return(new { orderInfo = new OrderOutput(order, client, orderItems), cornPrice, totalCornPrice = orderItems.Select(e => e.CornAmount).Sum(), totalUsdPrice = orderItems.Select(e => e.UsdAmount).Sum(), userName = username, balance = user.UserWallet.Balance }); } catch (Exception e) { Console.WriteLine(e); throw e; } }