public static async Task <ResultsItem> DeleteBBThread(int threadId, LocalAccount.PegaUser user)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
BBThreads serviceThread = db.BBThreads.FirstOrDefault(x => x.ThreadId == threadId);
if (serviceThread == null)
{
return(ResultsItem.Error("This thread was not found or has already been deleted."));
}
if (serviceThread.UserId != user.UserId)
{
return(ResultsItem.Error("This thread belongs to another user."));
}
db.Remove(serviceThread);
await db.SaveChangesAsync();
return(ResultsItem.Success("Successfully deleted this thread. Please refresh the page to see changes."));
}
}
catch (Exception ex)
{
Utilities.LogException(new[] { $"User:{user.Username}" }, ex);
return(ResultsItem.Error($"Unable to delete this thread. {ex.Message}"));
}
}
public static ResultsPair <LocalAccount.PegaUser> ViewUserProfile(string username)
{
using (PegasunDBContext db = new PegasunDBContext())
{
var user = db.Users.FirstOrDefault(x => x.Username == username);
if (user == null)
{
return(ResultsPair.CreateError <LocalAccount.PegaUser>($"Could not find the user {username}."));
}
var portfolios = db.Portfolios.Where(x => x.UserId == user.UserId && x.DisplayType == 3).ToList();
LocalAccount.PegaUser localUser = user.Adapt <LocalAccount.PegaUser>();
localUser.Portfolios = portfolios.Adapt <List <LocalCoins.Portfolio> >();
localUser.TotalCreatedThreads = db.BBThreads.Count(x => x.UserId == user.UserId);
localUser.TotalCreatedComments = db.BBComments.Count(x => x.UserId == user.UserId);
return(ResultsPair.CreateSuccess(localUser));
}
}
public static async Task <ResultsItem> CreateBBThread(LocalCommunity.BBThread thread, LocalAccount.PegaUser user)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
thread.Message = thread.Message.Clean(new[] { Types.CleanInputType.AZ09CommonCharsSM });
thread.UserId = user.UserId;
BBThreads serviceMessageThread = thread.Adapt <BBThreads>();
serviceMessageThread.CreateDate = DateTime.Now;
serviceMessageThread.UserId = user.UserId;
serviceMessageThread.Message = serviceMessageThread.Message.Clean(new[] { Types.CleanInputType.AZ09CommonCharsSM });
serviceMessageThread.Title = serviceMessageThread.Title.Clean(new[] { Types.CleanInputType.AZ09CommonCharsSM });
db.BBThreads.Add(serviceMessageThread);
await db.SaveChangesAsync();
return(ResultsItem.Success("Successfully created a new thread"));
}
}
catch (Exception ex)
{
Utilities.LogException(new[] { $"User:{user.Username}" }, ex);
return(ResultsItem.Error($"Unable to create a new thread. {ex.Message}"));
}
}
public static async Task <LocalCommunity.BBThread> GetBBThreadWithComments(int threadId, LocalAccount.PegaUser currentUser)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
var getThreadTask = GetBBThreadsFromDB(db, currentUser, threadId: threadId);
var getCommentsTask = GetBBThreadCommentsFromDB(db, threadId, currentUser);
LocalCommunity.BBThread thread = (await getThreadTask).FirstOrDefault();
List <LocalCommunity.BBComment> comments = await getCommentsTask;
if (thread == null)
{
return(null);
}
thread.ThreadComments = comments;
thread.ThreadName = "thread_" + thread.ThreadId;
return(thread);
}
}
catch (Exception ex)
{
Utilities.LogException(new[] { $"ThreadId:{threadId}" }, ex);
return(new LocalCommunity.BBThread());
}
}
private static async Task <List <LocalCommunity.BBComment> > GetBBThreadCommentsFromDB(PegasunDBContext db, int threadId, LocalAccount.PegaUser currentUser)
{
var query = db.BBComments.Select(x => new
{
BBComment = x,
User = new { x.User.UserId, x.User.Username, x.User.Email },
VoteResult = new { TotalVotes = x.BBCommentVotes.Count, TotalUpvotes = x.BBCommentVotes.Count(v => v.IsUpvote) }
});
var result = await query.Where(x => x.BBComment.ThreadId == threadId).ToListAsync();
List <LocalCommunity.BBComment> comments = new List <LocalCommunity.BBComment>();
result.ForEach(r =>
{
LocalCommunity.BBComment comment = r.BBComment.Adapt <LocalCommunity.BBComment>();
comment.User = r.User.Adapt <LocalAccount.PegaUser>();
comment.VoteResult = r.VoteResult.Adapt <LocalCommunity.VoteResult>();
comment.CurrentLoggedInUserID = (currentUser?.UserId).GetValueOrDefault();
comments.Add(comment);
});
return(comments);
}
private static async Task <List <LocalCommunity.BBThread> > GetBBThreadsFromDB(PegasunDBContext db, LocalAccount.PegaUser currentUser, int?take = null, int?threadId = null,
List <Types.ConvThreadCategory> categories = null, int officialCoindId = 0)
{
if ((take == null || categories.IsNullOrEmpty()) && threadId == null)
{
throw new Exception("GetMessageThread: Not all parameters were passed in correctly.");
}
var query = db.BBThreads.OrderByDescending(x => x.CreateDate).Select(x => new
{
BBThread = x,
User = new { x.User.UserId, x.User.Username, x.User.Email },
VoteResult = new { TotalVotes = x.BBThreadVotes.Count, TotalUpvotes = x.BBThreadVotes.Count(v => v.IsUpvote) },
TotalComments = x.BBComments.Count
});
var result = threadId.GetValueOrDefault() > 0 ? await query.Where(x => x.BBThread.ThreadId == threadId).ToListAsync()
: officialCoindId > 0
? await query.Where(x => x.BBThread.OfficialCoinId == officialCoindId).Take(take.GetValueOrDefault()).ToListAsync()
: await query.Where(x => categories.Any(c => (short)c == x.BBThread.CategoryCode)).Take(take.GetValueOrDefault()).ToListAsync();
List <LocalCommunity.BBThread> threads = new List <LocalCommunity.BBThread>();
result.ForEach(r =>
{
LocalCommunity.BBThread thread = r.BBThread.Adapt <LocalCommunity.BBThread>();
thread.User = r.User.Adapt <LocalAccount.PegaUser>();
thread.VoteResult = r.VoteResult.Adapt <LocalCommunity.VoteResult>();
thread.TotalComments = r.TotalComments;
thread.CurrentLoggedInUserID = (currentUser?.UserId).GetValueOrDefault();
threads.Add(thread);
});
return(threads);
}
public static async Task <ResultsItem> VoteBBComment(long commentId, bool isUpvote, LocalAccount.PegaUser user)
{
try
{
string message = "Successfully updated your vote. It will be reflected shortly.";
using (PegasunDBContext db = new PegasunDBContext())
{
var getServiceCommentTask = db.BBComments.FirstOrDefaultAsync(x => x.CommentId == commentId);
var getExistingVoteTask = db.BBCommentVotes.FirstOrDefaultAsync(x => x.CommentId == commentId && x.UserId == user.UserId);
var serviceComment = await getServiceCommentTask;
var existingVote = await getExistingVoteTask;
if (serviceComment == null)
{
return(ResultsItem.Error("This comment does not exist."));
}
if (existingVote != null)
{
if (existingVote.IsUpvote == isUpvote)
{
db.Remove(existingVote); message = "Successfully removed your vote. It will be reflected shortly.";
} // Same vote (e.g. clicked on upvote twice), which means they are re-tracing their vote.
else
{
existingVote.IsUpvote = isUpvote;
}
}
else
{
var newServiceVote = new BBCommentVotes
{
CommentId = commentId,
IsUpvote = isUpvote,
UserId = user.UserId
};
db.BBCommentVotes.Add(newServiceVote);
}
db.SaveChanges();
return(ResultsItem.Success(message));
}
}
catch (Exception ex)
{
Utilities.LogException(new[] { $"User:{user.Username}", $"CommentId:{commentId}" }, ex);
return(ResultsItem.Error($"Unable to submit your vote. {ex.Message}"));
}
}
// CurrentUser can be null
public static async Task <List <LocalCommunity.BBThread> > GetBBThreads(int take, List <Types.ConvThreadCategory> categories, LocalAccount.PegaUser currentUser, int officialCoinId = 0)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
List <LocalCommunity.BBThread> threads = await GetBBThreadsFromDB(db, currentUser, take : take, categories : categories, officialCoindId : officialCoinId);
return(threads);
}
}
catch (Exception ex)
{
Utilities.LogException(new[] { $"Category:{string.Join(",", categories)}" }, ex);
return(new List <LocalCommunity.BBThread>());
}
}
public static async Task <ResultsItem> CreateBBComment(LocalCommunity.BBComment comment, LocalAccount.PegaUser user)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
comment.Message.Clean(new[] { Types.CleanInputType.AZ09CommonCharsSM });
BBComments serviceComment = comment.Adapt <BBComments>();
serviceComment.CreateDate = DateTime.Now;
serviceComment.UserId = user.UserId;
serviceComment.Message = serviceComment.Message.Clean(new[] { Types.CleanInputType.AZ09CommonCharsSM });
db.BBComments.Add(serviceComment);
await db.SaveChangesAsync();
return(ResultsItem.Success("Successfully posted a new comment."));
}
}
catch (Exception ex)
{
Utilities.LogException(new[] { $"User:{user.Username}" }, ex);
return(ResultsItem.Error($"Unable to create a comment. {ex.Message}"));
}
}
public static async Task <List <ImportedCoin> > ApiImport_GDax(string encryptedApiPublic, string encryptedApiSecret, string passphrase, LocalAccount.PegaUser user)
{
string apiKey = Cryptography.Decrypt(encryptedApiPublic, Types.EncryptionType.ApiKey_Public, user); //"c6b8915e430a662b1ee2563e710d8a51";
string apiSecret = Cryptography.Decrypt(encryptedApiSecret, Types.EncryptionType.ApiKey_Private, user); // "4cIDR3rTUJtQvCnrrr5wGQvcvbeBef0Cy/JTmTmfr4C38rdL1+wEDuTG8jztU1ZXlu6Z2Pti7nWCwUouG463tQ==";
string url = "https://api.gdax.com/fills";
int timeStamp = Utilities.GetCurrentEpochTime();
string toSignMessage = timeStamp + "GET" + "/fills";
string signKey;
using (var hmac = new System.Security.Cryptography.HMACSHA256(Convert.FromBase64String(apiSecret)))
{
signKey = Convert.ToBase64String(hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(toSignMessage)));
}
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Add("User-Agent", "PegaTrade_APICaller");
client.DefaultRequestHeaders.Add("CB-ACCESS-KEY", apiKey);
client.DefaultRequestHeaders.Add("CB-ACCESS-SIGN", signKey);
client.DefaultRequestHeaders.Add("CB-ACCESS-TIMESTAMP", timeStamp.ToString());
client.DefaultRequestHeaders.Add("CB-ACCESS-PASSPHRASE", passphrase);
string jsonResult = await client.GetStringAsync(url);
List <API_GDaxImportResult> result = Deserialize <List <API_GDaxImportResult> >(jsonResult);
if (!result.IsNullOrEmpty())
{
return(result.Where(x => x.settled).Select(x => new ImportedCoin
{
Symbol = "USD-" + x.product_id.Replace("-USD", string.Empty),
Shares = Convert.ToDecimal(x.size),
OrderDate = x.created_at,
OrderType = x.side,
TotalPricePaidInCurrency = (Convert.ToDecimal(x.price) * Convert.ToDecimal(x.size)),
Exchange = Types.Exchanges.GDax
}).ToList());
}
return(new List <ImportedCoin>());
}
}
public static async Task <List <ImportedCoin> > ApiImport_BitTrex(string encryptedApiPublic, string encryptedApiSecret, LocalAccount.PegaUser user)
{
string apiKey = Cryptography.Decrypt(encryptedApiPublic, Types.EncryptionType.ApiKey_Public, user); // 3df1e84424d2416a9284804f67ce21ca
string apiSecret = Cryptography.Decrypt(encryptedApiSecret, Types.EncryptionType.ApiKey_Private, user); // 3fca8d88270f4bfeb56742bf5fd70841
string url = "https://bittrex.com/api/v1.1/account/getorderhistory";
int nonce = Utilities.GetCurrentEpochTime();
string uri = $"{url}?apikey={apiKey}&nonce={nonce}&count=100";
string signKey = Utilities.GenerateHmacSHA512Hash(uri, apiSecret);
using (HttpClient client = new HttpClient())
{
client.DefaultRequestHeaders.Add("apisign", signKey);
string jsonResult = await client.GetStringAsync(uri);
API_BitTrexImportResult result = Newtonsoft.Json.JsonConvert.DeserializeObject <API_BitTrexImportResult>(jsonResult);
if (result != null && result.success)
{
return(result.result.Select(x => new ImportedCoin
{
Symbol = x.Exchange,
Shares = Convert.ToDecimal(x.Quantity),
OrderDate = DateTime.Parse(x.TimeStamp),
OrderType = x.OrderType,
TotalPricePaidInCurrency = Convert.ToDecimal(x.Price),
Exchange = Types.Exchanges.BitTrex
}).ToList());
}
return(new List <ImportedCoin>());
}
}
public static async Task <ResultsPair <List <LocalCoins.CryptoCoin> > > ApiImport_EtherAddress(List <LocalCoins.MarketCoin> marketCoins, string etherAddress, int portfolioId, LocalAccount.PegaUser user)
{
ResultsPair <List <LocalCoins.CryptoCoin> > generateError(string errorMessage) => ResultsPair.CreateError <List <LocalCoins.CryptoCoin> >(errorMessage);
LocalCoins.CryptoCoin generateCoin(string symbol, decimal shares, decimal pricePerUnit)
{
return(new LocalCoins.CryptoCoin
{
CoinCurrency = Types.CoinCurrency.USD,
Exchange = Types.Exchanges.EtherAddressLookup,
OrderDate = DateTime.Now,
OrderType = Types.OrderType.Buy,
PortfolioId = portfolioId,
Shares = shares,
TotalPricePaidUSD = shares * pricePerUnit,
PricePerUnit = pricePerUnit,
Symbol = symbol
});
}
if (etherAddress.Length != 42)
{
return(generateError("This ethereum address is not valid."));
}
string url = $"https://api.ethplorer.io/getAddressInfo/{etherAddress}?apiKey=freekey";
using (HttpClient client = new HttpClient())
{
string jsonResult = await client.GetStringAsync(url);
if (string.IsNullOrEmpty(jsonResult))
{
return(generateError("An error has occured while calling the API endpoint"));
}
API_EthplorerAddressLookup result = Newtonsoft.Json.JsonConvert.DeserializeObject <API_EthplorerAddressLookup>(jsonResult);
if (result != null)
{
List <LocalCoins.CryptoCoin> coins = new List <LocalCoins.CryptoCoin>();
if (result.Eth.Balance > 0)
{
coins.Add(generateCoin("USD-ETH", (decimal)result.Eth.Balance, marketCoins.First(x => x.Symbol == "ETH").CurrentSymbolPriceUSD));
if (!result.Tokens.IsNullOrEmpty())
{
foreach (var x in result.Tokens.Where(x => x.TokenInfo != null && x.Balance > 0))
{
try
{
LocalCoins.MarketCoin marketCoin = marketCoins.FirstOrDefault(m => m.Name.ToUpper() == x.TokenInfo.Name.ToUpper());
if (marketCoin == null)
{
marketCoin = marketCoins.FirstOrDefault(m => m.Symbol.ToUpper() == x.TokenInfo.Symbol.ToUpper());
}
if (marketCoin == null)
{
continue;
}
double tokenDecimals = x.TokenInfo.Decimals;
decimal shares = tokenDecimals <= 0 ? (decimal)x.Balance : (decimal)(x.Balance / Math.Pow(10, x.TokenInfo.Decimals));
coins.Add(generateCoin($"USD-{x.TokenInfo.Symbol}", shares, marketCoin.CurrentSymbolPriceUSD));
}
catch { }
}
;
}
}
return(ResultsPair.CreateSuccess(coins));
}
return(generateError("Something went wrong, or you may not have any coins to import"));
}
}
// Creates a new user and then redirects them to the login page.
public static async Task <ResultsPair <LocalAccount.PegaUser> > CreateNewUser(LocalAccount.PegaUser user)
{
using (HttpClient client = new HttpClient())
{
var content = new FormUrlEncodedContent(new[]
{
new KeyValuePair <string, string>("Username", user.Username),
new KeyValuePair <string, string>("Password", user.Password),
new KeyValuePair <string, string>("Email", user.Email),
new KeyValuePair <string, string>("EmailSubscribePreferenceCode", ((int)EmailPreferences.Default).ToString()),
new KeyValuePair <string, string>("platform", ((int)Platform.PegaTrade).ToString())
});
HttpResponseMessage response = await client.PostAsync($"{baseUrl}/v1/Account/Create", content);
if (response.IsSuccessStatusCode)
{
string jsonString = await response.Content.ReadAsStringAsync();
ResultsItem createUserResult = NetJSON.NetJSON.Deserialize <PegasunAPIResult>(jsonString).ConvertToResultsItem();
if (createUserResult.ResultType == ResultsType.Successful)
{
var getUserResult = await AuthorizeUser(user.Username, user.Password);
if (!getUserResult.Result.IsSuccess)
{
return(getUserResult);
}
return(ResultsPair.Create(createUserResult, getUserResult.Value));
}
return(ResultsPair.CreateError <LocalAccount.PegaUser>(createUserResult.Message));
}
}
return(ResultsPair.CreateError <LocalAccount.PegaUser>(Lang.ServerConnectionError));
}
private static async Task <ResultsPair <LocalAccount.PTUserInfo> > CreateNewPTUserInfo(LocalAccount.PegaUser user)
{
try
{
using (PegasunDBContext db = new PegasunDBContext())
{
PTUserInfo ptUserInfo = new PTUserInfo
{
UserId = user.UserId,
SubscriptionLevel = (byte)SubscriptionLevel.Free,
SubscriptionExpireDate = null
};
db.PTUserInfo.Add(ptUserInfo);
await db.SaveChangesAsync();
LocalAccount.PTUserInfo localSubscription = ptUserInfo.Adapt <LocalAccount.PTUserInfo>();
return(ResultsPair.Create(ResultsItem.Success("Successfully created a new subscription."), localSubscription));
}
}
catch (Exception ex)
{
return(ResultsPair.CreateError <LocalAccount.PTUserInfo>($"Unable to create a new PTUserInfo: {ex.Message}"));
}
}
