public async Task <IActionResult> Moment(string id)
{
if (string.IsNullOrEmpty(id) || !int.TryParse(id, out var i))
{
var moment = new TelMomentHouder {
Beurzen = new List <TelMomentModel>()
};
foreach (var beurs in await BeurzenManager.GetBeurzenAsync())
{
moment.Beurzen.Add(new TelMomentModel
{
BeursId = beurs.BeursId,
BeursNaam = beurs.Naam,
});
}
return(View(moment));
}
using (var db = new ApplicationDbContext())
{
var moment = await db.TelMomenten.Include(x => x.Beurzen)
.SingleAsync(x => x.TelMomentHouderId == i);
return(View(moment));
}
}
private static async Task ModifyBeurs(AdminBeursModel model)
{
var beurs = model.Beurs;
using (var db = new ApplicationDbContext())
{
var dbBeurs = await db.Beurzen.Include(x => x.Waardes)
.FirstOrDefaultAsync(x => x.BeursId == beurs.BeursId);
var laatste = dbBeurs.Waardes.LastOrDefault();
if (laatste != null)
{
laatste.Waarde = model.NieuweWaarde;
db.Update(laatste);
}
dbBeurs.AantalLeden = model.Beurs.AantalLeden;
dbBeurs.BeschikbareAandelen = model.Beurs.BeschikbareAandelen;
dbBeurs.VorigeBeschikbareAandelen = model.Beurs.BeschikbareAandelen;
dbBeurs.Naam = model.Beurs.Naam;
dbBeurs.Omschrijving = model.Beurs.Omschrijving;
db.Update(dbBeurs);
beurs = dbBeurs;
await db.SaveChangesAsync();
}
await BeurzenManager.ModifyBeurs(beurs);
}
public async Task <IActionResult> Beurs(string id)
{
var errors = TempData.Get <List <string> >("errors");
if (errors != null)
{
var errorType = TempData.Get <string>("errorType");
foreach (var error in errors)
{
ModelState.AddModelError(errorType, error);
}
}
if (string.IsNullOrEmpty(id))
{
return(RedirectToAction("Index"));
}
Beurs beurs;
if (!int.TryParse(id, out var index))
{
beurs = await BeurzenManager.GetBeursMetNaamAsync(id);
}
else
{
beurs = await GetBeurs(index);
}
if (beurs == null)
{
return(StatusCode(404));
}
if (!User.Identity.IsAuthenticated)
{
return(View(new BeursModel {
Beurs = beurs, Aantal = 0
}));
}
var aantal = 0;
var gebruiker = await GetGebruikerWithAandelen(HttpContext);
var ah = gebruiker.Aandelen?.FirstOrDefault(x =>
x.ApplicationUserId == gebruiker.Id && x.BeursId == beurs.BeursId);
if (ah != null)
{
aantal = ah.Aantal;
}
var geld = gebruiker.Geld;
return(View(new BeursModel {
Beurs = beurs, Aantal = aantal, GebruikerGeld = geld
}));
}
public async Task <IActionResult> Beurs(string id)
{
if (id == null)
{
return(View(null));
}
if (!int.TryParse(id, out var i))
{
return(View(null));
}
var beurs = await BeurzenManager.GetBeursAsync(i);
return(View(new AdminBeursModel
{
Beurs = beurs,
NieuweWaarde = beurs.HuidigeWaarde
}));
}
public async Task <IActionResult> ModifyStocks(string id, string beurs, string verschil)
{
if (!int.TryParse(verschil, out var num))
{
return(BadRequest());
}
if (!int.TryParse(beurs, out var beursId))
{
return(BadRequest());
}
var beursobj = await BeurzenManager.GetBeursAsync(beursId);
using (var db = new ApplicationDbContext())
{
var user = await db.Users.Include(x => x.Aandelen).SingleOrDefaultAsync(x => x.Id == id);
if (user.Aandelen == null)
{
user.Aandelen = new List <AandeelHouder>();
}
var aandeelHouder = user.Aandelen.SingleOrDefault(
x => x.BeursId == beursId && x.ApplicationUserId == user.Id);
if (aandeelHouder == null && num > 0)
{
user.Aandelen.Add(new AandeelHouder
{
Aantal = num,
ApplicationUser = user,
ApplicationUserId = user.Id,
BeursId = beursId
});
}
else if (aandeelHouder != null)
{
aandeelHouder.Aantal += num;
if (aandeelHouder.Aantal < 0)
{
aandeelHouder.Aantal = 0;
}
}
await db.SaveChangesAsync();
}
return(Ok());
}
// GET
public async Task <IActionResult> Index()
{
var beurzen = await BeurzenManager.GetBeurzenAsync();
Dictionary <int, int> aantallen;
var userId = User.GetUserId();
using (var db = new ApplicationDbContext())
{
aantallen = await db.Aandelen.Where(x => x.ApplicationUserId == userId)
.ToDictionaryAsync(x => x.BeursId, x => x.Aantal);
}
return(View(new BeursLijstModel
{
Beurzen = beurzen,
AandeelAantallen = aantallen
}));
}
public async Task <IActionResult> DeleteBeurs(string id)
{
if (id == null)
{
return(BadRequest());
}
if (!int.TryParse(id, out var i))
{
return(BadRequest());
}
using (var db = new ApplicationDbContext())
{
db.Beurzen.Remove(db.Beurzen.Find(i));
db.Aandelen.RemoveRange(db.Aandelen.Where(x => x.BeursId == i));
await db.SaveChangesAsync();
}
BeurzenManager.DeleteBeurs(i);
return(Ok());
}
public async Task <IActionResult> ResetBeursspel()
{
using (var db = new ApplicationDbContext())
{
foreach (var applicationUser in db.Users)
{
applicationUser.Aandelen = new List <AandeelHouder>();
applicationUser.Geld = Settings.StartSpelerGeld;
ApplicationUser.ResetCache();
}
db.Database.ExecuteSqlCommand("DELETE FROM \"AandeelHouder\"");
db.Database.ExecuteSqlCommand("DELETE FROM \"BeursWaardes\"");
db.Database.ExecuteSqlCommand("DELETE FROM \"TelMomentModel\"");
db.Database.ExecuteSqlCommand("DELETE FROM \"TelMomenten\"");
await BeurzenManager.ClearCache();
foreach (var beurs in db.Beurzen)
{
beurs.Waardes = new List <BeursWaardes>
{
new BeursWaardes
{
Beurs = beurs,
BeursId = beurs.BeursId,
Tijd = DateTime.Now,
Type = BeursWaardes.WaardeType.Onbekend,
Waarde = Settings.StartBeursWaarde
}
};
beurs.BeschikbareAandelen = Settings.StartBeursBeschikbareAandelen;
beurs.VorigeBeschikbareAandelen = Settings.StartBeursBeschikbareAandelen;
}
await db.SaveChangesAsync();
}
var berekenSpelerWaardes = new Tasks.BerekenSpelerWaardes();
await berekenSpelerWaardes.ExecuteAsync();
return(Ok());
}
public static async Task BerekenBeurzen()
{
using (var db = new ApplicationDbContext())
{
//Haal de beurzen uit de database, itereer over hen
var beurzen = await db.Beurzen.Include(x => x.Waardes).ToListAsync();
foreach (var beurs in beurzen)
{
beurs.Waardes.Sort((x, y) => DateTime.Compare(x.Tijd, y.Tijd));
var huidigeAandelen = beurs.BeschikbareAandelen;
var vorigeAandelen = beurs.VorigeBeschikbareAandelen;
var verschil = huidigeAandelen - vorigeAandelen;
var huidigeWaarde = beurs.HuidigeWaarde;
var verschilProportie = (float)verschil / Settings.StartBeursBeschikbareAandelen;
var nieuweWaarde = huidigeWaarde - (huidigeWaarde * 0.05f * verschilProportie);
if (nieuweWaarde < 1)
{
nieuweWaarde = 1;
}
beurs.Waardes.Add(new BeursWaardes
{
Beurs = beurs,
BeursId = beurs.BeursId,
Tijd = DateTime.Now,
Type = BeursWaardes.WaardeType.VraagAanbod,
Waarde = nieuweWaarde
});
beurs.VorigeBeschikbareAandelen = huidigeAandelen;
db.Update(beurs);
}
await BeurzenManager.SetCache(beurzen);
await db.SaveChangesAsync();
}
}
private static async Task <int> CreateBeurs(Beurs beurs)
{
beurs.Waardes = new List <BeursWaardes>
{
new BeursWaardes
{
Beurs = beurs,
BeursId = beurs.BeursId,
Tijd = DateTime.Now,
Type = BeursWaardes.WaardeType.Onbekend,
Waarde = Settings.StartBeursWaarde
}
};
beurs.VorigeBeschikbareAandelen = beurs.BeschikbareAandelen;
using (var db = new ApplicationDbContext())
{
await db.Beurzen.AddAsync(beurs);
await db.SaveChangesAsync();
}
await BeurzenManager.AddBeurs(beurs);
return(beurs.BeursId);
}
private static async Task <Beurs> GetBeurs(int id)
{
return(await BeurzenManager.GetBeursAsync(id));
}
public async Task <IActionResult> Beurzen()
{
var beurzen = await BeurzenManager.GetBeurzenAsync();
return(View(beurzen));
}
public static async Task BerekenBeurzen(TelMomentHouder telMoment)
{
using (var db = new ApplicationDbContext())
{
//Haal de beurzen uit de database, itereer over hen
var beurzen = await db.Beurzen.Include(x => x.Waardes).ToListAsync();
foreach (var beurs in beurzen)
{
//We moeten zeker zijn dat de waarde geordend zijn op tijd
beurs.Waardes = beurs.Waardes.OrderBy(x => x.Tijd).ToList();
//als er al een waarde is die uitgerekend is door aanwezigheid, en dezelfde tijd als deze heeft
//zijn we deze aan het bewerken
if (beurs.Waardes.Any(x => x.Type == BeursWaardes.WaardeType.Aanwezigheid &&
x.Tijd == telMoment.Tijd))
{
//We pakken de beurs waar het telmoment naar verwijst aan de hand van het beurs id
var telBeurs = telMoment.Beurzen.FirstOrDefault(x => x.BeursId == beurs.BeursId);
if (telBeurs == null)
{
throw new NullReferenceException("Beurs is null.");
}
//pak de telmomenten voor de huidige beurs die niet het huidige moment zijn, en die
//voor dit telmoment hebben plaatsgevonden. We nemen hier de laatste drie van.
var telMomenten = await db.TelMomentModel.
Where(x => x.BeursId == beurs.BeursId && x.TelMomentModelId != telBeurs.TelMomentModelId &&
x.Tijd < telMoment.Tijd)
.OrderByDescending(x => x.Tijd)
.Take(3)
.ToListAsync();
//bereken de beurswaarde
var waarde = BerekenBeurs(beurs, telMomenten, telBeurs);
//verwijder de oude waarde
beurs.Waardes.Remove(beurs.Waardes
.FirstOrDefault(x => x.Type == BeursWaardes.WaardeType.Aanwezigheid &&
x.Tijd == telMoment.Tijd));
//voeg de geupdate waarde toe
beurs.Waardes.Add(waarde);
}
else
{
//We pakken de beurs waar het telmoment naar verwijst aan de hand van het beurs id
var telBeurs = telMoment.Beurzen.FirstOrDefault(x => x.BeursId == beurs.BeursId);
if (telBeurs == null)
{
throw new NullReferenceException("Beurs is null.");
}
//pak de telmomenten voor de huidige beurs die niet het huidige moment zijn,
// We nemen hier de laatste drie van.
var telMomenten = await db.TelMomentModel.
Where(x => x.BeursId == beurs.BeursId && x.TelMomentModelId != telBeurs.TelMomentModelId)
.OrderByDescending(x => x.Tijd)
.Take(3)
.ToListAsync();
//bereken de beurswaarde
var waarde = BerekenBeurs(beurs, telMomenten, telBeurs);
//voeg de geupdate waarde toe
beurs.Waardes.Add(waarde);
//update de beurs
db.Update(beurs);
}
}
//verwijder de locale cache, en update deze met de nieuwe beruzen
await BeurzenManager.SetCache(beurzen);
//sla de veranderingen in de database op
await db.SaveChangesAsync();
}
}