Exemple #1
0
 public ProsjektBLL(InterfaceDbTProsjekt moqs)
 {
     _repository = moqs;
 }
Exemple #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;
        }
Exemple #3
0
 public ProsjektBLL()
 {
     _repository = new DbTransaksjonerProsjekt();
 }
Exemple #4
0
 public ProsjektBLL()
 {
     _repository = new DbTransaksjonerProsjekt();
 }
Exemple #5
0
 public ProsjektBLL(InterfaceDbTProsjekt moqs)
 {
     _repository = moqs;
 }
Exemple #6
0
        public ProsjektTest(){
         // Lager mocks som vi kan gjøre spørringer mot
          
            var req = new List<Prosjektrequest>() {
                new Prosjektrequest()
            {
               ProsjektId = 1,
               BrukerIdFra = 1,
               BrukerIdTil = 2,
               MeldingId = 1,
               Sendt = Convert.ToDateTime("22.12.2012 16.43")

             }, new Prosjektrequest() { ProsjektId = 2,
               BrukerIdFra = 2,
               BrukerIdTil = 1,
               MeldingId = 1,
               Sendt = Convert.ToDateTime("22.12.2012 16.43")
             }
            };
            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")
                }
            };
            var reqMelding = new List<ProsjektrequestMelding>() { new ProsjektrequestMelding()
            {
               ProsjektId = 1,
               FraBruker = "*****@*****.**",
               TilBruker = "*****@*****.**",
               Melding = "",
               Prosjektnavn = "Bunnpris",
               MeldingId = 1,
               Tid = Convert.ToDateTime("22.12.2012 16.43")

             } };

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


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

            mockProductRepository.Setup(mr => mr.ErAdmin(It.IsAny<string>(), It.IsAny<int>()))
            .Returns(
              (string u, int i) =>
              {
                  var okAdmin = false;
                  var bId = this.mockProductRepository.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;
              });

            
            mockProductRepository.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;
                });

            mockProductRepository.Setup(mr => mr.BrukerNavn(It.IsAny<int>()))
            .Returns(
              (int i) =>
              {
                
                  var brukernavn = (from x in bruker
                             where x.BrukerId == i
                             select x.Email).SingleOrDefault();
                  return brukernavn;
              });


            mockProductRepository.Setup(mr => mr.SjekkTilgangProsjekt(It.IsAny<string>()))
               .Returns(
                   (string u) =>
                   {
                       int BrukerId = this.mockProductRepository.BrukerId(u);
                       List<ProsjektVis> pros = (from p in deltakelser
                                                 from s in prosjekter
                                                 where p.BrukerId == BrukerId && p.ProsjektId == s.ProsjektId
                                                 select
                                                     new ProsjektVis()
                                                     {
                                                         Id = p.ProsjektId,
                                                     }).ToList();

                       return pros;
                   });

            mockProductRepository.Setup(mr => mr.VisRequesterForProsjekt(It.IsAny<int>(), It.IsAny<string>()))
                .Returns(
                    (int i, string u) =>
                    {
                        var tilganger = this.mockProductRepository.SjekkTilgangProsjekt(u);
                        var eventer = (from k in req
                                       from s in tilganger
                                       where k.ProsjektId == i && k.ProsjektId == s.Id
                                       select new ProsjektrequestMelding
                                       {
                                           MeldingId = k.MeldingId,
                                           TilBruker = this.mockProductRepository.BrukerNavn(k.BrukerIdTil),
                                           Tid = k.Sendt,
                                           ProsjektId = k.ProsjektId
                                           
                                       }).ToList();
                        return eventer;
                    });

            mockProductRepository.Setup(mr => mr.VisRequester(It.IsAny<string>()))
              .Returns(
                  (string u) =>
                  {
                      int id = this.mockProductRepository.BrukerId(u);

                      List<ProsjektrequestMelding> pros = (from p in req
                                                           from b in bruker
                                                           from s in prosjekter
                                                           where p.BrukerIdTil == id && p.BrukerIdFra == b.BrukerId && p.ProsjektId == s.ProsjektId
                                                           select
                                                               new ProsjektrequestMelding()
                                                               {
                                                                   ProsjektId = p.ProsjektId,
                                                                   FraBruker = b.Email,
                                                                   Melding = " har invitert deg til å bli medlem av: ",
                                                                   Tid = p.Sendt,
                                                                   TilBruker = u
                                                               }).ToList();
                      return pros;

                  });

            mockProductRepository.Setup(mr => mr.HentProsjekter(It.IsAny<string>()))
             .Returns(
                 (string u) =>
                 {
                     int id = this.mockProductRepository.BrukerId(u);
                     List<ProsjektVis> pros = (from p in deltakelser
                                               from s in prosjekter
                                               where p.BrukerId == id && p.ProsjektId == s.ProsjektId
                                               select
                                                   new ProsjektVis()
                                                   {
                                                       Id = p.ProsjektId,
                                                       Arbeidsplass = s.Arbeidsplass
                                                   }).ToList();
                     return pros;

                 });

            mockProductRepository.Setup(mr => mr.SlettBrukerFraProsjekt(It.IsAny<string>(), It.IsAny<int>()))
            .Returns(
                (string u, int i) =>
                {
                    
                    var SlettProsjekt = deltakelser.FirstOrDefault(p => p.ProsjektDeltakerId == i);
                    var sjekkEier = prosjekter.FirstOrDefault(p => p.EierId == SlettProsjekt.BrukerId && p.ProsjektId == SlettProsjekt.ProsjektId);
                    if (sjekkEier != null)
                    {
                        return false; // kan ikke slette eier fra prosjekt
                    }
                    if (this.mockProductRepository.ErAdmin(u, SlettProsjekt.ProsjektId) == true || this.mockProductRepository.ErEier(u, SlettProsjekt.ProsjektId) == true)
                    {
                        try
                        {
                            deltakelser.Remove(SlettProsjekt);
                            return true;
                        }
                        catch (Exception feil)
                        {
                            return false;
                        }
                    }
                    return false;

                });

            mockProductRepository.Setup(mr => mr.RegistrerProsjekt(It.IsAny<Prosjekt>(), It.IsAny<string>()))
            .Returns(
                (Prosjekt p, string u) =>
                {
                    int userId = this.mockProductRepository.BrukerId(u);
                    if (p.Arbeidsplass == "" || userId == 0)
                    {
                        return false;
                    }
                    var nyProsjekt = new Prosjekt()
                    {
                        Arbeidsplass = p.Arbeidsplass,
                        EierId = userId

                    };
                    var nyProsjektDeltakelse = new Prosjektdeltakelse()
                    {
                        BrukerId = userId,
                        Medlemsdato = DateTime.Now,
                        ProsjektId = nyProsjekt.ProsjektId
                    };

                        try
                        {
                            prosjekter.Add(nyProsjekt);
                            deltakelser.Add(nyProsjektDeltakelse);
                            
                            return true;
                        }
                        catch (Exception feil)
                        {
                            return false;
                        }
                    
                });

            mockProductRepository.Setup(mr => mr.LeggTilBrukerRequest(It.IsAny<ProsjektrequestSkjema>(), It.IsAny<string>()))
          .Returns(
              (ProsjektrequestSkjema p, string u) =>
              {
                  int bId = this.mockProductRepository.BrukerId(u);
                  int bIdTil = this.mockProductRepository.BrukerId(p.TilBruker);
                  int pId = p.ProsjektId;

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

                  if (bIdTil == 0)
                  {
                      return false;
                  }
                  var nyRequest = new Prosjektrequest()
                  {
                      BrukerIdFra = bId,
                      BrukerIdTil = bIdTil,
                      ProsjektId = pId,
                      Akseptert = false,
                      Sendt = DateTime.Now
                  };
                  try
                      {
                          req.Add(nyRequest);
                          return true;
                      }
                      catch (Exception feil)
                      {
                          return false;
                      }
            
              });


            mockProductRepository.Setup(mr => mr.RegistrerProsjektdeltakelse(It.IsAny<ProsjektrequestMelding>(), It.IsAny<string>()))
          .Returns(
              (ProsjektrequestMelding p, string u) =>
              {
                 
                  int id = this.mockProductRepository.BrukerId(u);
                  IEnumerable<ProsjektDeltakelseOverforing> prosjektReq = from prosj in req
                                                                          from b in bruker
                                                                          from s in prosjekter
                                                                          where prosj.BrukerIdTil == id && prosj.BrukerIdFra == b.BrukerId && prosj.ProsjektId == p.ProsjektId
                                                                          select new ProsjektDeltakelseOverforing()
                                                                          {
                                                                              BrukerId = prosj.BrukerIdTil,
                                                                              ProsjektId = prosj.ProsjektId

                                                                          };
                  var prosjektD = new Prosjektdeltakelse();
                  foreach (var a in prosjektReq)
                  {
                      prosjektD.BrukerId = a.BrukerId;
                      prosjektD.ProsjektId = a.ProsjektId;
                      prosjektD.Medlemsdato = DateTime.Now;
                  }
                  try
                  {

                      deltakelser.Add(prosjektD);
                      this.mockProductRepository.SlettRequest(prosjektD.ProsjektId, u);
                      return true;

                  }
                  catch (Exception feil)
                  {
                      return false;
                  }

              });


            /*
              
            
            */

            this.mockProductRepository = mockProductRepository.Object;
        }
Exemple #7
0
        public BrukerTest()
        {
            // Lager mock som vi kan gjøre spørringer mot

            List<BrukerListe> brukere = new List<BrukerListe>
                {
                   new BrukerListe() {Brukernavn = "*****@*****.**", ProsjektDeltakerId = 1, Admin = false, Navn="Mats"},
                    new BrukerListe() {Brukernavn = "*****@*****.**", ProsjektDeltakerId = 2, Admin=true, Navn = "Gordo"}
                };
            List<dbBruker> brukereDB = new List<dbBruker>
                {
                     new dbBruker
                    {
                        BrukerId = 1, Email = "*****@*****.**"
                    },
                    new dbBruker
                    {
                        BrukerId = 2, Email = "*****@*****.**"
                    },
                    new dbBruker
                    {
                        BrukerId = 3, Email = "*****@*****.**"
                    }
                };
            List<Vakt> vakterDB = new List<Vakt>
                {
                    new Vakt {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 = 1, BrukerId = 1, start = Convert.ToDateTime("22.12.2012 16.43"),end =  Convert.ToDateTime("22.12.2012 16.43"),title = "Dagvakt",Beskrivelse = "Opplæring"}
                };
            List<Prosjektdeltakelse> deltakelser = new List<Prosjektdeltakelse>
                {
                    new Prosjektdeltakelse() {BrukerId = 1, ProsjektId = 1, ProsjektDeltakerId = 1, Admin = false},
                    new Prosjektdeltakelse() {BrukerId = 2, ProsjektId = 1, ProsjektDeltakerId = 2, Admin = false}
                };
            List<Prosjekt> prosjekter  = new List<Prosjekt>
                {
                    new Prosjekt() {ProsjektId = 1, EierId = 1},
                    new Prosjekt() {ProsjektId = 2, EierId = 2}
                };

            // Mock the Products Repository using Moq
            Mock<InterfaceDbTBruker> mockProductRepository = new Mock<InterfaceDbTBruker>();
            Mock<InterfaceDbTProsjekt> mockProductRepositoryProsjekt = new Mock<InterfaceDbTProsjekt>();



            mockProductRepository.Setup(mr => mr.HentBrukere(It.IsAny<int>(), It.IsAny<string>()))
                .Returns(
                (int i, string u) =>
                {
                    var deltakels = deltakelser.Where(x => x.ProsjektId == i).ToList();
                    List<BrukerListe> testliste = new List<BrukerListe>();
                    foreach (var del in deltakels)
                    {
                        testliste.Add(new BrukerListe() { ProsjektId = del.ProsjektId, ProsjektDeltakerId = del.ProsjektDeltakerId, Admin = del.Admin });
                    }
                    return testliste;
                });

            mockProductRepository.Setup(mr => mr.GiBrukerAdminTilgang(It.IsAny<Sjef>(), It.IsAny<string>()))
              .Returns(
              (Sjef s, string u) =>
              {
                  if (!this.mockProductRepositoryProsjekt.ErEier(u, s.ProsjektId))
                  {
                      return false;
                  }
                  var AdminTilgang = deltakelser.FirstOrDefault(p => p.ProsjektId == s.ProsjektId && p.BrukerId == s.BrukerId);
                  if (AdminTilgang == null)
                  {
                      return false;
                  }
                  try
                  {
                      AdminTilgang.Admin = true;
                      return true;
                  }
                  catch (Exception feil)
                  {
                      return false;
                  }
              });


           


            mockProductRepository.Setup(mr => mr.RegistrerBruker(It.IsAny<Registrer>()))
           .Returns(
           (Registrer r) =>
           {
               if (this.mockProductRepository.EmailDb(r))
               {
                   return false;
               }
                var algoritme = System.Security.Cryptography.SHA256.Create();
                var innData = System.Text.Encoding.ASCII.GetBytes(r.BekreftPassord);
                var passordDb = algoritme.ComputeHash(innData);
              
               var nyBruker = new dbBruker()
               {
                   Passord = passordDb,
                   Fornavn = r.Fornavn,
                   Etternavn = r.Etternavn,
                   Email = r.Email,
                   Telefonnummer = r.Telefonnummer
               };

               using (var db = new Dbkontekst())
               {
                   try
                   {
                       db.Brukere.Add(nyBruker);
                       db.SaveChanges();
                       return true;
                   }
                   catch (Exception feil)
                   {
                       return false;
                   }
               }
           });

            mockProductRepository.Setup(mr => mr.EmailDb(It.IsAny<Registrer>()))
          .Returns(
          (Registrer r) =>
          {
              dbBruker funnetBruker = brukereDB.FirstOrDefault
                     (b => b.Email == r.Email);
              if (funnetBruker == null)
              {
                  return false;
              }
              else
              {
                  return true;
              }
          });



            mockProductRepository.Setup(mr => mr.HentVakter(It.IsAny<string>(), It.IsAny<int>()))
           .Returns(
           (string u, int i)=>
           {
              
               int id = this.mockProductRepositoryProsjekt.BrukerId(u);

               List<Timeliste> pros = (from p in vakterDB
                                       where p.BrukerId == id && p.ProsjektId == i
                                       select
                                           new Timeliste()
                                           {
                                               ProsjektId = p.ProsjektId,
                                               PeriodeStart = p.start,
                                               PeriodeSlutt = p.end
                                           }).ToList();

               return pros;
           });
            mockProductRepository.Setup(mr => mr.FjernAdminTilgang(It.IsAny<Sjef>(), It.IsAny<string>()))
              .Returns(
              (Sjef s, string u) =>
              {
                
                  if (!this.mockProductRepositoryProsjekt.ErEier(u, s.ProsjektId))
                  {
                      return false;
                  }
                  try
                  {
                      var AdminTilgang = deltakelser.FirstOrDefault(p => p.ProsjektId == s.ProsjektId && p.BrukerId == s.BrukerId);
                      AdminTilgang.Admin = false;
                 
                      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 brukereDB
                                  where x.Email == u
                                  select x.BrukerId).SingleOrDefault();
                    return userId;
                });

            // Allows us to test saving a product

            // Complete the setup of our Mock Product Repository
            this.mockProductRepository = mockProductRepository.Object;
                  this.mockProductRepositoryProsjekt = mockProductRepositoryProsjekt.Object;
        }
Exemple #8
0
        public BrukerTest()
        {
            // Lager mock som vi kan gjøre spørringer mot

            List <BrukerListe> brukere = new List <BrukerListe>
            {
                new BrukerListe()
                {
                    Brukernavn = "*****@*****.**", ProsjektDeltakerId = 1, Admin = false, Navn = "Mats"
                },
                new BrukerListe()
                {
                    Brukernavn = "*****@*****.**", ProsjektDeltakerId = 2, Admin = true, Navn = "Gordo"
                }
            };
            List <dbBruker> brukereDB = new List <dbBruker>
            {
                new dbBruker
                {
                    BrukerId = 1, Email = "*****@*****.**"
                },
                new dbBruker
                {
                    BrukerId = 2, Email = "*****@*****.**"
                },
                new dbBruker
                {
                    BrukerId = 3, Email = "*****@*****.**"
                }
            };
            List <Vakt> vakterDB = new List <Vakt>
            {
                new Vakt {
                    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 = 1, BrukerId = 1, start = Convert.ToDateTime("22.12.2012 16.43"), end = Convert.ToDateTime("22.12.2012 16.43"), title = "Dagvakt", Beskrivelse = "Opplæring"
                }
            };
            List <Prosjektdeltakelse> deltakelser = new List <Prosjektdeltakelse>
            {
                new Prosjektdeltakelse()
                {
                    BrukerId = 1, ProsjektId = 1, ProsjektDeltakerId = 1, Admin = false
                },
                new Prosjektdeltakelse()
                {
                    BrukerId = 2, ProsjektId = 1, ProsjektDeltakerId = 2, Admin = false
                }
            };
            List <Prosjekt> prosjekter = new List <Prosjekt>
            {
                new Prosjekt()
                {
                    ProsjektId = 1, EierId = 1
                },
                new Prosjekt()
                {
                    ProsjektId = 2, EierId = 2
                }
            };

            // Mock the Products Repository using Moq
            Mock <InterfaceDbTBruker>   mockProductRepository         = new Mock <InterfaceDbTBruker>();
            Mock <InterfaceDbTProsjekt> mockProductRepositoryProsjekt = new Mock <InterfaceDbTProsjekt>();



            mockProductRepository.Setup(mr => mr.HentBrukere(It.IsAny <int>(), It.IsAny <string>()))
            .Returns(
                (int i, string u) =>
            {
                var deltakels = deltakelser.Where(x => x.ProsjektId == i).ToList();
                List <BrukerListe> testliste = new List <BrukerListe>();
                foreach (var del in deltakels)
                {
                    testliste.Add(new BrukerListe()
                    {
                        ProsjektId = del.ProsjektId, ProsjektDeltakerId = del.ProsjektDeltakerId, Admin = del.Admin
                    });
                }
                return(testliste);
            });

            mockProductRepository.Setup(mr => mr.GiBrukerAdminTilgang(It.IsAny <Sjef>(), It.IsAny <string>()))
            .Returns(
                (Sjef s, string u) =>
            {
                if (!this.mockProductRepositoryProsjekt.ErEier(u, s.ProsjektId))
                {
                    return(false);
                }
                var AdminTilgang = deltakelser.FirstOrDefault(p => p.ProsjektId == s.ProsjektId && p.BrukerId == s.BrukerId);
                if (AdminTilgang == null)
                {
                    return(false);
                }
                try
                {
                    AdminTilgang.Admin = true;
                    return(true);
                }
                catch (Exception feil)
                {
                    return(false);
                }
            });



            mockProductRepository.Setup(mr => mr.RegistrerBruker(It.IsAny <Registrer>()))
            .Returns(
                (Registrer r) =>
            {
                if (this.mockProductRepository.EmailDb(r))
                {
                    return(false);
                }
                var algoritme = System.Security.Cryptography.SHA256.Create();
                var innData   = System.Text.Encoding.ASCII.GetBytes(r.BekreftPassord);
                var passordDb = algoritme.ComputeHash(innData);

                var nyBruker = new dbBruker()
                {
                    Passord       = passordDb,
                    Fornavn       = r.Fornavn,
                    Etternavn     = r.Etternavn,
                    Email         = r.Email,
                    Telefonnummer = r.Telefonnummer
                };

                using (var db = new Dbkontekst())
                {
                    try
                    {
                        db.Brukere.Add(nyBruker);
                        db.SaveChanges();
                        return(true);
                    }
                    catch (Exception feil)
                    {
                        return(false);
                    }
                }
            });

            mockProductRepository.Setup(mr => mr.EmailDb(It.IsAny <Registrer>()))
            .Returns(
                (Registrer r) =>
            {
                dbBruker funnetBruker = brukereDB.FirstOrDefault
                                            (b => b.Email == r.Email);
                if (funnetBruker == null)
                {
                    return(false);
                }
                else
                {
                    return(true);
                }
            });



            mockProductRepository.Setup(mr => mr.HentVakter(It.IsAny <string>(), It.IsAny <int>()))
            .Returns(
                (string u, int i) =>
            {
                int id = this.mockProductRepositoryProsjekt.BrukerId(u);

                List <Timeliste> pros = (from p in vakterDB
                                         where p.BrukerId == id && p.ProsjektId == i
                                         select
                                         new Timeliste()
                {
                    ProsjektId = p.ProsjektId,
                    PeriodeStart = p.start,
                    PeriodeSlutt = p.end
                }).ToList();

                return(pros);
            });
            mockProductRepository.Setup(mr => mr.FjernAdminTilgang(It.IsAny <Sjef>(), It.IsAny <string>()))
            .Returns(
                (Sjef s, string u) =>
            {
                if (!this.mockProductRepositoryProsjekt.ErEier(u, s.ProsjektId))
                {
                    return(false);
                }
                try
                {
                    var AdminTilgang   = deltakelser.FirstOrDefault(p => p.ProsjektId == s.ProsjektId && p.BrukerId == s.BrukerId);
                    AdminTilgang.Admin = false;

                    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 brukereDB
                              where x.Email == u
                              select x.BrukerId).SingleOrDefault();
                return(userId);
            });

            // Allows us to test saving a product

            // Complete the setup of our Mock Product Repository
            this.mockProductRepository         = mockProductRepository.Object;
            this.mockProductRepositoryProsjekt = mockProductRepositoryProsjekt.Object;
        }
Exemple #9
0
        public ProsjektTest()
        {
            // Lager mocks som vi kan gjøre spørringer mot

            var req = new List <Prosjektrequest>()
            {
                new Prosjektrequest()
                {
                    ProsjektId  = 1,
                    BrukerIdFra = 1,
                    BrukerIdTil = 2,
                    MeldingId   = 1,
                    Sendt       = Convert.ToDateTime("22.12.2012 16.43")
                }, new Prosjektrequest()
                {
                    ProsjektId  = 2,
                    BrukerIdFra = 2,
                    BrukerIdTil = 1,
                    MeldingId   = 1,
                    Sendt       = Convert.ToDateTime("22.12.2012 16.43")
                }
            };
            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")
                }
            };
            var reqMelding = new List <ProsjektrequestMelding>()
            {
                new ProsjektrequestMelding()
                {
                    ProsjektId   = 1,
                    FraBruker    = "*****@*****.**",
                    TilBruker    = "*****@*****.**",
                    Melding      = "",
                    Prosjektnavn = "Bunnpris",
                    MeldingId    = 1,
                    Tid          = Convert.ToDateTime("22.12.2012 16.43")
                }
            };

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



            bool ok = false;

            mockProductRepository.Setup(mr => mr.ErEier(It.IsAny <string>(), It.IsAny <int>()))
            .Returns(
                (string u, int i) =>
            {
                var bId    = this.mockProductRepository.BrukerId(u);
                var TestOk = (from x in prosjekter
                              where x.EierId == bId && x.ProsjektId == i
                              select x.EierId).SingleOrDefault();

                if (TestOk != 0)
                {
                    ok = true;
                    return(ok);
                }
                return(ok);
            });

            mockProductRepository.Setup(mr => mr.ErAdmin(It.IsAny <string>(), It.IsAny <int>()))
            .Returns(
                (string u, int i) =>
            {
                var okAdmin = false;
                var bId     = this.mockProductRepository.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);
            });


            mockProductRepository.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);
            });

            mockProductRepository.Setup(mr => mr.BrukerNavn(It.IsAny <int>()))
            .Returns(
                (int i) =>
            {
                var brukernavn = (from x in bruker
                                  where x.BrukerId == i
                                  select x.Email).SingleOrDefault();
                return(brukernavn);
            });


            mockProductRepository.Setup(mr => mr.SjekkTilgangProsjekt(It.IsAny <string>()))
            .Returns(
                (string u) =>
            {
                int BrukerId            = this.mockProductRepository.BrukerId(u);
                List <ProsjektVis> pros = (from p in deltakelser
                                           from s in prosjekter
                                           where p.BrukerId == BrukerId && p.ProsjektId == s.ProsjektId
                                           select
                                           new ProsjektVis()
                {
                    Id = p.ProsjektId,
                }).ToList();

                return(pros);
            });

            mockProductRepository.Setup(mr => mr.VisRequesterForProsjekt(It.IsAny <int>(), It.IsAny <string>()))
            .Returns(
                (int i, string u) =>
            {
                var tilganger = this.mockProductRepository.SjekkTilgangProsjekt(u);
                var eventer   = (from k in req
                                 from s in tilganger
                                 where k.ProsjektId == i && k.ProsjektId == s.Id
                                 select new ProsjektrequestMelding
                {
                    MeldingId = k.MeldingId,
                    TilBruker = this.mockProductRepository.BrukerNavn(k.BrukerIdTil),
                    Tid = k.Sendt,
                    ProsjektId = k.ProsjektId
                }).ToList();
                return(eventer);
            });

            mockProductRepository.Setup(mr => mr.VisRequester(It.IsAny <string>()))
            .Returns(
                (string u) =>
            {
                int id = this.mockProductRepository.BrukerId(u);

                List <ProsjektrequestMelding> pros = (from p in req
                                                      from b in bruker
                                                      from s in prosjekter
                                                      where p.BrukerIdTil == id && p.BrukerIdFra == b.BrukerId && p.ProsjektId == s.ProsjektId
                                                      select
                                                      new ProsjektrequestMelding()
                {
                    ProsjektId = p.ProsjektId,
                    FraBruker = b.Email,
                    Melding = " har invitert deg til å bli medlem av: ",
                    Tid = p.Sendt,
                    TilBruker = u
                }).ToList();
                return(pros);
            });

            mockProductRepository.Setup(mr => mr.HentProsjekter(It.IsAny <string>()))
            .Returns(
                (string u) =>
            {
                int id = this.mockProductRepository.BrukerId(u);
                List <ProsjektVis> pros = (from p in deltakelser
                                           from s in prosjekter
                                           where p.BrukerId == id && p.ProsjektId == s.ProsjektId
                                           select
                                           new ProsjektVis()
                {
                    Id = p.ProsjektId,
                    Arbeidsplass = s.Arbeidsplass
                }).ToList();
                return(pros);
            });

            mockProductRepository.Setup(mr => mr.SlettBrukerFraProsjekt(It.IsAny <string>(), It.IsAny <int>()))
            .Returns(
                (string u, int i) =>
            {
                var SlettProsjekt = deltakelser.FirstOrDefault(p => p.ProsjektDeltakerId == i);
                var sjekkEier     = prosjekter.FirstOrDefault(p => p.EierId == SlettProsjekt.BrukerId && p.ProsjektId == SlettProsjekt.ProsjektId);
                if (sjekkEier != null)
                {
                    return(false);    // kan ikke slette eier fra prosjekt
                }
                if (this.mockProductRepository.ErAdmin(u, SlettProsjekt.ProsjektId) == true || this.mockProductRepository.ErEier(u, SlettProsjekt.ProsjektId) == true)
                {
                    try
                    {
                        deltakelser.Remove(SlettProsjekt);
                        return(true);
                    }
                    catch (Exception feil)
                    {
                        return(false);
                    }
                }
                return(false);
            });

            mockProductRepository.Setup(mr => mr.RegistrerProsjekt(It.IsAny <Prosjekt>(), It.IsAny <string>()))
            .Returns(
                (Prosjekt p, string u) =>
            {
                int userId = this.mockProductRepository.BrukerId(u);
                if (p.Arbeidsplass == "" || userId == 0)
                {
                    return(false);
                }
                var nyProsjekt = new Prosjekt()
                {
                    Arbeidsplass = p.Arbeidsplass,
                    EierId       = userId
                };
                var nyProsjektDeltakelse = new Prosjektdeltakelse()
                {
                    BrukerId    = userId,
                    Medlemsdato = DateTime.Now,
                    ProsjektId  = nyProsjekt.ProsjektId
                };

                try
                {
                    prosjekter.Add(nyProsjekt);
                    deltakelser.Add(nyProsjektDeltakelse);

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

            mockProductRepository.Setup(mr => mr.LeggTilBrukerRequest(It.IsAny <ProsjektrequestSkjema>(), It.IsAny <string>()))
            .Returns(
                (ProsjektrequestSkjema p, string u) =>
            {
                int bId    = this.mockProductRepository.BrukerId(u);
                int bIdTil = this.mockProductRepository.BrukerId(p.TilBruker);
                int pId    = p.ProsjektId;

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

                if (bIdTil == 0)
                {
                    return(false);
                }
                var nyRequest = new Prosjektrequest()
                {
                    BrukerIdFra = bId,
                    BrukerIdTil = bIdTil,
                    ProsjektId  = pId,
                    Akseptert   = false,
                    Sendt       = DateTime.Now
                };
                try
                {
                    req.Add(nyRequest);
                    return(true);
                }
                catch (Exception feil)
                {
                    return(false);
                }
            });


            mockProductRepository.Setup(mr => mr.RegistrerProsjektdeltakelse(It.IsAny <ProsjektrequestMelding>(), It.IsAny <string>()))
            .Returns(
                (ProsjektrequestMelding p, string u) =>
            {
                int id = this.mockProductRepository.BrukerId(u);
                IEnumerable <ProsjektDeltakelseOverforing> prosjektReq = from prosj in req
                                                                         from b in bruker
                                                                         from s in prosjekter
                                                                         where prosj.BrukerIdTil == id && prosj.BrukerIdFra == b.BrukerId && prosj.ProsjektId == p.ProsjektId
                                                                         select new ProsjektDeltakelseOverforing()
                {
                    BrukerId   = prosj.BrukerIdTil,
                    ProsjektId = prosj.ProsjektId
                };
                var prosjektD = new Prosjektdeltakelse();
                foreach (var a in prosjektReq)
                {
                    prosjektD.BrukerId    = a.BrukerId;
                    prosjektD.ProsjektId  = a.ProsjektId;
                    prosjektD.Medlemsdato = DateTime.Now;
                }
                try
                {
                    deltakelser.Add(prosjektD);
                    this.mockProductRepository.SlettRequest(prosjektD.ProsjektId, u);
                    return(true);
                }
                catch (Exception feil)
                {
                    return(false);
                }
            });


            /*
             *
             *
             */

            this.mockProductRepository = mockProductRepository.Object;
        }
Exemple #10
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;
        }