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