Ejemplo n.º 1
0
        public bool taLedigVakt(int id, string brukernavn)
        {
            var dbt = new DbTransaksjonerProsjekt();
            var db = new Dbkontekst();
            try
            {
                // finn personen i databasen
                Vakt taVakt = db.Vakter.FirstOrDefault(p => p.VaktId == id);

                VaktRequest nyRequest = new VaktRequest();
                // oppdater vakt fra databasen

                var pId = taVakt.ProsjektId;
                Prosjekt prosjekt = db.Prosjekter.FirstOrDefault(p => p.ProsjektId == pId);

                nyRequest.VaktId = taVakt.VaktId;
                nyRequest.Sendt = DateTime.Now;
                nyRequest.BrukerIdFra = dbt.BrukerId(brukernavn);
                nyRequest.BrukerIdTil = prosjekt.EierId;
                nyRequest.ProsjektId = prosjekt.ProsjektId;
                db.Vaktrequester.Add(nyRequest);
                
                db.SaveChanges();
                return true;
            }
            catch (Exception feil)
            {
                return false;
            }
        }
Ejemplo n.º 2
0
        public VaktTest()
        { 
            // Lager mocks som vi kan gjøre spørringer mot
           
            List<Vaktkalender> vakter = new List<Vaktkalender>
                {
                   // new Vaktkalender {ProsjektId = 1, start = Convert.ToDateTime("22.12.2012 16.43"),end =  Convert.ToDateTime("22.12.2012 16.43"),title = "Dagvakt",Beskrivelse = "Opplæring"},
                   // new Vaktkalender {ProsjektId = 2, start = Convert.ToDateTime("22.12.2012 16.43"),end =  Convert.ToDateTime("22.12.2012 16.43"),title = "Dagvakt",Beskrivelse = "Opplæring" },
                    //new Vaktkalender {ProsjektId = 3, Brukernavn = "", start = Convert.ToDateTime("22.12.2012 16.43"),end =  Convert.ToDateTime("22.12.2012 16.43"),title = "Dagvakt",Beskrivelse = "Opplæring"}
                };
            List<VaktRequest> vaktReq = new List<VaktRequest>
            {
                new VaktRequest
                {
                    BrukerIdTil = 1,
                    BrukerIdFra = 2,
                    MeldingId = 1,
                    VaktId = 1,
                    ProsjektId = 1,
                    
                }
            };

            List<Vakt> vakterDB = new List<Vakt>
                {
                    new Vakt {VaktId = 1, ProsjektId = 1, start = Convert.ToDateTime("22.12.2012 16.43"),end =  Convert.ToDateTime("22.12.2012 16.43"),title = "Dagvakt",Beskrivelse = "Opplæring"},
                    new Vakt {ProsjektId = 2, start = Convert.ToDateTime("22.12.2012 16.43"),end =  Convert.ToDateTime("22.12.2012 16.43"),title = "Dagvakt",Beskrivelse = "Opplæring" },
                    new Vakt {ProsjektId = 3, BrukerId = 1, start = Convert.ToDateTime("22.12.2012 16.43"),end =  Convert.ToDateTime("22.12.2012 16.43"),title = "Dagvakt",Beskrivelse = "Opplæring"},
                    new Vakt {ProsjektId = 3, BrukerId = 0, Ledig = true, start = Convert.ToDateTime("22.12.2012 16.43"),end =  Convert.ToDateTime("22.12.2012 16.43"),title = "Dagvakt",Beskrivelse = "Opplæring"}
            };
             List<Maler> maler = new List<Maler>
                {
                    new Maler {ProsjektId=1,startTid = "07.15", sluttTid = "14.15", Tittel = "dagvakt"}
                };

            List<dbBruker> bruker = new List<dbBruker>
                {
                    new dbBruker
                    {
                        BrukerId = 1, Email = "*****@*****.**"
                    },
                    new dbBruker
                    {
                        BrukerId = 2, Email = "*****@*****.**"
                    },
                    new dbBruker
                    {
                        BrukerId = 3, Email = "*****@*****.**"
                    }
                };
            List<Prosjekt> prosjekter = new List<Prosjekt>
                {
                    new Prosjekt()
                    {
                        ProsjektId=1,EierId=1
                    },
                     new Prosjekt()
                    {
                        ProsjektId=2,EierId=2
                    }

                };
            List<Prosjektdeltakelse> deltakelser = new List<Prosjektdeltakelse>
            {
                new Prosjektdeltakelse
                {
                    ProsjektDeltakerId=1,
                    BrukerId = 1,
                    ProsjektId = 1,
                    Admin = false,
                    Medlemsdato = Convert.ToDateTime("22.12.2012 16.43")
                },
                 new Prosjektdeltakelse
                {
                    ProsjektDeltakerId=2,
                    BrukerId = 2,
                    ProsjektId = 1,
                    Admin = true,
                    Medlemsdato = Convert.ToDateTime("22.12.2012 16.43")
                },
                 new Prosjektdeltakelse
                {
                    ProsjektDeltakerId=3,
                    BrukerId = 3,
                    ProsjektId = 1,
                    Admin = false,
                    Medlemsdato = Convert.ToDateTime("22.12.2012 16.43")
                }
            };
            Mock<InterfaceDbTProsjekt> mockProductRepositoryProsjekt = new Mock<InterfaceDbTProsjekt>();

            Mock<InterfaceDbTVakt> mockProductRepository = new Mock<InterfaceDbTVakt>();

            List<Vakt> myFilteredFoos = null;

            mockProductRepository.Setup(mr => mr.hentAlleVakter(It.IsAny<int>(), It.IsAny<string>()))
              .Callback((int i, string u) =>
                myFilteredFoos = vakterDB.Where(x => x.ProsjektId == i).ToList())
              .Returns(() =>
              {
                  List<Vaktkalender> testliste = new List<Vaktkalender>();
                  foreach (var vakt in myFilteredFoos)
                  {
                      testliste.Add(new Vaktkalender() { ProsjektId = vakt.ProsjektId,  start = vakt.start, end = vakt.end, title = vakt.title, Beskrivelse = vakt.Beskrivelse });
                  }
                  return testliste;
              });

            List<Maler> malene = null;
            mockProductRepository.Setup(mr => mr.hentAlleMaler(It.IsAny<int>(), It.IsAny<string>()))
            .Callback((int i, string u) =>
            malene = maler.Where(x => x.ProsjektId == i).ToList())
            .Returns(() =>
             {
              List<VisMaler> testliste = new List<VisMaler>();
                foreach (var mal in malene)
                {
                testliste.Add(new VisMaler() { ProsjektId = mal.ProsjektId, startTid = mal.startTid, sluttTid = mal.sluttTid, Tittel= mal.Tittel });
                }
                return testliste;
            });


            mockProductRepository.Setup(mr => mr.visVaktRequester(It.IsAny<string>()))
           .Returns(
           (string u) =>
           {
               int id = this.mockProductRepositoryProsjekt.BrukerId(u);
              
               List<VaktRequestMelding> req = (from p in vaktReq
                                               from b in bruker
                                               from s in vakterDB
                                               where p.BrukerIdTil == id && p.BrukerIdFra == b.BrukerId && p.VaktId == s.VaktId
                                               select new VaktRequestMelding()
                                               {
                                                   MeldingId = p.MeldingId,
                                                   ProsjektId = p.ProsjektId,
                                                   FraBruker = b.Email,
                                                   Melding = " vil ta vakten: ",
                                                 
                                                   VaktId = p.VaktId,
                                                 
                                                   Tid = p.Sendt,
                                                   TilBruker = u
                                               }).ToList();

               return req;
           });

            mockProductRepository.Setup(mr => mr.requestOk(It.IsAny<int>()))
          .Returns(
          (int i) =>
          {
              try
              {
                  var Requester = vaktReq.FirstOrDefault(p => p.MeldingId == i);
                  var OppdaterVakt = vakterDB.FirstOrDefault(p => p.VaktId == Requester.VaktId);
                  OppdaterVakt.BrukerId = Requester.BrukerIdFra;
                  OppdaterVakt.Ledig = false;
                  OppdaterVakt.color = "#3A87AD";
                  vaktReq.Remove(Requester);
                 
                  return true;
              }
              catch (Exception feil)
              {
                  return false;
              }
          });

            mockProductRepository.Setup(mr => mr.hentAlleLedigeVakter(It.IsAny<int>(), It.IsAny<string>()))
             .Callback((int i, string u) =>
               myFilteredFoos = vakterDB.Where(x => x.ProsjektId == i && x.BrukerId == 0).ToList())
             .Returns(() =>
             {
                 List<Vaktkalender> testliste = new List<Vaktkalender>();
                 foreach (var vakt in myFilteredFoos)
                 {
                     testliste.Add(new Vaktkalender() { ProsjektId = vakt.ProsjektId, Ledig = vakt.Ledig, start = vakt.start, end = vakt.end, title = vakt.title, Beskrivelse = vakt.Beskrivelse });
                 }
                 return testliste;
             });
          
            mockProductRepository.Setup(mr => mr.hentAlleVakterForBruker(It.IsAny<string>()))
           .Returns((string u) =>
           {
               var user = bruker.Where(x => x.Email == u ).Single();
               int id = user.BrukerId;
               myFilteredFoos = vakterDB.Where(x => x.BrukerId == id).ToList();
               List<Vaktkalender> testliste = new List<Vaktkalender>();
               foreach (var vakt in myFilteredFoos)
               {
                   testliste.Add(new Vaktkalender() { ProsjektId = vakt.ProsjektId, Brukernavn = user.Email, Ledig = vakt.Ledig, start = vakt.start, end = vakt.end, title = vakt.title, Beskrivelse = vakt.Beskrivelse });
               }
               return testliste;
           });

            mockProductRepository.Setup(mr => mr.SlettVakt(It.IsAny<int>(), It.IsAny<string>()))
           .Returns((int i, string u) =>
           {
               var slettVakt = vakterDB.FirstOrDefault(p => p.VaktId == i);
               if (!this.mockProductRepositoryProsjekt.ErAdmin(u, slettVakt.ProsjektId) && !this.mockProductRepositoryProsjekt.ErEier(u, slettVakt.ProsjektId))
               {
                   return false;
               }
               try
               {
                   vakterDB.Remove(slettVakt);
                   return true;
               }
               catch (Exception feil)
               {
                   return false;
               }
           });

            mockProductRepository.Setup(mr => mr.LedigVakt(It.IsAny<Vaktskjema>()))
         .Returns((Vaktskjema i) =>
         {
             if (i.BrukerId == 0)
             {
                 return true;
             }
             return false;
         });

            mockProductRepository.Setup(mr => mr.taLedigVakt(It.IsAny<int>(), It.IsAny<string>()))
          .Returns((int i, string u) =>
          {
              try
              {
                  // finn personen i databasen
                  Vakt taVakt = vakterDB.FirstOrDefault(p => p.VaktId == i);

                  VaktRequest nyRequest = new VaktRequest();
                  // oppdater vakt fra databasen

                  var pId = taVakt.ProsjektId;
                  Prosjekt prosjekt = prosjekter.FirstOrDefault(p => p.ProsjektId == pId);

                  nyRequest.VaktId = taVakt.VaktId;
                  nyRequest.Sendt = DateTime.Now;
                  nyRequest.BrukerIdFra = this.mockProductRepositoryProsjekt.BrukerId(u);
                  nyRequest.BrukerIdTil = prosjekt.EierId;
                  nyRequest.ProsjektId = prosjekt.ProsjektId;
                  vaktReq.Add(nyRequest);
                  return true;
              }
              catch (Exception feil)
              {
                  return false;
              }
          });

            mockProductRepository.Setup(mr => mr.VakterProsjekt(It.IsAny<int>()))
          .Returns((int i) =>
          {
              var eventer = (from k in vakterDB
                             where k.ProsjektId == i
                             select k
                             ).ToList();
              return eventer;
          });
            

            mockProductRepository.Setup(mr => mr.RegistrerVakt(It.IsAny<Vaktskjema>(), It.IsAny<string>())).Returns(
                (Vaktskjema vakt, string u) =>
                {

                    if (!this.mockProductRepositoryProsjekt.ErAdmin(u, vakt.ProsjektId) && !this.mockProductRepositoryProsjekt.ErEier(u, vakt.ProsjektId))
                    {
                        return false;
                    }

                        Vakt nyVakt = new Vakt();
                        nyVakt.ProsjektId = vakt.ProsjektId;
                        nyVakt.BrukerId = vakt.ProsjektId;
                        string start = vakt.start + " " + vakt.startTid;

                        IFormatProvider culture = System.Threading.Thread.CurrentThread.CurrentCulture;
                        DateTime dt1 = DateTime.ParseExact(start, "dd.MM.yyyy H:mm", culture, System.Globalization.DateTimeStyles.AssumeLocal);
                        DateTime dt2;
                        string end = "";
                        if (vakt.end != null)
                        {
                            end = vakt.end + " " + vakt.endTid;
                            dt2 = DateTime.ParseExact(end, "dd.MM.yyyy H:mm", culture, System.Globalization.DateTimeStyles.AssumeLocal);
                        }
                        else
                        {
                            end = vakt.start + " " + vakt.endTid;
                            dt2 = DateTime.ParseExact(end, "dd.MM.yyyy H:mm", culture, System.Globalization.DateTimeStyles.AssumeLocal);
                        }
                        nyVakt.start = dt1;
                        nyVakt.end = dt2;

                        int result = DateTime.Compare(dt1, dt2);
                        if (result > 0 || result == 0)
                        {
                            return false;

                        }
                        else
                        {
                            vakterDB.Add(nyVakt);
                        }
                    

                    return true;
                });

            mockProductRepository.Setup(mr => mr.EndreVakt(It.IsAny<Vaktskjema>(), It.IsAny<string>())).Returns(
               (Vaktskjema vakt, string u) =>
               {
                   if (!this.mockProductRepositoryProsjekt.ErAdmin(u, vakt.ProsjektId) && !this.mockProductRepositoryProsjekt.ErEier(u, vakt.ProsjektId))
                   {
                       return false;
                   }
                   
                   var NyEndreVakt = vakterDB.FirstOrDefault(p => p.VaktId == vakt.Vaktid);
                   string start = vakt.start + " " + vakt.startTid;
                   string end;

                   IFormatProvider culture = System.Threading.Thread.CurrentThread.CurrentCulture;
                   DateTime dt1 = DateTime.ParseExact(start, "dd.MM.yyyy H:mm", culture, System.Globalization.DateTimeStyles.AssumeLocal);
                   DateTime dt2;

                   if (vakt.end != "" && vakt.endDato == true)
                   {
                       end = vakt.end + " " + vakt.endTid;
                       dt2 = DateTime.ParseExact(end, "dd.MM.yyyy H:mm", culture, System.Globalization.DateTimeStyles.AssumeLocal);
                   }
                   else
                   {
                       end = vakt.start + " " + vakt.endTid;
                       dt2 = DateTime.ParseExact(end, "dd.MM.yyyy H:mm", culture, System.Globalization.DateTimeStyles.AssumeLocal);
                   }

                   int result = DateTime.Compare(dt1, dt2);
                   if (result > 0 || result == 0)
                   {
                       return false;
                   }
                   if (!this.mockProductRepositoryProsjekt.ErAdmin(u, NyEndreVakt.ProsjektId) && !this.mockProductRepositoryProsjekt.ErEier(u, NyEndreVakt.ProsjektId))
                   {
                       return false;
                   }
                   try
                   {
                       NyEndreVakt.Beskrivelse = vakt.Beskrivelse;
                       NyEndreVakt.BrukerId = vakt.BrukerId;
                       NyEndreVakt.start = dt1;
                       NyEndreVakt.end = dt2;
                       NyEndreVakt.title = vakt.title;

                       if (this.mockProductRepository.LedigVakt(vakt))
                       {
                           NyEndreVakt.Ledig = true;
                           NyEndreVakt.color = "#5CB85C";
                       }
                       else
                       {
                           NyEndreVakt.Ledig = false;
                           NyEndreVakt.color = "#3A87AD";
                       }

                       return true;
                   }
                   catch (Exception feil)
                   {
                       return false;
                   }
               });



            mockProductRepositoryProsjekt.Setup(mr => mr.ErEier(It.IsAny<string>(), It.IsAny<int>()))
             .Returns(
               (string u, int i) =>
               {
                   var bId = this.mockProductRepositoryProsjekt.BrukerId(u);
                   var TestOk = (from x in prosjekter
                                 where x.EierId == bId && x.ProsjektId == i
                                 select x.EierId).SingleOrDefault();
                   bool ok = false;
                   if (TestOk != 0)
                   {
                       ok = true;
                       return ok;
                   }
                   return ok;
               });

            mockProductRepositoryProsjekt.Setup(mr => mr.ErAdmin(It.IsAny<string>(), It.IsAny<int>()))
            .Returns(
              (string u, int i) =>
              {
                  var okAdmin = false;
                  var bId = this.mockProductRepositoryProsjekt.BrukerId(u);
                  var TestOk = (from x in deltakelser
                                where x.ProsjektId == i && x.BrukerId == bId
                                select x.Admin).SingleOrDefault();

                  if (TestOk != false)
                  {
                      okAdmin = true;
                      return okAdmin;
                  }
                  return okAdmin;
              });
            mockProductRepositoryProsjekt.Setup(mr => mr.BrukerId(It.IsAny<string>()))
              .Returns(
                (string u) =>
                {
                    int userId = (from x in bruker
                                  where x.Email == u
                                  select x.BrukerId).SingleOrDefault();
                    return userId;
                });
            
            // Complete the setup of our Mock Product Repository
            this.mockProductRepositoryProsjekt = mockProductRepositoryProsjekt.Object;
            this.mockProductRepository = mockProductRepository.Object;
        }