public async Task <bool> EndreRS(RuteStopp endreRS)
{
try
{
var etRS = await _db.Rutestopp.FindAsync(endreRS.ID);
if (!etRS.Holdeplass.Sted.Equals(endreRS.Holdeplass.Sted))
{
var sjekkHoldeplass = _db.Holdeplasser.Where(s => s.Sted.Contains(etRS.Holdeplass.Sted));
if (sjekkHoldeplass == null)
{
var holdeplassRad = new Holdeplass();
holdeplassRad.Sted = endreRS.Holdeplass.Sted;
holdeplassRad.Sone = endreRS.Holdeplass.Sone;
etRS.Holdeplass = holdeplassRad;
}
else
{
etRS.Holdeplass = endreRS.Holdeplass;
}
}
etRS.StoppTid = endreRS.StoppTid;
await _db.SaveChangesAsync();
Log.Information("Rutestopp id: {id} endret.", endreRS.ID);
return(true);
}
catch (Exception e)
{
Log.Error("Error i EndreRS: {error}", e);
return(false);
}
}
public RuteStopp NyttRuteStopp(string[] argumenter)
{
Console.WriteLine(argumenter[0]);
Console.WriteLine(argumenter[1]);
Console.WriteLine(argumenter[2]);
string holdeplassNavn = argumenter[0];
string ruteNavn = argumenter[1];
int minutterEtterAvgang = int.Parse(argumenter[2]);
TimeSpan stoppTid = TimeSpan.FromMinutes(minutterEtterAvgang);
Holdeplass holdeplass = _db.Holdeplasser.Where(h => h.Sted == holdeplassNavn).FirstOrDefault();
Rute rute = _db.Ruter.Where(r => r.Navn == ruteNavn).FirstOrDefault();
if (holdeplass != null && rute != null)
{
RuteStopp nyttRuteStopp = new RuteStopp();
nyttRuteStopp.Rute = rute;
nyttRuteStopp.Holdeplass = holdeplass;
nyttRuteStopp.StoppTid = stoppTid;
_db.Rutestopp.Add(nyttRuteStopp);
_db.SaveChanges();
return(nyttRuteStopp);
}
Log.Information("Nytt rutestopp lagt til.");
return(null);
}
public async Task EndreRSLoggetInnFeilInput()
{
var oslo = new Holdeplass {
Sted = "", Sone = 1
};
var OsloStavanger = new Rute {
Navn = "Oslo-Stavanger"
};
var RuteOsloStavangerStoppOslo = new RuteStopp {
Holdeplass = oslo, Rute = OsloStavanger, StoppTid = TimeSpan.FromMinutes(0)
};
mockRep.Setup(k => k.EndreRS(RuteOsloStavangerStoppOslo)).ReturnsAsync(true);
var bestillingController = new AdminController(mockRep.Object);
bestillingController.ModelState.AddModelError("Holdeplass", "Feil i inputvalidering på server");
mockSession[_loggetInn] = _loggetInn;
mockHttpContext.Setup(s => s.Session).Returns(mockSession);
bestillingController.ControllerContext.HttpContext = mockHttpContext.Object;
var resultat = await bestillingController.EndreRS(It.IsAny <RuteStopp>()) as BadRequestObjectResult;
Assert.Equal((int)HttpStatusCode.BadRequest, resultat.StatusCode);
Assert.Equal("Feil i inputvalidering på server", resultat.Value);
}
public async Task HentRuteStoppLoggetInn()
{
var oslo = new Holdeplass {
Sted = "Oslo", Sone = 1
};
var OsloStavanger = new Rute {
Navn = "Oslo-Stavanger"
};
var RuteOsloStavangerStoppOslo = new RuteStopp {
Holdeplass = oslo, Rute = OsloStavanger, StoppTid = TimeSpan.FromMinutes(0)
};
var liste = new List <RuteStopp>();
liste.Add(RuteOsloStavangerStoppOslo);
mockRep.Setup(k => k.HentRuteStopp()).ReturnsAsync(liste);
var bestillingController = new AdminController(mockRep.Object);
mockSession[_loggetInn] = _loggetInn;
mockHttpContext.Setup(s => s.Session).Returns(mockSession);
bestillingController.ControllerContext.HttpContext = mockHttpContext.Object;
var resultat = await bestillingController.HentRuteStopp() as OkObjectResult;
Assert.Equal((int)HttpStatusCode.OK, resultat.StatusCode);
Assert.Equal <List <RuteStopp> >((List <RuteStopp>)resultat.Value, liste);
}
public async Task HentHoldeplasserLoggetInn()
{
var kongsberg = new Holdeplass {
Sted = "Kongsberg", Sone = 2
};
var notodden = new Holdeplass {
Sted = "Notodden", Sone = 3
};
var holdListe = new List <Holdeplass>();
holdListe.Add(kongsberg);
holdListe.Add(notodden);
mockRep.Setup(k => k.HentAlleHoldeplasser()).ReturnsAsync(holdListe);
var bestillingController = new AdminController(mockRep.Object);
mockSession[_loggetInn] = _loggetInn;
mockHttpContext.Setup(s => s.Session).Returns(mockSession);
bestillingController.ControllerContext.HttpContext = mockHttpContext.Object;
var resultat = await bestillingController.AdminHentHoldeplasser() as OkObjectResult;
Assert.Equal((int)HttpStatusCode.OK, resultat.StatusCode);
Assert.Equal <List <Holdeplass> >((List <Holdeplass>)resultat.Value, holdListe);
}
public async Task <bool> LagreHoldeplass(Holdeplass innHoldeplass)
{
try
{
_transportDB.Holdeplass.Add(innHoldeplass);
await _transportDB.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
_log.LogInformation(e.Message);
return(false);
}
}
public async Task <bool> EndreHoldeplass(Holdeplass innHoldeplass)
{
try
{
var endreObjekt = await _transportDB.Holdeplass.FindAsync(innHoldeplass.ID);
endreObjekt.navn = innHoldeplass.navn;
await _transportDB.SaveChangesAsync();
}
catch (Exception e)
{
_log.LogInformation(e.Message);
return(false);
}
return(true);
}
public async Task <ActionResult> HentHoldeplass(int id)
{
if (ModelState.IsValid)
{
Holdeplass enHoldeplass = await _db.HentHoldeplass(id);
if (enHoldeplass == null)
{
Log.Information("Fant ikke holdeplassen");
return(NotFound("Fant ikke holdeplassen"));
}
return(Ok(enHoldeplass));
}
Log.Information("Feil i inputvalidering");
return(BadRequest("Feil i inputvalidering på server"));
}
public async Task <bool> SlettHoldeplass(int id)
{
try
{
Holdeplass enHoldeplass = await _transportDB.Holdeplass.FindAsync(id);
_transportDB.Holdeplass.Remove(enHoldeplass);
await _transportDB.SaveChangesAsync();
return(true);
}
catch (Exception e)
{
_log.LogInformation(e.Message);
return(false);
}
}
public async Task <bool> SlettHoldeplass(int id)
{
try
{
Holdeplass enHoldeplass = await _db.Holdeplasser.FindAsync(id);
_db.Holdeplasser.Remove(enHoldeplass);
await _db.SaveChangesAsync();
}
catch (Exception e)
{
Log.Error("Error i SlettHoldeplass: {error}", e);
Console.Write(e.Message);
return(false);
}
Log.Information("Holdeplass slettet.");
return(true);
}
public async Task <ActionResult> LagreHoldeplass(Holdeplass innHoldeplass)
{
if (string.IsNullOrEmpty(HttpContext.Session.GetString(_loggetInn)))
{
return(Unauthorized("Ikke logget inn"));
}
if (ModelState.IsValid)
{
bool lagreOK = await _db.LagreHoldeplass(innHoldeplass);
if (!lagreOK)
{
Log.Information("Holdeplass kunne ikke lagres");
return(BadRequest("Holdeplass kunne ikke lagres"));
}
return(Ok("Holdeplass lagret"));
}
return(BadRequest("Feil i inputvalidering på server"));
}
public async Task <ActionResult> EndreHoldeplass(Holdeplass endreHoldeplass)
{
if (string.IsNullOrEmpty(HttpContext.Session.GetString(_loggetInn)))
{
return(Unauthorized("Ikke logget inn"));
}
if (ModelState.IsValid)
{
bool returOk = await _db.EndreHoldeplass(endreHoldeplass);
if (!returOk)
{
Log.Information("Endringen av holdeplassen kunne ikke utføres");
return(NotFound("Endringen av holdeplassen kunne ikke utføres"));
}
return(Ok("Holdeplass endret"));
}
Log.Information("Feil i inputvalidering");
return(BadRequest("Feil i inputvalidering på server"));
}
public async Task <bool> LagreHoldeplass(Holdeplass innHP)
{
try
{
var nyHS = new Holdeplass();
nyHS.Sted = innHP.Sted;
nyHS.Sone = innHP.Sone;
_db.Holdeplasser.Add(nyHS);
await _db.SaveChangesAsync();
Log.Information("Holdeplass lagt inn: {holdeplass}", innHP.Sted);
return(true);
}
catch (Exception e)
{
Log.Error("Error i LagreHoldeplass: {error}", e);
return(false);
}
}
public async Task <bool> EndreHoldeplass(Holdeplass endreHoldeplass)
{
try
{
var enHoldeplass = await _db.Holdeplasser.FindAsync(endreHoldeplass.ID);
enHoldeplass.Sted = endreHoldeplass.Sted;
enHoldeplass.Sone = endreHoldeplass.Sone;
await _db.SaveChangesAsync();
Log.Information("Holdeplass id: {id} endret.", endreHoldeplass.ID);
return(true);
}
catch (Exception e)
{
Log.Error("Error i EndreHoldeplass: {error}", e);
return(false);
}
}
public async Task <Holdeplass> HentHoldeplass(int id)
{
try
{
Holdeplass enHoldeplass = await _db.Holdeplasser.FindAsync(id);
var hentetHold = new Holdeplass()
{
ID = enHoldeplass.ID,
Sted = enHoldeplass.Sted,
Sone = enHoldeplass.Sone
};
return(hentetHold);
}
catch (Exception e)
{
Log.Error("Error i HentHoldeplass: {error}", e);
return(null);
}
}
public async Task <ActionResult> GetHoldeplass(Holdeplass holdeplass)
{
if (string.IsNullOrEmpty(HttpContext.Session.GetString(_loggetInn)))
{
return(Unauthorized());
}
if (ModelState.IsValid)
{
bool returOK = await _transportDB.EndreHoldeplass(holdeplass);
if (!returOK)
{
_log.LogInformation("Endringen kunne ikke utføres");
return(NotFound("Endringen kunne ikke utføres"));
}
return(Ok("endret"));
}
_log.LogInformation("Feil i inputvalidering");
return(BadRequest("Feil i inputvalidering på server"));
}
public async Task EndreHoldeplassFeilInput()
{
var holdeplass1 = new Holdeplass {
ID = 1, Sted = "", Sone = 1
};
mockRep.Setup(k => k.EndreHoldeplass(It.IsAny <Holdeplass>())).ReturnsAsync(true);
var bestillingController = new AdminController(mockRep.Object);
bestillingController.ModelState.AddModelError("Sted", "Feil i inputvalidering på server");
mockSession[_loggetInn] = _loggetInn;
mockHttpContext.Setup(s => s.Session).Returns(mockSession);
bestillingController.ControllerContext.HttpContext = mockHttpContext.Object;
var resultat = await bestillingController.EndreHoldeplass(holdeplass1) as BadRequestObjectResult;
Assert.Equal((int)HttpStatusCode.BadRequest, resultat.StatusCode);
Assert.Equal("Feil i inputvalidering på server", resultat.Value);
}
public async Task <RuteStopp> EtRuteStopp(int id)
{
try
{
RuteStopp etRS = await _db.Rutestopp.FindAsync(id);
Holdeplass holdeplass = await _db.Holdeplasser.FindAsync(etRS.Holdeplass.ID);
var hentetRS = new RuteStopp()
{
ID = etRS.ID,
StoppTid = etRS.StoppTid,
Holdeplass = holdeplass
};
return(hentetRS);
}
catch (Exception e)
{
Log.Error("Error i EtRuteStopp: {error}", e);
return(null);
}
}
public async Task <bool> LagreRS(RuteStopp innRS)
{
try
{
var nyRS = new RuteStopp();
nyRS.StoppTid = innRS.StoppTid;
// sjekker om holdeplass allerede ligger i databasen, legger til ny dersom den ikke gjør det
var sjekkHoldeplass = _db.Holdeplasser.Where(navn => navn.Sted.Contains(innRS.Holdeplass.Sted));
if (sjekkHoldeplass == null)
{
// oppretter en ny holdeplass
var nyHoldeplass = new Holdeplass();
nyHoldeplass.Sted = innRS.Holdeplass.Sted;
nyHoldeplass.Sone = innRS.Holdeplass.Sone;
nyRS.Holdeplass = nyHoldeplass;
}
else
{
nyRS.Holdeplass.Sted = innRS.Holdeplass.Sted;
nyRS.Holdeplass.Sone = innRS.Holdeplass.Sone;
}
_db.Rutestopp.Add(nyRS);
await _db.SaveChangesAsync();
Log.Information("Rutestopp lagret.");
return(true);
}
catch (Exception e)
{
Log.Error("Error i LagreRS: {error}", e);
return(false);
}
}
//Returnere en liste med ruteavganger
public List <RuteAvgang> FinnEnRuteAvgang(string[] holdeplasserOgDato) //kan ikke være async pga where
{
JsonSerializerOptions serializerOptions = new JsonSerializerOptions {
PropertyNameCaseInsensitive = true
};
try
{
Holdeplass fra = JsonSerializer.Deserialize <Holdeplass>(holdeplasserOgDato[0], serializerOptions);
Holdeplass til = JsonSerializer.Deserialize <Holdeplass>(holdeplasserOgDato[1], serializerOptions);
Console.WriteLine(fra.ToString() + ", " + til.ToString());
DateTime date = DateTime.ParseExact(holdeplasserOgDato[2], "dd/MM/yyyy HH:mm:ss", CultureInfo.InvariantCulture);
Console.WriteLine(date);
List <RuteAvgang> ruteavganger = new List <RuteAvgang>();
List <Rute> potensielleRuter = new List <Rute>();
//1.Finne rutestopp der holdeplassID tilsvarer holdeplass fraID
//2.Loope rutestopplisten, inni loopen så leter vi etter rutestopp med samme ruteID, som har holdeplassID tilsvarende tilID
//rekkefølgenr større enn fraID sitt rekkefølgenr
//3.Hvis vi finner en eller flere, legger dette til i listen av rutekandidater
foreach (var fraStopp in _db.Rutestopp.Where(r => r.Holdeplass.ID == fra.ID))
{
foreach (var tilStopp in _db.Rutestopp.Where(r => r.Holdeplass.ID == til.ID &&
fraStopp.Rute == r.Rute))
{
potensielleRuter.Add(fraStopp.Rute);
}
/*if (stopp.Holdeplass.ID == til.ID || stopp.Holdeplass.ID>til.ID) {
* potensielleRuter.Add(stopp.Rute);
* }*/
}
if (potensielleRuter.Count > 0)
{
potensielleRuter.ForEach(pr =>
{
Console.WriteLine("En mulig rute er: " + pr.Navn);
});
}
else
{
Console.WriteLine("Ingen potensielle ruter :(");
}
//4.Looper listen av rutekandidater og finner ruteavganger som bruker ruta
//5. Hvis ruteavgangen har riktig dato, legger den til i listen over ruteavganger
foreach (var rute in potensielleRuter)
{
foreach (var ruteavgang in _db.RuteAvganger.Where(ra => ra.Rute.RID == rute.RID))
{
ruteavganger.Add(ruteavgang);
}
}
return(ruteavganger);
}
catch (Exception e)
{
Log.Error("Error i SammeDato: {error}", e);
return(null);
}
}
