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