Exemple #1
0
        // Metode for å oppdatere verdeiene i et RuteStopp
        public async Task <bool> OppdaterRuteStopp(NyRuteStopp oppdatertRuteStopp)
        {
            try
            {
                // Returnerer false hvis nyttStoppNummer er mindre enn det minste eller større en det største som allerede eksisterer
                int antallRuteStopp = await _db.RuteStopp.Where(rs => rs.Rute.Linjekode == oppdatertRuteStopp.Linjekode).CountAsync();

                int nyttStoppNummer = oppdatertRuteStopp.StoppNummer;
                if (nyttStoppNummer > antallRuteStopp || nyttStoppNummer <= 0)
                {
                    return(false);
                }

                // Fjerner RuteStopp-objektet som skal endres
                bool slettOk = await FjernRuteStopp(oppdatertRuteStopp.Id);

                bool nyOk = await NyRuteStopp(oppdatertRuteStopp);  // Legger til et nytt RuteStopp

                if (slettOk && nyOk)
                {
                    return(true);
                }
                return(false);
            }
            catch (Exception e)
            {
                _log.LogInformation(e.Message);
                return(false);
            }
        }
Exemple #2
0
        public async Task HentEtRuteStopp_Regex()
        {
            // arrange
            NyRuteStopp utRuteStopp = nyttRuteStopp();

            mockRepo.Setup(rs => rs.HentEtRuteStopp(1)).ReturnsAsync(() => null);
            ruteStoppController.ModelState.AddModelError("Stoppnavn", "Feil i inputvalideringen på server");

            //act
            var resultat = await ruteStoppController.HentEtRuteStopp(1) as BadRequestObjectResult;

            //assert
            Assert.Equal("Feil i inputvalideringen på server", resultat.Value);
        }
Exemple #3
0
        public async Task HentEtRuteStopp_Null()
        {
            int id = 1;
            // arrange
            NyRuteStopp utRuteStopp = nyttRuteStopp();

            mockRepo.Setup(rs => rs.HentEtRuteStopp(id)).ReturnsAsync(() => null);

            //act
            var resultat = await ruteStoppController.HentEtRuteStopp(id) as NotFoundObjectResult;

            //assert
            Assert.Equal($"Rutestoppet ble ikke funnet", resultat.Value);
        }
Exemple #4
0
        public async Task NyRuteStopp_Feil()
        {
            // arrange
            NyRuteStopp innRuteStopp = nyttRuteStopp();

            mockRepo.Setup(rs => rs.NyRuteStopp(innRuteStopp)).ReturnsAsync(false);
            MockSession(_innlogget);
            //act
            var resultat = await ruteStoppController.NyRuteStopp(innRuteStopp) as BadRequestObjectResult;

            //assert
            Assert.Equal((int)HttpStatusCode.BadRequest, resultat.StatusCode);
            Assert.Equal($"Nytt RuteStopp kunne ikke lagres med verdiene: {innRuteStopp}", resultat.Value);
        }
Exemple #5
0
        public async Task NyRuteStopp_IkkeTilgang()
        {
            // arrange
            NyRuteStopp innRuteStopp = nyttRuteStopp();

            mockRepo.Setup(rs => rs.NyRuteStopp(innRuteStopp)).ReturnsAsync(true);
            MockSession(_ikkeInnlogget);
            //act
            var resultat = await ruteStoppController.NyRuteStopp(innRuteStopp) as UnauthorizedObjectResult;

            //assert
            Assert.Equal((int)HttpStatusCode.Unauthorized, resultat.StatusCode);
            Assert.Equal("Ikke innlogget", resultat.Value);
        }
Exemple #6
0
        public async Task NyRuteStopp_Riktig()
        {
            // arrange
            NyRuteStopp innRuteStopp = nyttRuteStopp();

            mockRepo.Setup(rs => rs.NyRuteStopp(innRuteStopp)).ReturnsAsync(true);
            MockSession(_innlogget);
            //act
            var resultat = await ruteStoppController.NyRuteStopp(innRuteStopp) as OkObjectResult;

            //assert
            Assert.Equal((int)HttpStatusCode.OK, resultat.StatusCode);
            Assert.Equal($"Nytt RuteStopp ble lagret med verdiene: {innRuteStopp}", resultat.Value);
        }
Exemple #7
0
        public async Task OppdaterRuteStopp_Feil()
        {
            // arrange
            NyRuteStopp innRuteStopp = nyttRuteStopp();

            mockRepo.Setup(rs => rs.OppdaterRuteStopp(innRuteStopp)).ReturnsAsync(false);
            MockSession(_innlogget);
            //act
            var resultat = await ruteStoppController.OppdaterRuteStopp(innRuteStopp) as NotFoundObjectResult;

            //assert
            Assert.Equal((int)HttpStatusCode.NotFound, resultat.StatusCode);
            Assert.Equal($"Endringen av RuteStopp kunne ikke utføres med verdiene: {innRuteStopp}", resultat.Value);
        }
Exemple #8
0
        public async Task HentEtRuteStopp_Riktig()
        {
            // arrange
            NyRuteStopp utRuteStopp = nyttRuteStopp();

            mockRepo.Setup(rs => rs.HentEtRuteStopp(1)).ReturnsAsync(utRuteStopp);

            //act
            var resultat = await ruteStoppController.HentEtRuteStopp(1) as OkObjectResult;

            NyRuteStopp faktiskRuteStopp = (NyRuteStopp)resultat.Value;

            //assert
            Assert.Equal(utRuteStopp.ToString(), faktiskRuteStopp.ToString());
        }
Exemple #9
0
        public async Task NyRuteStopp_Regex()
        {
            // arrange
            NyRuteStopp innRuteStopp = nyttRuteStopp();

            mockRepo.Setup(rs => rs.NyRuteStopp(innRuteStopp)).ReturnsAsync(true);
            ruteStoppController.ModelState.AddModelError("Linjekode", "Feil i inputvalideringen på server");
            MockSession(_innlogget);

            //act
            var resultat = await ruteStoppController.NyRuteStopp(innRuteStopp) as BadRequestObjectResult;

            //assert
            Assert.Equal((int)HttpStatusCode.BadRequest, resultat.StatusCode);
            Assert.Equal("Feil i inputvalideringen på server", resultat.Value);
        }
        public async Task <ActionResult> HentEtRuteStopp(int id)
        {
            if (ModelState.IsValid)
            {
                NyRuteStopp ruteStopp = await _db.HentEtRuteStopp(id);

                if (ruteStopp == null)
                {
                    melding = $"Rutestoppet ble ikke funnet";
                    _log.LogWarning(melding);
                    return(NotFound(melding));
                }
                return(Ok(ruteStopp));
            }
            _log.LogWarning(ugyldigValidering);
            return(BadRequest(ugyldigValidering));
        }
Exemple #11
0
        public async Task <NyRuteStopp> HentEtRuteStopp(int id)
        {
            try
            {
                RuteStopp ruteStopp = await _db.RuteStopp.FindAsync(id);

                NyRuteStopp utRuteStopp = new NyRuteStopp
                {
                    Stoppnavn             = ruteStopp.Stopp.Navn,
                    StoppNummer           = ruteStopp.StoppNummer,
                    MinutterTilNesteStopp = ruteStopp.MinutterTilNesteStopp,
                    Linjekode             = ruteStopp.Rute.Linjekode
                };
                return(utRuteStopp);
            }
            catch (Exception e)
            {
                _log.LogInformation(e.Message);
                return(null);
            }
        }
        public async Task <ActionResult> NyRuteStopp(NyRuteStopp innRuteStopp)
        {
            if (string.IsNullOrEmpty(HttpContext.Session.GetString(_innlogget)))
            {
                return(Unauthorized("Ikke innlogget"));
            }
            if (ModelState.IsValid)
            {
                bool returOK = await _db.NyRuteStopp(innRuteStopp);

                if (!returOK)
                {
                    melding = $"Nytt RuteStopp kunne ikke lagres med verdiene: {innRuteStopp}";
                    _log.LogWarning(melding);
                    return(BadRequest(melding));
                }
                melding = $"Nytt RuteStopp ble lagret med verdiene: {innRuteStopp}";
                _log.LogInformation(melding);
                return(Ok(melding));
            }
            _log.LogWarning(ugyldigValidering);
            return(BadRequest(ugyldigValidering));
        }
        public async Task <ActionResult> OppdaterRuteStopp(NyRuteStopp ruteStoppOppdater)
        {
            if (string.IsNullOrEmpty(HttpContext.Session.GetString(_innlogget)))
            {
                return(Unauthorized("Ikke innlogget"));
            }
            if (ModelState.IsValid)
            {
                bool returOK = await _db.OppdaterRuteStopp(ruteStoppOppdater);

                if (!returOK)
                {
                    melding = $"Endringen av RuteStopp kunne ikke utføres med verdiene: {ruteStoppOppdater}";
                    _log.LogWarning(melding);
                    return(NotFound(melding));
                }
                melding = $"Endringen av RuteStopp ble utført med verdiene: {ruteStoppOppdater}";
                _log.LogInformation(melding);
                return(Ok(melding));
            }
            _log.LogWarning(ugyldigValidering);
            return(BadRequest(ugyldigValidering));
        }
Exemple #14
0
        public async Task <bool> NyRuteStopp(NyRuteStopp innRuteStopp)
        {
            try
            {
                // Returnerer false hvis nyttStoppNummer er mindre enn det minste eller større en det største som allerede eksisterer
                int antallRuteStopp = await _db.RuteStopp.Where(rs => rs.Rute.Linjekode == innRuteStopp.Linjekode).CountAsync();

                int nyttStoppNummer = innRuteStopp.StoppNummer;
                if (nyttStoppNummer > antallRuteStopp + 1 || nyttStoppNummer <= 0)
                {
                    return(false);
                }

                // Henter alle RuteStopp fra samme rute som har likt eller høyre stoppnummer enn det nye stoppet
                List <RuteStopp> endreStoppNummer = await LiktEllerSenereStoppNummer(innRuteStopp.StoppNummer, innRuteStopp.Linjekode);

                // Adderer alle med stoppnummer som er større eller lik det nye rutestoppet med 1
                foreach (RuteStopp rs in endreStoppNummer)
                {
                    rs.StoppNummer++;
                }

                // Henter ruten til det nye RuteStopp-objektet
                Ruter rute = await _db.Ruter.FindAsync(innRuteStopp.Linjekode);

                // Nytt RuteStopp-objekt
                RuteStopp nyttRuteStopp = new RuteStopp
                {
                    Id                    = innRuteStopp.Id,
                    StoppNummer           = innRuteStopp.StoppNummer,
                    MinutterTilNesteStopp = innRuteStopp.MinutterTilNesteStopp,
                    Rute                  = rute
                };

                // Sjekker om det allerede eksisterer et stopp med tilsvarende navn i DB
                Stopp eksisterendeStopp = await _db.Stopp
                                          .Where(s => s.Navn == innRuteStopp.Stoppnavn).SingleOrDefaultAsync();

                // Hvis det eksiterer blir dette Stopp-objektet brukt
                if (eksisterendeStopp != null)
                {
                    nyttRuteStopp.Stopp = eksisterendeStopp;
                }
                // Hvis det ikke eksiterer blir et nytt Stopp-okbjekt lagt til
                else
                {
                    Stopp nyttStopp = new Stopp {
                        Navn = innRuteStopp.Stoppnavn
                    };
                    nyttRuteStopp.Stopp = nyttStopp;
                }

                _db.RuteStopp.Add(nyttRuteStopp);
                await _db.SaveChangesAsync();

                return(true);
            }
            catch (Exception e)
            {
                _log.LogInformation(e.Message);
                return(false);
            }
        }