Beispiel #1
0
        public bool Endre(Fly fly)
        {
            using (var db = new DB())
            {
                try
                {
                    var dbflyentitet = db.Fly.Find(fly.ID);
                    dbflyentitet.Modell      = fly.Modell;
                    dbflyentitet.AntallSeter = fly.AntallSeter;

                    db.Endringer.Add(new DBEndring()
                    {
                        Endring   = "Oppdaterte fly med id " + ID + ". Flymodell er " + dbflyentitet.Modell + ", antall seter " + dbflyentitet.AntallSeter,
                        Tidspunkt = DateTime.Now
                    });

                    db.SaveChanges();
                    return(true);
                } catch (Exception e)
                {
                    DALsetup.LogFeilTilFil("DBFly:Endre", e, "En feil oppsto da metoden prøvde å oppdatere fly");
                    return(false);
                }
            }
        }
Beispiel #2
0
        public bool Slett(int ID)
        {
            using (var db = new DB())
            {
                var fly = db.Fly.Find(ID);

                if (fly != null)
                {
                    db.Fly.Remove(fly);
                    db.Endringer.Add(new DBEndring()
                    {
                        Endring   = "Slettet fly med id " + ID,
                        Tidspunkt = DateTime.Now
                    });
                    try
                    {
                        db.SaveChanges();
                        return(true);
                    }
                    catch (Exception e)
                    {
                        DALsetup.LogFeilTilFil("DBFly:Slett", e, "En feil oppsto da metoden prøvde å slette fly med ID " + ID);
                        return(false);
                    }
                }
                return(false);
            }
        }
        public bool Slett(string referanse)
        {
            using (var db = new DB())
            {
                var dbbestilling = db.Bestillinger.Include("FlygningerTur").Include("FlygningerRetur").FirstOrDefault(best => best.Referanse == referanse);
                if (dbbestilling != null)
                {
                    db.Bestillinger.Remove(dbbestilling);

                    db.Endringer.Add(new DBEndring()
                    {
                        Endring   = "Slettet bestilling med referanse " + referanse,
                        Tidspunkt = DateTime.Now
                    });


                    try
                    {
                        db.SaveChanges();
                    }
                    catch (Exception e)
                    {
                        DALsetup.LogFeilTilFil("DBBestilling:Slett", e, "En feil oppsto da metoden prøvde å slette bestilling med referanse" + referanse);
                        return(false);
                    }

                    return(true);
                }
                return(false);
            }
        }
        public bool Endre(int id, DateTime nyAvgangstid)
        {
            using (var db = new DB())
            {
                try
                {
                    var eksisterendeFlygning = db.Flygninger.Find(id);
                    if (eksisterendeFlygning != null)
                    {
                        eksisterendeFlygning.AvgangsTid = nyAvgangstid;
                        db.Endringer.Add(new DBEndring()
                        {
                            Endring   = $"Endret avgangstid på flygning {id}. Ny avgangstid {nyAvgangstid}.",
                            Tidspunkt = DateTime.Now
                        });

                        db.SaveChanges();
                        return(true);
                    }

                    db.Endringer.Add(new DBEndring()
                    {
                        Endring   = $"Prøvde å endre en flygning som ikke eksisterte: {id}",
                        Tidspunkt = DateTime.Now
                    });
                    db.SaveChanges();
                }
                catch (Exception e)
                {
                    DALsetup.LogFeilTilFil("DBFlygning:Endre", e.InnerException, $"Feil under lagring til databasen, med id: {id}");
                }

                return(false);
            }
        }
        public bool LeggInn(Flyplass flyplass)
        {
            using (var db = new DB())
            {
                try
                {
                    var dbflyplass = Mapper.Map <DBFlyplass>(flyplass);
                    if (db.Flyplasser.FirstOrDefault(fly => fly.ID == dbflyplass.ID) == null)
                    {
                        db.Flyplasser.Add(dbflyplass);

                        db.Endringer.Add(new DBEndring()
                        {
                            Tidspunkt = DateTime.Now,
                            Endring   = $"Legg til flyplass med ID {dbflyplass.ID}, nye verdier: {dbflyplass.Navn}, {dbflyplass.By}, {dbflyplass.Land}"
                        });

                        db.SaveChanges();
                        return(true);
                    }
                }
                catch (Exception e)
                {
                    DALsetup.LogFeilTilFil("DBFlyplass:LeggInn", e, "En feil oppsto da metoden prøvde å legge inn flyplass");
                }
            }
            return(false);
        }
 public bool LeggInn(Flygning flygning)
 {
     using (var db = new DB())
     {
         var dbflygning = Mapper.Map <DBFlygning>(flygning);
         try
         {
             dbflygning.Rute = db.Ruter.Find(dbflygning.Rute.ID);
             db.Flyplasser.Find(dbflygning.Rute.Fra.ID);
             db.Flyplasser.Find(dbflygning.Rute.Til.ID);
             dbflygning.Fly = db.Fly.Find(dbflygning.Fly.ID);
             db.Flygninger.Add(dbflygning);
             db.Endringer.Add(new DBEndring()
             {
                 Endring   = "La til flygning ny flygning mellom: " + dbflygning.Rute.Fra.ID + " - " + dbflygning.Rute.Til.ID,
                 Tidspunkt = DateTime.Now
             });
             db.SaveChanges();
             return(true);
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBFlygning:LeggInn", e.InnerException, "Feil under lagring til databasen");
             return(false);
         }
     }
 }
 public bool EndreStatus(int id)
 {
     using (var db = new DB())
     {
         try
         {
             DBFlygning dbflygning = db.Flygninger.Include("Bestillinger").Where(item => item.ID == id).FirstOrDefault();
             if (dbflygning != null)
             {
                 if (dbflygning.AvgangsTid < DateTime.Now && dbflygning.Bestillinger.Count() == 0)
                 {
                     return(false);
                 }
                 dbflygning.Kansellert = !dbflygning.Kansellert;
             }
             string kansellert = dbflygning.Kansellert == true ? "kansellert" : "aktiv";
             db.Endringer.Add(new DBEndring()
             {
                 Tidspunkt = DateTime.Now,
                 Endring   = $"Endret status på flygning {dbflygning.ID} til å være {kansellert}"
             });
             db.SaveChanges();
             return(true);
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBFlygning:EndreStatus", e, "En feil oppsto da metoden prøvde å oppdatere status på flygning");
             return(false);
         }
     }
 }
Beispiel #8
0
        public List <FeilFraFilViewModel> ParseFeil(string filePath)
        {
            List <FeilFraFilViewModel> feil = new List <FeilFraFilViewModel>();

            try
            {
                StreamReader read = File.OpenText(Path.Combine(System.AppDomain.CurrentDomain.BaseDirectory, filePath));
                string       line;
                while ((line = read.ReadLine()) != null)
                {
                    string[]            parts      = Regex.Split(line, ": ");
                    FeilFraFilViewModel feilObjekt = new FeilFraFilViewModel
                    {
                        Tidspunkt   = parts[0],
                        Feilmelding = parts[1]
                    };
                    feil.Add(feilObjekt);
                }
            }
            catch (Exception e)
            {
                DALsetup.LogFeilTilFil(System.Reflection.MethodBase.GetCurrentMethod().Name, e, "En feil skjedde når metoden prøvde å tolke linjene i " + filePath);
            }
            return(feil);
        }
 public bool Endre(Kunde kunde)
 {
     using (var db = new DB())
     {
         try
         {
             var dbkundeEntitet = db.Kunder.Find(kunde.ID);
             dbkundeEntitet.Fornavn    = kunde.Fornavn;
             dbkundeEntitet.Etternavn  = kunde.Etternavn;
             dbkundeEntitet.Fodselsdag = kunde.Fodselsdag;
             dbkundeEntitet.Tlf        = kunde.Tlf;
             dbkundeEntitet.Adresse    = kunde.Adresse;
             dbkundeEntitet.EPost      = kunde.EPost;
             dbkundeEntitet.Postnummer = db.Poststeder.Find(kunde.Postnr);
             db.Endringer.Add(new DBEndring()
             {
                 Tidspunkt = DateTime.Now,
                 Endring   = $"Endret på kunde {kunde.ID}, nye verdier: {kunde.Fornavn} {kunde.Etternavn}, {kunde.Adresse}, {kunde.Postnr} {dbkundeEntitet.Postnummer.Poststed}"
             });
             db.SaveChanges();
             return(true);
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBKunde:Endre", e, $"En feil oppsto da metoden prøvde å oppdatere kunde.");
             return(false);
         }
     }
 }
        public List <Kunde> HentAlle()
        {
            using (var db = new DB())
            {
                try
                {
                    var dbkunder = db.Kunder.Include("Postnummer").ToList();
                    var kunder   = new List <Kunde>();
                    foreach (var kunde in dbkunder)
                    {
                        var domenekunde = Mapper.Map <Kunde>(kunde);

                        domenekunde.Postnr   = kunde.Postnummer.Postnr;
                        domenekunde.Poststed = kunde.Postnummer.Poststed;

                        kunder.Add(domenekunde);
                    }
                    return(kunder);
                }catch (Exception e)
                {
                    DALsetup.LogFeilTilFil("DBKunde:HentAlle", e, "En feil oppsto da metoden prøvde å hente alle kundene.");
                    return(null);
                }
            }
        }
        public Bestilling Hent(string referanse)
        {
            Bestilling bestilling = null;

            if (referanse == null)
            {
                return(bestilling);
            }

            referanse = referanse.ToUpper().Trim();
            var  regex   = new Regex("^[A-Z0-9]{6}$");
            bool isMatch = regex.IsMatch(referanse);

            try
            {
                if (isMatch)
                {
                    using (var db = new DB())
                    {
                        var dbbestilling = db.Bestillinger.Include("Passasjerer.Postnummer").Where(best => best.Referanse == referanse).FirstOrDefault();
                        bestilling = Mapper.Map <Bestilling>(dbbestilling);
                    }
                }
            }
            catch (Exception e)
            {
                DALsetup.LogFeilTilFil("DBBestilling:HentAlle", e, "En feil oppsto når metoden prøvde å finne bestilling med referanse " + referanse);
            }

            return(bestilling);
        }
Beispiel #12
0
        public bool Slett(int id)
        {
            using (var db = new DB())
            {
                var rute = db.Ruter.FirstOrDefault(r => r.ID == id);
                if (rute != null)
                {
                    db.Endringer.Add(new DBEndring()
                    {
                        Endring   = $"Fjernet rute med ID: {rute.ID}",
                        Tidspunkt = DateTime.Now
                    });
                    db.Ruter.Remove(rute);

                    try
                    {
                        db.SaveChanges();
                        return(true);
                    }
                    catch (Exception exception)
                    {
                        DALsetup.LogFeilTilFil("DBRute.Slett", exception, "En feil oppsto da metoden prøvde å slette rute.");
                    }
                }
                return(false);
            }
        }
Beispiel #13
0
        public bool Endre(Rute innrute)
        {
            using (var db = new DB())
            {
                var rute        = db.Ruter.FirstOrDefault(r => r.ID == innrute.ID);
                var fraFlyplass = db.Flyplasser.FirstOrDefault(flyplass => flyplass.ID == innrute.Fra.ID);
                var tilFlyplass = db.Flyplasser.FirstOrDefault(flyplass => flyplass.ID == innrute.Til.ID);
                if (rute != null && fraFlyplass != null && tilFlyplass != null)
                {
                    rute.Fra      = fraFlyplass;
                    rute.Til      = tilFlyplass;
                    rute.Reisetid = innrute.Reisetid;
                    rute.BasePris = innrute.BasePris;

                    db.Endringer.Add(new DBEndring()
                    {
                        Endring   = $"Endrer rute med nye verdier. Ny verdier: fra flyplass: {rute.Fra.ID}, til flyplass: {rute.Til.ID}, reisetid: {rute.Reisetid}, pris: {rute.BasePris} ",
                        Tidspunkt = DateTime.Now
                    });

                    try
                    {
                        db.SaveChanges();
                        return(true);
                    }
                    catch (Exception e)
                    {
                        DALsetup.LogFeilTilFil("DBRute:Endre", e, "En feil oppsto da metoden prøvde å endre rute.");
                    }
                }
                return(false);
            }
        }
        public bool LeggInn(Admin admin)
        {
            using (var db = new DB())
            {
                try
                {
                    if (admin != null)
                    {
                        var     salt    = LagSalt();
                        DBAdmin dbadmin = new DBAdmin()
                        {
                            Brukernavn = admin.Brukernavn,
                            Salt       = salt,
                            Passord    = HashPassord(admin.Passord, salt)
                        };
                        db.Administratorer.Add(dbadmin);

                        db.Endringer.Add(new DBEndring()
                        {
                            Tidspunkt = DateTime.Now,
                            Endring   = "Legg til administrator med brukernavn " + admin.Brukernavn
                        });
                        db.SaveChanges();
                        return(true);
                    }
                    return(false);
                } catch (Exception e)
                {
                    DALsetup.LogFeilTilFil("DBAdmin:LeggInn", e, "En feil oppsto da metoden prøvde å legge inn administrator med brukernavn " + admin.Brukernavn);
                    return(false);
                }
            }
        }
 public bool Slett(string username)
 {
     using (var db = new DB())
     {
         try
         {
             var admin = db.Administratorer.Where(kunde => kunde.Brukernavn == username).FirstOrDefault();
             if (admin != null)
             {
                 db.Administratorer.Remove(admin);
                 db.Endringer.Add(new DBEndring()
                 {
                     Tidspunkt = DateTime.Now,
                     Endring   = $"Slettet administrator {admin.Brukernavn} "
                 });
                 db.SaveChanges();
                 return(true);
             }
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBAdmin:Slett", e, "En feil oppsto da metoden prøvde å slette administrator.");
         }
         return(false);
     }
 }
 public bool EndrePassord(string username, string password)
 {
     using (var db = new DB())
     {
         try
         {
             var salt  = LagSalt();
             var hash  = HashPassord(password, salt);
             var admin = db.Administratorer.Find(username);
             admin.Passord = hash;
             admin.Salt    = salt;
             db.Endringer.Add(new DBEndring()
             {
                 Tidspunkt = DateTime.Now,
                 Endring   = "Endrer passord på admin " + username
             });
             db.SaveChanges();
             return(true);
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBAdmin:EndrePassord", e, "En feil oppsto da metoden prøvde å endre passordet til admin " + username);
         }
     }
     return(false);
 }
        public void LeggInn(Bestilling bestilling)
        {
            using (var db = new DB())
            {
                try
                {
                    var dbbestilling = Mapper.Map <DBBestilling>(bestilling);
                    var a            = db.Entry(dbbestilling);

                    List <DBKunde> kunder  = new List <DBKunde>();
                    DBKunde        dbKunde = new DBKunde();
                    foreach (var kunde in bestilling.Passasjerer)
                    {
                        dbKunde.LeggInn(kunde);
                        var dkunde = db.Kunder.Include("Postnummer").Where(k => k.Etternavn == kunde.Etternavn && k.Fornavn == kunde.Fornavn && k.Tlf == kunde.Tlf).FirstOrDefault();
                        kunder.Add(dkunde);
                        if (!db.Poststeder.Local.Any(e => e.Postnr == dkunde.Postnummer.Postnr))
                        {
                            db.Entry(dkunde.Postnummer).State = EntityState.Unchanged;
                        }
                    }
                    dbbestilling.Passasjerer = kunder;

                    List <DBFlygning> flygninger = new List <DBFlygning>();
                    foreach (var flygning in dbbestilling.FlygningerTur)
                    {
                        flygninger.Add(db.Flygninger.Find(flygning.ID));
                    }
                    dbbestilling.FlygningerTur = flygninger;

                    flygninger = new List <DBFlygning>();
                    foreach (var flygning in dbbestilling.FlygningerRetur)
                    {
                        flygninger.Add(db.Flygninger.Find(flygning.ID));
                    }
                    dbbestilling.FlygningerRetur = flygninger;

                    db.Bestillinger.Add(dbbestilling);
                    var endring = new DBEndring()
                    {
                        Tidspunkt = DateTime.Now,
                        Endring   = "La til bestilling: " + dbbestilling.Referanse
                    };
                    db.Endringer.Add(endring);
                    db.SaveChanges();
                }
                catch (Exception e)
                {
                    DALsetup.LogFeilTilFil("DBBestilling:LeggInn", e, "En feil oppsto når metoden prøvde å legge inn bestillingen i databasen.");
                }
            }
        }
 public DBAdmin Hent(string username)
 {
     using (var db = new DB())
     {
         try
         {
             return(db.Administratorer.Find(username)); //Admin == null betyr feil brukernavn
         } catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBAdmin:Hent", e, "En feil oppsto da metoden prøvde å administrator, brukernavn: " + username);
             return(null);
         }
     }
 }
Beispiel #19
0
 public List <Fly> HentAlle()
 {
     using (var db = new DB())
     {
         try
         {
             return(Mapper.Map <List <Fly> >(db.Fly));
         } catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBFly:HentAlle", e, "En feil oppsto da metoden prøvde å hente alle fly");
             return(null);
         }
     }
 }
Beispiel #20
0
 public Fly Hent(int ID)
 {
     using (var db = new DB())
     {
         try
         {
             return(Mapper.Map <Fly>(db.Fly.Find(ID)));
         } catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBFly:Hent", e, "En feil oppsto da metoden prøvde å hente fly med ID " + ID);
             return(null);
         }
     }
 }
Beispiel #21
0
 public List <Endring> HentAlle()
 {
     using (var db = new DB())
     {
         try
         {
             return(Mapper.Map <List <Endring> >(db.Endringer));
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBEndring:HentAlle", e, "En feil oppsto da metoden prøvde å hente alle registrerte endringer fra databasen");
             return(null);
         }
     }
 }
 public Flygning Hent(int id)
 {
     using (var db = new DB())
     {
         try
         {
             var dbflygning = db.Flygninger.Include("Fly").Where(item => item.ID == id).FirstOrDefault();
             return(Mapper.Map <Flygning>(dbflygning));
         }catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBFlygning:Hent", e, "En feil oppsto da metoden prøvde hente flygning med ID " + id);
             return(null);
         }
     }
 }
 public List <Flygning> HentFlygningerTil(Flyplass flyplass)
 {
     using (var db = new DB())
     {
         try
         {
             return(Mapper.Map <List <Flygning> >(db.Flygninger.Include("Fly").Where(flygning => flygning.Rute.Til.ID == flyplass.ID).ToList()));
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBFlygning:HentFlygningerTil", e, "En feil oppsto da metoden prøvde å hente flygninger");
             return(null);
         }
     }
 }
 public Flyplass Hent(string tilFlyplassID)
 {
     using (var db = new DB())
     {
         try
         {
             return(Mapper.Map <Flyplass>(db.Flyplasser.Find(tilFlyplassID)));
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBFlyplass:Hent", e, "En feil oppsto da metoden prøvde å hente flyplass med ID " + tilFlyplassID);
             return(null);
         }
     }
 }
 public Flygning Finn(int ID)
 {
     using (var db = new DB())
     {
         try
         {
             return(Mapper.Map <Flygning>(db.Flygninger.AsNoTracking().FirstOrDefault(fly => fly.ID == ID)));
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBFlygning:Finn", e, "En feil oppsto da metoden prøvde å finne flygning med ID " + ID);
             return(null);
         }
     }
 }
 public bool EksistererReferanse(string referanse)
 {
     using (var db = new DB())
     {
         try
         {
             return(db.Bestillinger.Where(best => best.Referanse == referanse).Any());
         }
         catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBBestilling:EksistererReferanse", e, "En feil oppsto når metoden prøvde å finne ut om referansen " + referanse + " eksisterer.");
         }
         return(false);
     }
 }
        public bool LeggInn(Kunde innKunde)
        {
            using (var db = new DB())
            {
                try
                {
                    DBKunde eksisterendeKunde = db.Kunder.Where(k => k.Etternavn == innKunde.Etternavn && k.Fornavn == innKunde.Fornavn && k.Tlf == innKunde.Tlf).FirstOrDefault();

                    if (eksisterendeKunde != null)
                    {
                        return(false);
                    }

                    DBKunde kunde = Mapper.Map <DBKunde>(innKunde);
                    db.Kunder.Add(kunde);

                    var poststed = db.Poststeder.Find(innKunde.Postnr);
                    if (poststed == null) //Hvis postnummeret finnes attacher vi det med databasen.
                    {
                        kunde.Postnummer = new DBPostnummer
                        {
                            Postnr   = innKunde.Postnr,
                            Poststed = ""
                        };
                    }
                    else
                    {
                        kunde.Postnummer = poststed;
                        db.Poststeder.Attach(poststed);
                    }
                    var endring = new DBEndring()
                    {
                        Tidspunkt = DateTime.Now,
                        Endring   = $"La til ny kunde: {kunde.Fornavn} {kunde.Etternavn}, {kunde.Adresse}, {kunde.Postnummer.Postnr} {kunde.Postnummer.Poststed}"
                    };
                    db.Endringer.Add(endring);
                    db.SaveChanges();

                    return(true);
                }
                catch (Exception e)
                {
                    DALsetup.LogFeilTilFil("DBKunde:LeggInn", e, "En feil oppsto da metoden prøvde å legge inn ny kunde.");
                    return(false);
                }
            }
        }
 public Kunde Hent(int id)
 {
     using (var db = new DB())
     {
         try
         {
             var   dbkunde = db.Kunder.Include("Postnummer").Where(kunde => kunde.ID == id).FirstOrDefault();
             Kunde kund    = Mapper.Map <Kunde>(dbkunde);
             kund.Postnr   = dbkunde.Postnummer.Postnr;
             kund.Poststed = dbkunde.Postnummer.Poststed;
             return(kund);
         }catch (Exception e)
         {
             DALsetup.LogFeilTilFil("DBKunde:Hent", e, "En feil oppsto da metoden prøvde å hente en kunde.");
             return(null);
         }
     }
 }
        public Postnummer Hent(string postnummer)
        {
            var  regex   = new Regex("^[0-9]{4}$");
            bool isMatch = regex.IsMatch(postnummer);

            if (isMatch)
            {
                using (var db = new DB())
                {
                    try
                    {
                        return(Mapper.Map <Postnummer>(db.Poststeder.FirstOrDefault(model => model.Postnr == postnummer)));
                    }catch (Exception e)
                    {
                        DALsetup.LogFeilTilFil("DBPostnummer:Hent", e, "En feil oppsto da metoden prøvde å hente poststed.");
                        return(null);
                    }
                }
            }
            return(null);
        }
        public List <Bestilling> HentAlle()
        {
            using (var db = new DB())
            {
                try
                {
                    var dbbestillinger = db.Bestillinger.ToList();
                    var bestillinger   = new List <Bestilling>();
                    foreach (var best in dbbestillinger)
                    {
                        bestillinger.Add(Mapper.Map <Bestilling>(best));
                    }

                    return(bestillinger);
                }catch (Exception e)
                {
                    DALsetup.LogFeilTilFil(System.Reflection.MethodBase.GetCurrentMethod().Name, e, "En feil oppsto når metoden prøvde å hente alle bestillinger.");
                    return(null);
                }
            }
        }