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;
}
}
async Task FillColumns(Dictionary <string, object> response, WithdrawRequest request, User user)
{
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);
}
}
}
}
static async Task PopuplateUserResponse(BitcornContext dbContext, SubRequest subRequest, SubscriptionResponse output, User user)
{
var selectableUser = new SelectableUser(user);
var columns = await UserReflection.GetColumns(dbContext, subRequest.Columns, new int[] {
selectableUser.UserId
});
if (columns != null && columns.Count > 0)
{
foreach (var column in columns.First().Value)
{
selectableUser.Add(column.Key, column.Value);
}
}
output.User = selectableUser;
}
public async Task <ActionResult <object> > Ban([FromBody] BanUserRequest request)
{
if (string.IsNullOrWhiteSpace(request.Sender))
{
throw new ArgumentNullException("Sender");
}
if (string.IsNullOrWhiteSpace(request.BanUser))
{
throw new ArgumentNullException("BanUser");
}
var senderPlatformId = BitcornUtils.GetPlatformId(request.Sender);
var senderUser = await BitcornUtils.GetUserForPlatform(senderPlatformId, _dbContext).FirstOrDefaultAsync();
if (senderUser != null && senderUser.Level == "5000")
{
var banPlatformId = BitcornUtils.GetPlatformId(request.BanUser);
var primaryKey = -1;
var banUser = await BitcornUtils.GetUserForPlatform(banPlatformId, _dbContext).FirstOrDefaultAsync();
if (banUser != null)
{
primaryKey = banUser.UserId;
banUser.IsBanned = true;
_dbContext.Update(banUser);
await _dbContext.SaveAsync();
}
var users = await UserReflection.GetColumns(_dbContext, new string[] { "*" }, new[] { primaryKey });
if (users.Count > 0)
{
return(users.First());
}
return(null);
}
else
{
return(StatusCode((int)HttpStatusCode.Forbidden));
}
}
internal static async Task <object[]> GetLivestreamSettings(BitcornContext dbContext, string[] columns)
{
if (columns == null)
{
columns = new string[0];
}
var streams = await dbContext.GetLivestreams().Where(e => e.Stream.Enabled).ToArrayAsync();
List <object> output = new List <object>();
var userIds = streams.Select(x => x.User.UserId).ToArray();
//var selectColumns = columns.Split(" ");
var selectedColumns = await UserReflection.GetColumns(dbContext, columns, userIds, new UserReflectionContext(UserReflection.StreamerModel));//new Dictionary<string,object>();
foreach (var entry in streams)
{
if (!string.IsNullOrEmpty(entry.User.UserIdentity.TwitchId))
{
var srcColumns = new Dictionary <string, object>();
try
{
if (selectedColumns.TryGetValue(entry.User.UserId, out var cols))
{
if (cols != null)
{
srcColumns = cols;
}
}
}
catch
{
}
output.Add(LivestreamUtils.GetLivestreamSettingsForUser(entry.User, entry.Stream, srcColumns));
//channels.Add(stream.UserIdentity.TwitchUsername);
}
}
return(output.ToArray());
}
public static async Task AppendTxs(TxReceipt[] transactions, BitcornContext dbContext, string[] appendColumns)
{
if (appendColumns != null && appendColumns.Length > 0)
{
List <int> participants = new List <int>(transactions.Length + 1);
if (transactions[0].From != null)
{
participants.Add(transactions[0].From.UserId);
}
for (int i = 0; i < transactions.Length; i++)
{
if (transactions[i].To != null)
{
participants.Add(transactions[i].To.UserId);
}
}
var columns = await UserReflection.GetColumns(dbContext, appendColumns, participants.ToArray());
foreach (var tx in transactions)
{
if (tx.From != null)
{
var fromColumns = columns[participants[0]];
foreach (var from in fromColumns)
{
tx.From.Add(from.Key, from.Value);
}
}
if (tx.To != null)
{
foreach (var to in columns[tx.To.UserId])
{
tx.To.Add(to.Key, to.Value);
}
}
}
}
}
