public async Task <ActionResult> Deposit([FromBody] WalletDepositRequest request) { try { var receipts = await WalletUtils.Deposit(_dbContext, request); foreach (var receipt in receipts) { var identity = await _dbContext.UserIdentity.FirstOrDefaultAsync(u => u.UserId == receipt.ReceiverId); await BitcornUtils.TxTracking(_configuration, new { txid = receipt.BlockchainTxId, time = DateTime.Now, method = "deposit", platform = "wallet-server", amount = receipt.Amount, userid = receipt.ReceiverId, twitchUsername = identity.TwitchUsername, discordUsername = identity.DiscordUsername }); } return(Ok()); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); throw e; } }
public async Task <ActionResult <FullUser> > CreateCornaddy([FromBody] CreateCornaddyRequest request) { try { 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) { 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); throw e; } }
public async Task <ActionResult <SubscriptionResponse> > New([FromBody] SubRequest subRequest) { var platformId = BitcornUtils.GetPlatformId(subRequest.Id); var user = await BitcornUtils.GetUserForPlatform(platformId, _dbContext).FirstOrDefaultAsync(); if (user != null && UserLockCollection.Lock(user.UserId)) { try { subRequest.Platform = platformId.Platform; var tx = await SubscriptionUtils.Subscribe(_dbContext, user, subRequest); if (tx != null) { return(tx); } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(subRequest)); throw e; } finally { UserLockCollection.Release(user.UserId); } } return(StatusCode((int)HttpStatusCode.BadRequest)); }
public async Task <ActionResult <object> > GetUserSubscriptions([FromRoute] string platformId, [FromRoute] string subscriptionName = null) { if (string.IsNullOrEmpty(platformId)) { throw new ArgumentException("platformId"); } try { var id = BitcornUtils.GetPlatformId(platformId); var user = await BitcornUtils.GetUserForPlatform(id, _dbContext).FirstOrDefaultAsync(); if (user != null) { var now = DateTime.Now; var subscriptionsQuery = SubscriptionUtils.GetUserSubscriptions(_dbContext, user) .Join(_dbContext.Subscription, (UserSubcriptionTierInfo info) => info.SubscriptionTier.SubscriptionId, (Subscription sub) => sub.SubscriptionId, (info, sub) => new { userInfo = info, subscriptionInfo = sub }).Where(s => s.userInfo.UserSubscription.LastSubDate.Value.AddDays(s.subscriptionInfo.Duration) > now); if (string.IsNullOrEmpty(subscriptionName) || subscriptionName == "*") { return(await subscriptionsQuery.Select(s => new { daysLeft = (s.userInfo.UserSubscription.LastSubDate.Value.AddDays(s.subscriptionInfo.Duration) - now).TotalDays, tier = s.userInfo.SubscriptionTier.Tier, name = s.subscriptionInfo.Name, description = s.subscriptionInfo.Description, lastSubDate = s.userInfo.UserSubscription.LastSubDate }).ToArrayAsync()); } else { return(await subscriptionsQuery.Where(q => q.subscriptionInfo.Name.ToLower() == subscriptionName.ToLower()).Select(s => new { daysLeft = (s.userInfo.UserSubscription.LastSubDate.Value.AddDays(s.subscriptionInfo.Duration) - now).TotalDays, tier = s.userInfo.SubscriptionTier.Tier, name = s.subscriptionInfo.Name, description = s.subscriptionInfo.Description, lastSubDate = s.userInfo.UserSubscription.LastSubDate }).ToArrayAsync()); } } else { return(StatusCode(404)); } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(new { platformId, subscriptionName })); throw e; } }
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 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 <int> Payout([FromBody] HashSet <string> chatters) { try { var grouping = (await _dbContext.JoinUserModels().Where(u => chatters.Contains(u.UserIdentity.TwitchId)) .AsNoTracking() .ToArrayAsync()).GroupBy(u => u.SubTier).ToArray(); decimal total = 0; int changedRows = 0; StringBuilder sql = new StringBuilder(); var pk = nameof(UserWallet.UserId); foreach (var group in grouping) { decimal payout = 0; var level = group.Key; if (level == 0) { continue; } var ids = group.Select(u => u.UserId).ToArray(); if (level == 1) { payout = 0.25m; } else if (level == 2) { payout = .5m; } else { payout = 1; } sql.Append(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), payout, '+', pk, ids)); sql.Append(TxUtils.ModifyNumber(nameof(UserStat), nameof(UserStat.EarnedIdle), payout, '+', pk, ids)); int count = await _dbContext.Database.ExecuteSqlRawAsync(sql.ToString()); total += payout * count; changedRows += count; } if (changedRows > 0) { await _dbContext.Database.ExecuteSqlRawAsync(TxUtils.ModifyNumber(nameof(UserWallet), nameof(UserWallet.Balance), total, '-', pk, BitcornHubPK)); } //this endpoint is called frequently so can use this to check if there are tx's that need to be refunded await TxUtils.RefundUnclaimed(_dbContext); return(changedRows / 2); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); throw e; } }
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 async Task SocketReceiverHandler <T>(WebSocket webSocket, string args) where T : SocketReceiver, new() { var buffer = new byte[1024 * 4]; //var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None); var receiver = new T(); receiver.InitDb(_dbContext); receiver.Start(webSocket, args); await receiver.PostStart(webSocket); while (!webSocket.CloseStatus.HasValue) { try { var receiveArr = new ArraySegment <byte>(buffer); //var serverMsg = Encoding.UTF8.GetBytes($"Server: Hello. You said: {Encoding.UTF8.GetString(buffer)}"); //await webSocket.SendAsync(new ArraySegment<byte>(serverMsg), result.MessageType, result.EndOfMessage, CancellationToken.None); var result = await webSocket.ReceiveAsync(receiveArr, CancellationToken.None); if (result.Count != 0 || result.CloseStatus == WebSocketCloseStatus.Empty) { string message = Encoding.UTF8.GetString(receiveArr.Array, receiveArr.Offset, result.Count); await receiver.Process(webSocket, message); } } catch (WebSocketException ex) { break; } catch (Exception ex) { await BITCORNLogger.LogError(_dbContext, ex, "web socket error "); } } try { if (webSocket.State == WebSocketState.Open) { await webSocket.CloseAsync(WebSocketCloseStatus.Empty, null, CancellationToken.None); } } catch (Exception ex) { await BITCORNLogger.LogError(_dbContext, ex, "failed to close socket"); } receiver.OnClose(); }
public override async Task <PlatformSyncResponse> SyncPlatform(RegistrationData registrationData, User auth0DbUser, PlatformId platformId, string auth0Id) { try { var twitterUser = await TwitterApi.GetTwitterUser(_configuration, platformId.Id); var twitterDbUser = await _dbContext.TwitterQuery(platformId.Id).FirstOrDefaultAsync(); var creationTime = twitterUser.GetCreatedTime(); if (twitterDbUser != null && twitterDbUser.UserIdentity.Auth0Id == null) { auth0DbUser.UserIdentity.TwitterId = twitterDbUser.UserIdentity.TwitterId; //_dbContext.UserIdentity.Remove(auth0DbUser); MigrateOldIdentity(auth0DbUser.UserIdentity, twitterDbUser.UserIdentity); twitterDbUser.UserIdentity.Auth0Id = auth0Id; twitterDbUser.UserIdentity.TwitterUsername = twitterUser.ScreenName; twitterDbUser.UserIdentity.Auth0Nickname = auth0DbUser.UserIdentity.Auth0Nickname; await MigrateOldProfile(auth0DbUser, twitterDbUser); return(GetSyncOutput(creationTime, twitterDbUser, true)); } if (twitterDbUser == null && auth0DbUser != null) { auth0DbUser.UserIdentity.TwitterId = platformId.Id; auth0DbUser.UserIdentity.TwitterUsername = twitterUser.ScreenName; await _dbContext.SaveAsync(); return(GetSyncOutput(creationTime, auth0DbUser, false)); } if (twitterDbUser?.UserIdentity.Auth0Id != null) { var obj = GetSyncOutput(creationTime, twitterDbUser, false); obj.ProfileAlreadySynced = true; return(obj); /* * var e = new Exception($"Auth0Id already exists for user {platformId.Id}"); * await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(registrationData)); * throw e; */ } var ex = new Exception($"Failed to register twitter id for user {platformId.Id} {auth0Id}"); await BITCORNLogger.LogError(_dbContext, ex, JsonConvert.SerializeObject(registrationData)); throw ex; } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(registrationData)); throw e; } throw new Exception($"HOW THE F**K DID YOU GET HERE"); }
public override async Task <PlatformSyncResponse> SyncPlatform(RegistrationData registrationData, User auth0DbUser, PlatformId platformId, string auth0Id) { try { var redditDbUser = await _dbContext.RedditQuery(platformId.Id).FirstOrDefaultAsync(); if (redditDbUser != null && redditDbUser.UserIdentity.Auth0Id == null) { auth0DbUser.UserIdentity.RedditId = redditDbUser.UserIdentity.RedditId; MigrateOldIdentity(auth0DbUser.UserIdentity, redditDbUser.UserIdentity); //_dbContext.UserIdentity.Remove(auth0DbUser); redditDbUser.UserIdentity.Auth0Id = auth0Id; redditDbUser.UserIdentity.Auth0Nickname = auth0DbUser.UserIdentity.Auth0Nickname; await MigrateOldProfile(auth0DbUser, redditDbUser); return(GetSyncOutput(redditDbUser, true)); } else if (redditDbUser == null && auth0DbUser != null) { auth0DbUser.UserIdentity.RedditId = platformId.Id; await _dbContext.SaveAsync(); return(GetSyncOutput(auth0DbUser, false)); } else if (redditDbUser?.UserIdentity.Auth0Id != null) { var obj = GetSyncOutput(DateTime.Now, redditDbUser, false); obj.ProfileAlreadySynced = true; return(obj); /* * var e = new Exception($"Auth0Id already exists for user {platformId.Id}"); * await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(registrationData)); * throw e; */ } else { var e = new Exception($"Failed to register reddit id for user {platformId.Id} {platformId.Id}"); await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(registrationData)); throw e; } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(registrationData)); throw e; } throw new Exception($"HOW THE F**K DID YOU GET HERE"); }
public async Task <object> Withdraw([FromBody] WithdrawRequest request) { try { var platformId = BitcornUtils.GetPlatformId(request.Id); var user = await BitcornUtils.GetUserForPlatform(platformId, _dbContext).FirstOrDefaultAsync(); var response = new Dictionary <string, object>(); if (user != null) { var withdrawResult = await WalletUtils.Withdraw(_dbContext, _configuration, user, request.CornAddy, request.Amount, platformId.Platform); response.Add("usererror", withdrawResult.UserError); response.Add("walletavailable", withdrawResult.WalletAvailable); response.Add("txid", withdrawResult.WalletObject); if (request.Columns.Length > 0) { var columns = await UserReflection.GetColumns(_dbContext, request.Columns, new int[] { user.UserId }); if (columns.Count > 0) { foreach (var item in columns.First().Value) { response.Add(item.Key, item.Value); } } } if (withdrawResult.WalletObject != null && request.Amount > 100000) { await BitcornUtils.TxTracking(_configuration, new { txid = withdrawResult.WalletObject, time = DateTime.Now, method = "withdraw", platform = platformId.Platform, amount = request.Amount, userid = user.UserId, twitchUsername = user.UserIdentity.TwitchUsername, discordUsername = user.UserIdentity.DiscordUsername, cornaddy = request.CornAddy, }); } } return(response); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); throw e; } }
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next) { User user = await CacheUserAttribute.ReadUser(_config, _dbContext, context); ; try { await next(); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, null); } }
public async Task <HttpStatusCode> UpdateSubs() { try { var krak = new Kraken(_config, _dbContext); await krak.Nachos(); return(HttpStatusCode.OK); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); return(HttpStatusCode.InternalServerError); } }
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 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 <bool> > IsSubbed([FromRoute] string platformId, [FromRoute] string subscriptionName, [FromQuery] string subTier = null) { if (string.IsNullOrEmpty(platformId)) { throw new ArgumentException("platformId"); } if (string.IsNullOrEmpty(subscriptionName)) { throw new ArgumentException("subscriptionName"); } try { var id = BitcornUtils.GetPlatformId(platformId); var user = await BitcornUtils.GetUserForPlatform(id, _dbContext).FirstOrDefaultAsync(); if (user != null) { int?tier = null; if (!string.IsNullOrEmpty(subTier)) { try { tier = int.Parse(subTier); } catch { } } return(await SubscriptionUtils.HasSubscribed(_dbContext, user, subscriptionName, tier)); } else { return(StatusCode(404)); } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(new { subTier, platformId, subscriptionName })); throw e; } }
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; } }
/// <summary> /// called from client server to create an order tht the user will authorize /// </summary> public async Task <ActionResult <OrderOutput> > CreateOrder([FromBody] CreateOrderRequest orderRequest) { try { var appId = this.GetAppId(_configuration); if (string.IsNullOrEmpty(appId)) { return(StatusCode((int)HttpStatusCode.BadRequest)); } if (appId != orderRequest.ClientId) { await BITCORNLogger.LogError(_dbContext, new Exception("Unauthorized app request " + appId + " - " + orderRequest.ClientId), JsonConvert.SerializeObject(orderRequest)); return(StatusCode(401)); } var client = await _dbContext.ThirdPartyClient.FirstOrDefaultAsync((e) => e.ClientId == appId); //await BITCORNLogger.LogError(_dbContext,new Exception(""),JsonConvert.SerializeObject(orderRequest)); if (client != null) { if (client.OrderMaxSize != null) { if (client.OrderMaxSize.Value > orderRequest.Items.Length) { return(StatusCode((int)HttpStatusCode.NotAcceptable)); } } var cornPrice = await ProbitApi.GetCornPriceAsync(_dbContext); if (client.OrderMaxCost != null) { var totalSum = orderRequest.Items.Select(i => i.AmountUsd / cornPrice).Sum(); if (totalSum > client.OrderMaxCost.Value) { return(StatusCode((int)HttpStatusCode.NotAcceptable)); } } var order = new Order(); order.ClientId = client.ClientId; order.OrderId = Guid.NewGuid().ToString(); order.ClientOrderId = orderRequest.ClientOrderId.ToString(); OrderItem[] items = new OrderItem[orderRequest.Items.Length]; for (int i = 0; i < orderRequest.Items.Length; i++) { var orderItem = new OrderItem(); orderItem.Name = orderRequest.Items[i].Name; orderItem.OrderId = order.OrderId; orderItem.ClientItemId = orderRequest.Items[i].ItemId; orderItem.Quantity = orderRequest.Items[i].Quantity; if (orderItem.Quantity < 1) { orderItem.Quantity = 1; } var usdAmount = orderRequest.Items[i].AmountUsd; var cornAmount = usdAmount / cornPrice; orderItem.CornAmount = cornAmount; orderItem.UsdAmount = orderRequest.Items[i].AmountUsd; items[i] = orderItem; _dbContext.OrderItem.Add(orderItem); } order.OrderState = 0; order.CreatedAt = DateTime.Now; _dbContext.Order.Add(order); await _dbContext.SaveAsync(); return(new OrderOutput(order, client, items)); } return(StatusCode(400)); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(orderRequest)); return(StatusCode(500)); } }
public async Task <ActionResult <object> > Withdraw([FromBody] WithdrawRequest request) { try { var platformId = BitcornUtils.GetPlatformId(request.Id); var user = this.GetCachedUser();//await BitcornUtils.GetUserForPlatform(platformId, _dbContext).FirstOrDefaultAsync(); var response = new Dictionary <string, object>(); if (user != null) { if (user.UserWallet.IsLocked != null && user.UserWallet.IsLocked.Value) { return(StatusCode(420)); } //if (user.MFA) { if (user.UserWallet.Balance < 30_000_000) { var withdrawResult = await WalletUtils.Withdraw(_dbContext, _configuration, user, request.CornAddy, request.Amount, platformId.Platform); response.Add("usererror", withdrawResult.UserError); response.Add("walletavailable", withdrawResult.WalletAvailable); response.Add("txid", withdrawResult.WalletObject); if (withdrawResult.ErrorCode != null && withdrawResult.ErrorCode == Utils.Wallet.Models.WalletErrorCodes.RPC_WALLET_INSUFFICIENT_FUNDS) { await BitcornUtils.TxTracking(_configuration, new { message = "Insufficient funds detected on wallet on withdraw, (this might be because of no mature utxos) address to deposit from cold reserve = " + withdrawResult.DepositAddress }); } await FillColumns(response, request, user); if (withdrawResult.WalletObject != null && request.Amount > 100000) { await BitcornUtils.TxTracking(_configuration, new { txid = withdrawResult.WalletObject, time = DateTime.Now, method = "withdraw", platform = platformId.Platform, amount = request.Amount, userid = user.UserId, twitchUsername = user.UserIdentity.TwitchUsername, discordUsername = user.UserIdentity.DiscordUsername, cornaddy = request.CornAddy, }); } } else { response.Add("usererror", false); response.Add("walletavailable", false); response.Add("txid", null); await FillColumns(response, request, user); await BitcornUtils.TxTracking(_configuration, new { message = "Withdraw cancelled, manual withdraw required.", time = DateTime.Now, platform = platformId.Platform, amount = request.Amount, userid = user.UserId, twitchUsername = user.UserIdentity.TwitchUsername, discordUsername = user.UserIdentity.DiscordUsername, cornaddy = request.CornAddy, }); } } /* * else * { * await FillColumns(response, request, user); * response.Add("usererror", false); * response.Add("walletavailable", false); * response.Add("txid", null); * }*/ } return(response); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(request)); throw e; } }
public async Task <Dictionary <string, string> > GetSubs(string twitchId) { HelixSubResponse initial = null; try { var userIds = new Dictionary <string, string>(); initial = await SubscriptionsRequest(twitchId, null); if (initial != null) { //if (initial.data == null) return 0; string pagination = null; if (initial.pagination != null && !string.IsNullOrEmpty(initial.pagination.cursor)) { pagination = initial.pagination.cursor; } for (int i = 0; i < initial.data.Length; i++) { var userId = initial.data[i].user_id; if (!userIds.ContainsKey(userId)) { userIds.Add(initial.data[i].user_id, initial.data[i].tier); } } while (!string.IsNullOrEmpty(pagination)) { if (!string.IsNullOrEmpty(pagination)) { var output = await SubscriptionsRequest(twitchId, pagination); if (output != null && output.data != null) { for (int i = 0; i < output.data.Length; i++) { var userId = output.data[i].user_id; if (!userIds.ContainsKey(userId)) { userIds.Add(userId, output.data[i].tier); } } if (output.pagination != null) { pagination = output.pagination.cursor; } } } } } return(userIds); } catch (Exception ex) { await BITCORNLogger.LogError(_dbContext, ex, JsonConvert.SerializeObject(initial)); throw ex; //return new Dictionary<string, string>(); } }
public async Task <FullUser> Register([FromBody] RegistrationData registrationData) { if (registrationData == null) { throw new ArgumentNullException("registrationData"); } if (registrationData.Auth0Id == null) { throw new ArgumentNullException("registrationData.Auth0Id"); } if (registrationData.PlatformId == null) { throw new ArgumentNullException("registrationData.PlatformId"); } try { string auth0Id = registrationData.Auth0Id; var auth0DbUser = await _dbContext.Auth0Query(auth0Id).FirstOrDefaultAsync(); var platformId = BitcornUtils.GetPlatformId(registrationData.PlatformId); switch (platformId.Platform) { case "twitch": var twitchUser = await TwitchKraken.GetTwitchUser(platformId.Id); var twitchDbUser = await _dbContext.TwitchQuery(platformId.Id).FirstOrDefaultAsync(); if (twitchDbUser != null && twitchDbUser.UserIdentity.Auth0Id == null) { // _dbContext.UserIdentity.Remove(auth0DbUser); auth0DbUser.UserIdentity.TwitchId = twitchDbUser.UserIdentity.TwitchId; CopyIdentity(auth0DbUser.UserIdentity, twitchDbUser.UserIdentity); twitchDbUser.UserIdentity.TwitchUsername = twitchUser.name; twitchDbUser.UserIdentity.Auth0Id = auth0Id; twitchDbUser.UserIdentity.Auth0Nickname = auth0DbUser.UserIdentity.Auth0Nickname; await MigrateUser(auth0DbUser, twitchDbUser); await TxUtils.TryClaimTx(platformId, null, _dbContext); return(GetFullUser(twitchDbUser)); } else if (twitchDbUser == null && auth0DbUser != null) { auth0DbUser.UserIdentity.TwitchId = platformId.Id; auth0DbUser.UserIdentity.TwitchUsername = twitchUser.name; await _dbContext.SaveAsync(); await TxUtils.TryClaimTx(platformId, null, _dbContext); return(GetFullUser(auth0DbUser)); } else if (twitchDbUser != null) { var e = new Exception($"A login id already exists for this twitch id {platformId.Id}"); await BITCORNLogger.LogError(_dbContext, e); throw e; } else { var e = new Exception( $"Failed to register twitch {platformId.Id} {auth0Id}"); await BITCORNLogger.LogError(_dbContext, e); throw e; } case "discord": try { var discordToken = DiscordApi.GetDiscordBotToken(_configuration); var discordUser = await DiscordApi.GetDiscordUser(discordToken, platformId.Id); var discordDbUser = await _dbContext.DiscordQuery(platformId.Id).FirstOrDefaultAsync(); if (discordDbUser != null && discordDbUser.UserIdentity.Auth0Id == null) { //_dbContext.UserIdentity.Remove(auth0DbUser); //await _dbContext.SaveAsync(); auth0DbUser.UserIdentity.DiscordId = discordDbUser.UserIdentity.DiscordId; CopyIdentity(auth0DbUser.UserIdentity, discordDbUser.UserIdentity); discordDbUser.UserIdentity.DiscordUsername = DiscordApi.GetUsernameString(discordUser); discordDbUser.UserIdentity.Auth0Id = auth0Id; discordDbUser.UserIdentity.Auth0Nickname = auth0DbUser.UserIdentity.Auth0Nickname; await MigrateUser(auth0DbUser, discordDbUser); await TxUtils.TryClaimTx(platformId, null, _dbContext); return(GetFullUser(discordDbUser)); } else if (discordDbUser == null && auth0DbUser != null) { auth0DbUser.UserIdentity.DiscordId = platformId.Id; auth0DbUser.UserIdentity.DiscordUsername = DiscordApi.GetUsernameString(discordUser); await _dbContext.SaveAsync(); await TxUtils.TryClaimTx(platformId, null, _dbContext); return(GetFullUser(auth0DbUser)); } else if (discordDbUser?.UserIdentity.Auth0Id != null) { var e = new Exception($"A login id already exists for this discord id"); await BITCORNLogger.LogError(_dbContext, e, $"Auth0Id already exists for user {platformId.Id}"); throw e; } else { var e = new Exception($"Failed to register discord"); await BITCORNLogger.LogError(_dbContext, e, $"Failed to register discord id for user {platformId.Id} {auth0Id}"); throw e; } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); throw new Exception($"Failed to add user's discord"); } throw new Exception($"HOW THE F**K DID YOU GET HERE"); case "twitter": try { var twitterUser = await TwitterApi.GetTwitterUser(_configuration, platformId.Id); var twitterDbUser = await _dbContext.TwitterQuery(platformId.Id).FirstOrDefaultAsync(); if (twitterDbUser != null && twitterDbUser.UserIdentity.Auth0Id == null) { auth0DbUser.UserIdentity.TwitterId = twitterDbUser.UserIdentity.TwitterId; //_dbContext.UserIdentity.Remove(auth0DbUser); CopyIdentity(auth0DbUser.UserIdentity, twitterDbUser.UserIdentity); twitterDbUser.UserIdentity.Auth0Id = auth0Id; twitterDbUser.UserIdentity.TwitterUsername = twitterUser.Name; twitterDbUser.UserIdentity.Auth0Nickname = auth0DbUser.UserIdentity.Auth0Nickname; await MigrateUser(auth0DbUser, twitterDbUser); await TxUtils.TryClaimTx(platformId, null, _dbContext); return(GetFullUser(twitterDbUser)); } if (twitterDbUser == null && auth0DbUser != null) { auth0DbUser.UserIdentity.TwitterId = platformId.Id; auth0DbUser.UserIdentity.TwitterUsername = twitterUser.Name; await _dbContext.SaveAsync(); await TxUtils.TryClaimTx(platformId, null, _dbContext); return(GetFullUser(auth0DbUser)); } if (twitterDbUser?.UserIdentity.Auth0Id != null) { var e = new Exception($"Auth0Id already exists for user {platformId.Id}"); await BITCORNLogger.LogError(_dbContext, e); throw e; } var ex = new Exception($"Failed to register twitter id for user {platformId.Id} {auth0Id}"); await BITCORNLogger.LogError(_dbContext, ex); throw ex; } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); throw e; } throw new Exception($"HOW THE F**K DID YOU GET HERE"); case "reddit": try { var redditDbUser = await _dbContext.RedditQuery(platformId.Id).FirstOrDefaultAsync(); if (redditDbUser != null && redditDbUser.UserIdentity.Auth0Id == null) { auth0DbUser.UserIdentity.RedditId = redditDbUser.UserIdentity.RedditId; CopyIdentity(auth0DbUser.UserIdentity, redditDbUser.UserIdentity); //_dbContext.UserIdentity.Remove(auth0DbUser); redditDbUser.UserIdentity.Auth0Id = auth0Id; redditDbUser.UserIdentity.Auth0Nickname = auth0DbUser.UserIdentity.Auth0Nickname; await MigrateUser(auth0DbUser, redditDbUser); await TxUtils.TryClaimTx(platformId, null, _dbContext); return(GetFullUser(redditDbUser)); } else if (redditDbUser == null && auth0DbUser != null) { auth0DbUser.UserIdentity.RedditId = platformId.Id; await _dbContext.SaveAsync(); await TxUtils.TryClaimTx(platformId, null, _dbContext); return(GetFullUser(auth0DbUser)); } else if (redditDbUser?.UserIdentity.Auth0Id != null) { var e = new Exception($"Auth0Id already exists for user {platformId.Id}"); await BITCORNLogger.LogError(_dbContext, e); throw e; } else { var e = new Exception($"Failed to register reddit id for user {platformId.Id} {platformId.Id}"); await BITCORNLogger.LogError(_dbContext, e); throw e; } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e); throw e; } throw new Exception($"HOW THE F**K DID YOU GET HERE"); default: throw new Exception("Invalid platform provided in the Id"); } } catch (Exception e) { throw new Exception($"registration failed for {registrationData}"); } throw new Exception("HOW THE F**K DID YOU GET HERE"); }
public async Task <ActionResult <object> > CloseTransaction([FromBody] CloseOrderTransactionRequest orderRequest) { try { var appId = this.GetAppId(_configuration); if (string.IsNullOrEmpty(appId)) { return(StatusCode((int)HttpStatusCode.BadRequest)); } if (appId != orderRequest.ClientId) { await BITCORNLogger.LogError(_dbContext, new Exception("Unauthorized app request " + appId + " - " + orderRequest.ClientId), JsonConvert.SerializeObject(orderRequest)); return(StatusCode(401)); } var checkOrder = await GetOrder(orderRequest.OrderId); if (checkOrder == null) { return(StatusCode(404)); } var(order, client) = checkOrder.Value; if (order.ClientId != orderRequest.ClientId) { return(StatusCode((int)HttpStatusCode.BadRequest)); } if (order.OrderState != 1) { return(StatusCode((int)HttpStatusCode.Gone)); } //if (client.ClientId != orderRequest.ClientId) return StatusCode(400); if (order.TxId != null && orderRequest.TxId == order.TxId) { if (order.OrderState == 1) { order.OrderState = 2; await _dbContext.SaveAsync(); return(new { success = true }); } else { return(HttpStatusCode.Gone); } } return(StatusCode(400)); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(orderRequest)); return(StatusCode(500)); } }
public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next) { User user = await CacheUserAttribute.ReadUser(_config, _dbContext, context); try { try { var appId = context.HttpContext.GetAppId(_config); if (!string.IsNullOrEmpty(appId)) { var thirdPartyClient = await _dbContext.ThirdPartyClient.AnyAsync(a => a.ClientId == appId); if (thirdPartyClient) { context.Result = new ContentResult() { StatusCode = (int)HttpStatusCode.Forbidden, Content = JsonConvert.SerializeObject(new { refused = "Server refuses to serve this request: invalid headers" }) }; await BITCORNLogger.LogError(_dbContext, new Exception("Forbidden request for app id:" + appId), appId); return; } } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, null); throw e; } if (user == null) { var query = LockUserAttributeUtils.GetUserFromHeader(context, _dbContext); if (query == null) { context.Result = new ContentResult() { StatusCode = (int)HttpStatusCode.BadRequest, Content = JsonConvert.SerializeObject(new { refused = "Server refuses to serve this request: invalid headers" }) }; return; } user = await query.FirstOrDefaultAsync(); if (user != null) { context.HttpContext.Items.Add("user", user); context.HttpContext.Items.Add("usermode", 1); } } } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, null); throw; } if (user == null) { //let the api deal with unregistered sender await next(); return; } if (!UserLockCollection.Lock(user)) { context.Result = new ContentResult() { StatusCode = UserLockCollection.UserLockedReturnCode, Content = JsonConvert.SerializeObject(new { refused = "Server refuses to serve this request: User is locked" }) }; return; } try { await next(); } finally { UserLockCollection.Release(user); } }
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); } }
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); } } }
public override async Task <PlatformSyncResponse> SyncPlatform(RegistrationData registrationData, User auth0DbUser, PlatformId platformId, string auth0Id) { var twitchUser = await TwitchKraken.GetTwitchUser(platformId.Id); var twitchDbUser = await _dbContext.TwitchQuery(platformId.Id).FirstOrDefaultAsync(); if (twitchDbUser != null && twitchDbUser.UserIdentity.Auth0Id == null) { // _dbContext.UserIdentity.Remove(auth0DbUser); auth0DbUser.UserIdentity.TwitchId = twitchDbUser.UserIdentity.TwitchId; MigrateOldIdentity(auth0DbUser.UserIdentity, twitchDbUser.UserIdentity); twitchDbUser.UserIdentity.TwitchUsername = twitchUser.display_name; twitchDbUser.UserIdentity.Auth0Id = auth0Id; twitchDbUser.UserIdentity.Auth0Nickname = auth0DbUser.UserIdentity.Auth0Nickname; twitchDbUser.UserIdentity.TwitchRefreshToken = registrationData.Token; await MigrateOldProfile(auth0DbUser, twitchDbUser); return(GetSyncOutput(twitchUser.created_at, twitchDbUser, true)); } else if (twitchDbUser == null && auth0DbUser != null) { auth0DbUser.UserIdentity.TwitchId = platformId.Id; auth0DbUser.UserIdentity.TwitchUsername = twitchUser.name; auth0DbUser.UserIdentity.TwitchRefreshToken = registrationData.Token; await _dbContext.SaveAsync(); return(GetSyncOutput(twitchUser.created_at, auth0DbUser, false)); } else if (twitchDbUser != null) { /* * var e = new Exception($"A login id already exists for this twitch id {platformId.Id}"); * await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(registrationData)); * throw e; */ if (auth0DbUser != null && twitchDbUser != null) { if (twitchDbUser.UserIdentity.Auth0Id == auth0DbUser.UserIdentity.Auth0Id && !string.IsNullOrEmpty(registrationData.Token)) { if (twitchDbUser.UserIdentity.TwitchId == auth0DbUser.UserIdentity.TwitchId) { auth0DbUser.UserIdentity.TwitchRefreshToken = registrationData.Token; await _dbContext.SaveAsync(); return(GetSyncOutput(twitchUser.created_at, twitchDbUser, false)); } } } var obj = GetSyncOutput(twitchUser.created_at, twitchDbUser, false); obj.ProfileAlreadySynced = true; return(obj); } else { var e = new Exception( $"Failed to register twitch {platformId.Id} {auth0Id}"); await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(registrationData)); throw e; } }
/// <summary> /// called from client server to create an order tht the user will authorize /// </summary> public async Task <ActionResult <object> > AuthorizeOrder([FromBody] AuthorizeOrderRequest orderRequest) { try { var user = (this.GetCachedUser()); if (this.GetUserMode() != null && this.GetUserMode() == 1) { throw new NotImplementedException(); } if (user != null) { if (user.IsBanned) { return(StatusCode(403)); } var checkOrder = await GetOrder(orderRequest.OrderId); if (checkOrder == null) { return(StatusCode(404)); } var(order, client) = checkOrder.Value; if (order.OrderState != 0) { return(StatusCode((int)HttpStatusCode.Gone)); } if (order.ClientId != orderRequest.ClientId) { return(StatusCode((int)HttpStatusCode.BadRequest)); } 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 recipientUser = await _dbContext.JoinUserModels() .FirstOrDefaultAsync((u) => u.UserId == client.RecipientUser); 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) { if (recipientUser != null) { var processInfo = await TxUtils.PrepareTransaction(user, recipientUser, cornOrderSum, client.ClientId, "app:order", _dbContext); var paymentSuccess = await processInfo.ExecuteTransaction(_dbContext); if (paymentSuccess) { var jwt = CreateJwt(client, order, orderItems, cornOrderSum, processInfo.Transactions[0].TxId.Value); order.TxId = processInfo.Transactions[0].TxId; order.OrderState = 1; order.CompletedAt = DateTime.Now; await _dbContext.SaveAsync(); if (string.IsNullOrEmpty(client.Capture)) { return(new { jwt, txId = order.TxId.Value, amount = cornOrderSum }); } else { var restClient = new RestClient(); var url = $"{client.Domain}/{client.Capture}"; var redirectUrl = $"{client.Domain}/{client.Redirect}"; var restRequest = new RestRequest(url, Method.POST); if (client.PostFormat == "application/x-www-form-urlencoded") { restRequest.AddHeader("Content-Type", "application/x-www-form-urlencoded"); restRequest.AddObject(new { jwt }); } else { restRequest.AddJsonBody(new { jwt }); } var restResponse = restClient.Execute(restRequest); await BITCORNLogger.LogError(_dbContext, new Exception("Order hook callback"), restResponse.Content); return(new { redirect = redirectUrl, txId = order.TxId.Value, amount = cornOrderSum }); } } else { return(new { txId = -1 }); } } } else { return(StatusCode((int)HttpStatusCode.PaymentRequired)); } } return(StatusCode((int)HttpStatusCode.BadRequest)); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, JsonConvert.SerializeObject(orderRequest)); return(StatusCode(500)); } }
public async Task <ActionResult <List <AvailableSubscriptionResponse> > > Available([FromRoute] string subscriptionName = null) { try { AvailableSubscriptionInfo[] subscriptions = null; var query = (from subscriptionTier in _dbContext.SubscriptionTier join subscription in _dbContext.Subscription on subscriptionTier.SubscriptionId equals subscription.SubscriptionId select new AvailableSubscriptionInfo { SubscriptionTier = subscriptionTier, Subscription = subscription }); if (string.IsNullOrEmpty(subscriptionName) || subscriptionName == "*") { subscriptions = await query.ToArrayAsync(); } else { subscriptions = await query.Where(s => s.Subscription.Name.ToLower() == subscriptionName.ToLower()).ToArrayAsync(); } var availableSubscriptions = new List <AvailableSubscriptionResponse>(); var cornUsdt = await ProbitApi.GetCornPriceAsync(_dbContext); foreach (var row in subscriptions) { var existingEntry = availableSubscriptions.FirstOrDefault(l => l.Subscription.SubscriptionId == row.Subscription.SubscriptionId); if (existingEntry == null) { existingEntry = new AvailableSubscriptionResponse() { Subscription = row.Subscription, }; availableSubscriptions.Add(existingEntry); } decimal actualCost = 0; if (row.SubscriptionTier.CostUsdt != null && row.SubscriptionTier.CostUsdt > 0) { actualCost = SubscriptionUtils.CalculateUsdtToCornCost(cornUsdt, row.SubscriptionTier); if (row.SubscriptionTier.CostCorn == 0 || row.SubscriptionTier.CostCorn == null) { row.SubscriptionTier.CostCorn = actualCost; } } else if (row.SubscriptionTier.CostCorn != null && row.SubscriptionTier.CostCorn > 0) { actualCost = row.SubscriptionTier.CostCorn.Value; } existingEntry.Tiers.Add(new { tierInfo = row.SubscriptionTier, actualCost }); } return(availableSubscriptions); } catch (Exception e) { await BITCORNLogger.LogError(_dbContext, e, subscriptionName); throw e; } }
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()); }