public async Task <IHttpActionResult> PutRate(int id, Rate rate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != rate.Id)
{
return(BadRequest());
}
db.Entry(rate).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!RateExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public async Task <ActionResult <Currency> > PostTodoItem(Currency item)
{
_context.Currency.Add(item);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetCurrency), new { id = item.Id }, item));
}
public async Task <ActionResult <Currency> > PostCurrencyInfo([FromForm] Currency currency)
{
currency.cashUSDValue = Math.Round(currency.cashValue *
Convert.ToDouble(GetUpdatedCurrencyData(currencyURL, currencyURLParameters)), 2);
currency.bitcoinUSDValue = Math.Round(Convert.ToDouble
(GetUpdatedCurrencyData(cryptocurrencyURL, cryptocurrencyURLParameters)), 2);
currency.totalBitCoinValue = Math.Round(currency.cashUSDValue / currency.bitcoinUSDValue, 2);
currency.totalBitCoinPurchasable = Math.Floor(currency.totalBitCoinValue);
_context.Currencies.Add(currency);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetSongs", new { currency.id }, currency));
}
public async Task <IActionResult> ChooseCurrency(List <Currency> currencies)
{
foreach (var item in currencies)
{
if (item.Checked)
{
Currency currency = await _context.Currencies.FirstAsync(value => value.CurrencyId == item.CurrencyId);
currency.Quantity = currency.Quantity + 1;
_context.Update(currency);
await _context.SaveChangesAsync();
}
}
return(RedirectToAction("Index"));
}
public Task AddAsync(Guid apiKey)
{
apiKeyDbSet.Add(new ApiKey {
Value = apiKey
});
return(dbContext.SaveChangesAsync());
}
public async Task CreateNewMeme(string name, [Remainder] string content)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var meme = db.Memes.Find(name);
if (meme == null)
{
await db.AddAsync(new Meme
{
Id = name,
Content = content,
Owner = Context.Message.Author.Id
});
await db.SaveChangesAsync();
await ReplyAsync($"Meme {name} created!");
}
else
{
await ReplyAsync($"The name: {name} already exists, pick a different one!");
}
}
}
public async Task CreateAccount()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
await db.UserAccounts.AddAsync(new UserAccount
{
Id = Context.User.Id,
Balance = 1000,
Inventory = new Dictionary <string, int>()
});
await db.Cooldowns.AddAsync(new Cooldowns
{
Id = Context.User.Id,
Collect = new DateTime(),
Work = new DateTime(),
Rob = new DateTime(),
Robbed = new DateTime(),
Roulette = new DateTime(),
Trivia = new DateTime()
});
await db.SaveChangesAsync();
await ReplyAsync("Account created!");
}
}
public async Task AddHistory(RequestHistory history)
{
using (CurrencyContext context = new CurrencyContext())
{
context.RequestHistory.Add(history);
await context.SaveChangesAsync();
}
}
public Task AddRangeAsync(ExchangeRate[] exchangeRates)
{
exchangeRatesDbSet
.UpsertRange(mapper.Map <Database.Entities.ExchangeRate[]>(exchangeRates))
.On(entity => new { entity.Date, entity.Source, entity.Target })
.NoUpdate();
return(dbContext.SaveChangesAsync());
}
public async Task Buy(string itemname, int quantity = 1)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var item = db.Items.AsQueryable().Where(i => i.Id.ToLower() == itemname.ToLower()).FirstOrDefault();
if (item != null)
{
if (account.AddToInventory(item, quantity))
{
if (account.SubtractBalance(item.Price * quantity))
{
if (item.Id.ToLower() == "bitcoin_miner")
{
cooldowns.Collect = new DateTime();
db.Update(cooldowns);
}
db.Update(account);
await ReplyAsync("Item purchased!");
}
else
{
account.RemoveFromInventory(item, quantity);
db.Update(account);
await ReplyAsync("You can't afford that item!");
}
await db.SaveChangesAsync();
}
else
{
await ReplyAsync("You have reached the item limit for that item!");
}
}
else
{
await ReplyAsync("Item was not found!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
//Invoked every 10 minutes
//Gets new data from api, updates database and sends message to clients to update data on site
private async void DoWork(object state)
{
using var scope = _scopeFactory.CreateScope();
var dbContext =
new CurrencyContext(
scope.ServiceProvider.GetRequiredService <DbContextOptions <CurrencyContext> >());
var httpClient = _httpClientFactory.CreateClient("API Client");
foreach (var currency in DropDownHelper.GetCurrenciesList())
{
var httpResponse = await httpClient.GetAsync("/latest?base=" + currency);
if (!httpResponse.IsSuccessStatusCode)
{
return;
}
var content = await httpResponse.Content.ReadAsStringAsync();
var newModel = JsonConvert.DeserializeObject <CurrencyModel>(content);
var oldModel = dbContext.Currency.FirstOrDefault(c =>
c.CurrencyName == newModel.CurrencyName && c.RatesDate.Date == newModel.RatesDate.Date);
if (oldModel != null)
{
var oldExchangeRates = dbContext.ExchangeRates
.Where(r => r.CurrencyId == oldModel.Id)
.ToList();
dbContext.ExchangeRates.RemoveRange(oldExchangeRates);
oldModel.Rates = newModel.Rates;
dbContext.Currency.Update(oldModel);
}
else
{
dbContext.Currency.Add(newModel);
}
}
await dbContext.SaveChangesAsync();
if (LiveRatesHub.ConnectedClients != null && LiveRatesHub.ConnectedClients.Count != 0)
{
await _hubContext.Clients.All.SendAsync("UpdateRates");
}
}
public async Task Collect()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
if (account.Inventory.ContainsKey("bitcoin_miner"))
{
var collect = cooldowns.Collect;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(collect, "h", _collectCooldown);
if (isCooledDown)
{
var collected = _collectAmount * account.Inventory["bitcoin_miner"];
account.AddBalance(collected);
cooldowns.Collect = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync($"You've collected {collected} Kredits!");
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, collect.AddHours(_collectCooldown));
await ReplyAsync($"You can only collect once every {_collectCooldown} hours!\n" +
$"You still have to wait for {cooldown}!");
}
}
else
{
await ReplyAsync("You dont generate any passive income yet! Buy a device from the store does!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
public async Task DeleteMeme([Remainder] string name)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var meme = db.Memes.Find(name);
if (meme != null)
{
db.Remove(meme);
await db.SaveChangesAsync();
await ReplyAsync($"Removed '{name}'!");
}
else
{
await ReplyAsync($"Meme '{name}' does not exist!");
}
}
}
public async Task EditMeme(string name, [Remainder] string content)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var meme = db.Memes.Find(name);
if (meme != null)
{
meme.Content = content;
db.Update(meme);
await db.SaveChangesAsync();
await ReplyAsync($"Meme '{name}' was updated!");
}
else
{
await ReplyAsync($"Meme '{name}' does not exist!");
}
}
}
public async Task StartTrivia()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
if (!Running)
{
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var lastTrivia = cooldowns.Trivia;
var cooldownHandler = new CooldownHandler();
if (account.Inventory.ContainsKey("trivia_license"))
{
var isCooledDown = cooldownHandler.IsCooledDown(lastTrivia, "m", _triviaCooldown);
if (isCooledDown)
{
Running = true;
cooldowns.Trivia = DateTime.Now;
db.Update(cooldowns);
await db.SaveChangesAsync();
var response = await Client.GetAsync(TriviaUrl);
var responseString = await response.Content.ReadAsStringAsync();
var responseJson = JObject.Parse(responseString);
var score = new Dictionary <ulong, int>();
var stopwatch = new Stopwatch();
await ReplyAsync("A trivia session is starting in 30 seconds...");
await Task.Delay(10000);
await ReplyAsync("A trivia session is starting in 20 seconds...");
await Task.Delay(10000);
await ReplyAsync("A trivia session is starting in 10 seconds...");
await Task.Delay(7000);
await ReplyAsync("A trivia session is starting in 3 seconds...");
await Task.Delay(1000);
await ReplyAsync("A trivia session is starting in 2 seconds...");
await Task.Delay(1000);
await ReplyAsync("A trivia session is starting in 1 seconds...");
await Task.Delay(1000);
await ReplyAsync("Trivia is starting!");
foreach (var result in responseJson["results"])
{
await Task.Delay(2000);
await ReplyAsync(HttpUtility.HtmlDecode(result["question"].ToString()));
this.result = result;
await Task.Delay(2000);
var answers = new List <string>();
answers.Add(result["correct_answer"].ToString());
foreach (var incorrectAnswer in result["incorrect_answers"])
{
answers.Add((string)incorrectAnswer);
}
answers = answers.OrderBy(a => Guid.NewGuid()).ToList();
var answersMessage = string.Join(", ", answers.ToArray());
await ReplyAsync("Answers: " + HttpUtility.HtmlDecode(answersMessage));
Context.Client.MessageReceived += tryAnswer;
stopwatch.Start();
var timeout = false;
while (winnerId == 0)
{
if (stopwatch.ElapsedMilliseconds > 15000)
{
timeout = true;
break;
}
}
stopwatch.Stop();
stopwatch.Reset();
Context.Client.MessageReceived -= tryAnswer;
if (timeout)
{
var correctAnswer = HttpUtility.HtmlDecode((string)result["correct_answer"]);
await ReplyAsync($"The answer was: {correctAnswer}!");
await ReplyAsync("No answer was found, skipping to next question!");
continue;
}
await ReplyAsync($"<@{winnerId}> has found the correct answer!");
if (score.ContainsKey(winnerId))
{
score[winnerId]++;
}
else
{
score.Add(winnerId, 1);
}
winnerId = 0;
if (score.ContainsValue(4) || result == responseJson["results"].Last)
{
break;
}
}
var sortedScores = score.OrderBy(s => s.Value).ToList();
var winners = "";
foreach (var points in sortedScores)
{
winners += $"<@{points.Key}> : {points.Value} points\n";
}
var embed = new EmbedBuilder();
embed.WithColor(new Color(0, 255, 0));
embed.WithTitle("Trivia score");
embed.WithDescription(winners);
await ReplyAsync("", false, embed.Build());
Running = false;
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, lastTrivia.AddMinutes(_triviaCooldown));
await ReplyAsync($"You can only start a trivia session once every {_triviaCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("You can't start a trivia session without a license! Check the $shop.");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
else
{
await ReplyAsync("A trivia session is already running!");
}
}
public async Task Rob(IUser user)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
if (user.Id != Context.Message.Author.Id)
{
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
var targetAccount = db.UserAccounts.AsQueryable().Where(u => u.Id == user.Id).FirstOrDefault();
var targetCooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == user.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
if (account.Inventory.ContainsKey("beat_stick"))
{
if (targetAccount != null && targetCooldowns != null)
{
var rob = cooldowns.Rob;
var robbed = targetCooldowns.Robbed;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(rob, "m", _robCooldown);
var isCooledDownTarget = cooldownHandler.IsCooledDown(robbed, "m", _robCooldown);
if (isCooledDown)
{
if (isCooledDownTarget)
{
var rng = new Random();
var robAmount = rng.Next(_minRob, _maxRob);
if (rng.Next(0, 3) > 0)
{
robAmount = (targetAccount.Balance >= robAmount) ? robAmount : targetAccount.Balance;
account.AddBalance(robAmount);
targetAccount.SubtractBalance(robAmount);
await ReplyAsync($"You stole: {robAmount} Kredits!");
}
else
{
robAmount = (account.Balance >= robAmount) ? robAmount : account.Balance;
account.SubtractBalance(robAmount);
targetAccount.AddBalance(robAmount);
await ReplyAsync($"You were beaten up and lost: {robAmount} Kredits!");
}
cooldowns.Rob = DateTime.Now;
targetCooldowns.Robbed = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
db.Update(targetAccount);
db.Update(targetCooldowns);
await db.SaveChangesAsync();
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, robbed.AddMinutes(_robCooldown));
await ReplyAsync($"Your target can only be robbed once every {_robCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, rob.AddMinutes(_robCooldown));
await ReplyAsync($"You can only rob once every {_robCooldown} minutes! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("Your target does not have an account yet!");
}
}
else
{
await ReplyAsync("You need a beat stick to rob people with!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
else
{
await ReplyAsync("You can't rob yourself you idiota!");
}
}
public async Task Work()
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (account != null && cooldowns != null)
{
var pay = _workAmount;
if (account.Inventory.ContainsKey("working_tools"))
{
pay += (25 * account.Inventory["working_tools"]);
}
if (account.Inventory.ContainsKey("doctors_license"))
{
pay *= (1 + account.Inventory["doctors_license"]);
}
var work = cooldowns.Work;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(work, "m", _workCooldown);
if (isCooledDown)
{
var rng = new Random();
var randNr = rng.Next(0, 3);
if (randNr == 0 && account.Inventory.ContainsKey("vaccine"))
{
randNr = 1;
}
if (randNr > 0)
{
account.AddBalance(pay);
cooldowns.Work = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync($"You've earned {pay} Kredits!");
}
else
{
cooldowns.Work = DateTime.Now;
db.Update(cooldowns);
await db.SaveChangesAsync();
await ReplyAsync("You got covid and could not show up to work. Unlucky, I guess.");
}
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, work.AddMinutes(_workCooldown));
await ReplyAsync($"You can only work once every {_workCooldown} minutes!\n" +
$"You still have to wait for {cooldown}!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
}
/// <summary>
/// another async layer to make sure nothing gets stuck <see cref="UpdateDataBaseAsync"/>
/// </summary>
private async Task _updateDataBaseAsync(DateTime start, DateTime finish, bool force)
{
using (var ctx = new CurrencyContext()) {
DateTime checkStart = start.Date; //make sure requested date is not later than the latest downloaded because
//it is assumed that everything is updated until the latest date available
if (!force) //if we should only update what is necessary
{
checkStart = DateTime.Parse((from hc in ctx.HistoricalCurrency select hc.date).ToList().LastOrDefault()).AddDays(1); //latest update to the database
}
if (start < checkStart)
{
start = checkStart; //make sure everything is updated until latest available
}
Task <string>[] taskList = new Task <string> [(finish - start).Days + 1];
for (int i = 0; start <= finish; i++, start = start.AddDays(1)) //each day in date range
{
string parsedDate = ParseDate(start);
taskList[i] = Task <string> .Factory.StartNew(() => {//real concurrency!
string jsonData = "";
using (var wc = new WebClient()) {
for (int j = 0; j < 4; j++) //try 4 times
{
try { //we calculate url here so we get a new key each time
string url = @"http://apilayer.net/api/historical?access_key=" + GetKey() + "&date=" +
parsedDate + @"¤cies=EUR,GBP,ILS,BTC,JMD&format=1";
jsonData = wc.DownloadString(url);
if (jsonData.Contains("success\":true"))//CurrencyClayer's way of saying good
{
break;
}
}
catch (Exception e) {
Console.WriteLine(e.Message);
}
}
}
return(jsonData);
});
}
Task.WaitAll(taskList);//wait for all of the threads to finish
foreach (var item in taskList)
{
if (item.Result == "")
{
continue; //something went wrong
}
HistoricalCurrencyEntity entity =
JsonConvert.DeserializeObject <HistoricalCurrencyEntity>(item.Result);
if (!ctx.HistoricalCurrency.Any(e => e.date == entity.date)) //only add if it's not saved already
{
ctx.HistoricalCurrency.Add(entity);
}
}
await ctx.SaveChangesAsync();
}
}
public async Task SpinRoulette(int bet)
{
if (!CommandHandler.IsPostedInCorrectChannel(Context.Message, GetType().Name))
{
return;
}
using (var db = new CurrencyContext())
{
var account = db.UserAccounts.AsQueryable().Where(u => u.Id == Context.User.Id).FirstOrDefault();
var cooldowns = db.Cooldowns.AsQueryable().Where(c => c.Id == Context.User.Id).FirstOrDefault();
if (bet >= _minWager && bet <= _maxWager)
{
if (account != null && cooldowns != null)
{
if (bet <= account.Balance)
{
var lastRoulette = cooldowns.Roulette;
var cooldownHandler = new CooldownHandler();
var isCooledDown = cooldownHandler.IsCooledDown(lastRoulette, "s", _rouletteCooldown);
if (isCooledDown)
{
var rng = new Random();
if (rng.Next(0, 2) > 0)
{
account.AddBalance(bet);
await ReplyAsync($"You won: {bet} Kredits!");
}
else
{
account.SubtractBalance(bet);
await ReplyAsync($"You lost: {bet} Kredits!");
}
cooldowns.Roulette = DateTime.Now;
db.Update(account);
db.Update(cooldowns);
await db.SaveChangesAsync();
}
else
{
var cooldown = cooldownHandler.GetDifference(DateTime.Now, lastRoulette.AddSeconds(_rouletteCooldown));
await ReplyAsync($"You can only roulette once every {_rouletteCooldown} seconds! \n" +
$"You still have to wait for: {cooldown}!");
}
}
else
{
await ReplyAsync("You can't afford that bet!");
}
}
else
{
await ReplyAsync("You dont have an account yet, type $acc to create one!");
}
}
else
{
await ReplyAsync($"Wager between {_minWager}-{_maxWager} Kredits!");
}
}
}
