public void TestInit()
        {
            Fixture = new Fixture();
            Fixture.Behaviors.OfType <ThrowingRecursionBehavior>().ToList().ForEach(b => Fixture.Behaviors.Remove(b));
            Fixture.Behaviors.Add(new OmitOnRecursionBehavior());

            var benutzerList = new List <Benutzer>();

            Fixture.AddManyTo(benutzerList);
            Fixture.RepeatCount = 10;
            Fixture.AddManyTo(benutzerList);

            var mockBenutzerRepository = new Mock <IBenutzerRepository>();

            mockBenutzerRepository.Setup(x => x.SearchUser()).Returns(benutzerList);
            mockBenutzerRepository.Setup(x => x.SearchAllMitarbeiterWithPaging(It.IsAny <int>(), It.IsAny <int>())).Returns(benutzerList);
            mockBenutzerRepository.Setup(x => x.SearchUserById(It.IsAny <int>())).Returns(Fixture.Build <Benutzer>().With(x => x.BenutzerId, 1).With(x => x.EMailVerificationCode, "TestHash").With(x => x.PasswordVerificationCode, "TestHash").Create());
            mockBenutzerRepository.Setup(x => x.SearchUserByIdNoTracking(It.IsAny <int>())).Returns(Fixture.Build <Benutzer>().With(x => x.BenutzerId, 1).Create());
            mockBenutzerRepository.Setup(x => x.SearchUserByEMail(It.IsAny <string>())).Returns(Fixture.Build <Benutzer>().With(x => x.Mail, "*****@*****.**").Create());
            mockBenutzerRepository.Setup(x => x.GetMitarbeiterCount()).Returns(10);
            mockBenutzerRepository.Setup(x => x.AddUser(It.IsAny <Benutzer>()));
            mockBenutzerRepository.Setup(x => x.EditUser(It.IsAny <Benutzer>()));
            mockBenutzerRepository.Setup(x => x.RemoveUser(It.IsAny <Benutzer>()));
            MockBenutzerRepository = mockBenutzerRepository.Object;

            var mockBenutzerGruppeService = new Mock <IBenutzerGruppeService>();

            mockBenutzerGruppeService.Setup(x => x.SearchGroupByBezeichnung(It.IsAny <string>())).Returns(Fixture.Build <BenutzerGruppe>().With(x => x.Bezeichnung, "TestBezeichnung").Create());
            MockBenutzerGruppeService = mockBenutzerGruppeService.Object;

            var mockMapper = new Mock <IMapper>();

            mockMapper.Setup(s => s.Map <Benutzer, Benutzer>(It.IsAny <Benutzer>(), It.IsAny <Benutzer>()));
            MockMapper = mockMapper.Object;

            var mockMd5Hash = new Mock <IMd5Hash>();

            mockMd5Hash.Setup(s => s.CalculateMD5Hash(It.IsAny <string>())).Returns("TestHash");
            MockMD5Hash = mockMd5Hash.Object;

            var mockMailService = new Mock <IMailService>();

            mockMailService.Setup(x => x.SendForgottenPasswordMail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
            mockMailService.Setup(x => x.SendNewMitarbeiterMail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
            mockMailService.Setup(x => x.SendRegisterMail(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()));
            MockMailService = mockMailService.Object;

            BenutzerService = new BenutzerService(MockBenutzerRepository, MockMailService, MockBenutzerGruppeService, MockMD5Hash);
        }
        // GET: Benutzer/Details/5
        public ActionResult DetailsCaterer(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            DetailsCatererViewModel detailsCatererViewModel =
                BenutzerViewModelService.Map_Benutzer_DetailsCatererViewModel(BenutzerService.SearchUserById(Convert.ToInt32(id)));

            if (detailsCatererViewModel == null)
            {
                return(HttpNotFound());
            }
            return(View(detailsCatererViewModel));
        }
        // GET: Benutzer/Mydata/5
        public ActionResult EditCaterer(int?id)
        {
            if (id == null)
            {
                return(View("~/Views/Shared/Error.cshtml"));
            }

            MyDataBenutzerViewModel myDataBenutzerViewModel =
                BenutzerViewModelService.Map_Benutzer_MyDataBenutzerViewModel(BenutzerService.SearchUserById(Convert.ToInt32(id)));

            if (myDataBenutzerViewModel == null)
            {
                return(HttpNotFound());
            }
            return(View(myDataBenutzerViewModel));
        }
        // GET: Benutzer/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }

            EditBenutzerViewModel editBenutzerViewModel =
                BenutzerViewModelService.Map_Benutzer_EditBenutzerViewModel(BenutzerService.SearchUserById(Convert.ToInt32(id)));

            if (editBenutzerViewModel == null)
            {
                return(HttpNotFound());
            }
            return(View(editBenutzerViewModel));
        }
Exemple #5
0
 public ActionResult PasswordRequest(ForgottenPasswordRequestViewModel forgottenPasswordRequestViewModel)
 {
     if (ModelState.IsValid)
     {
         if (!BenutzerService.CheckEmailForRegistration(forgottenPasswordRequestViewModel.Mail))
         {
             BenutzerService.ForgottenPasswordEmailForBenutzer(forgottenPasswordRequestViewModel.Mail);
             return(View("PasswordRequestComplete"));
         }
         else
         {
             return(View("PasswordRequestComplete"));
         }
     }
     return(View());
 }
 public ActionResult EditCaterer(MyDataBenutzerViewModel myDataBenutzerViewModel)
 {
     if (ModelState.IsValid)
     {
         if (Request.Form["btnSave"] != null)
         {
             BenutzerService.EditCaterer(BenutzerViewModelService.Map_MyDataBenutzerViewModel_Benutzer(myDataBenutzerViewModel));
             TempData["isSaved"] = true;
         }
         else if (Request.Form["btnModalDelete"] != null)
         {
             BenutzerService.RemoveCaterer(BenutzerViewModelService.Map_MyDataBenutzerViewModel_Benutzer(myDataBenutzerViewModel).BenutzerId);
             TempData["isAccountDeleted"] = true;
         }
         return(RedirectToAction("IndexCaterer", "Benutzer"));
     }
     return(View(BenutzerViewModelService.AddListsToMyDataViewModel(myDataBenutzerViewModel)));
 }
        public ActionResult CreateCaterer(CreateCatererViewModel createCatererViewModel)
        {
            if (ModelState.IsValid)
            {
                if (BenutzerService.CheckEmailForRegistration(createCatererViewModel.Mail))
                {
                    BenutzerService.AddCaterer(BenutzerViewModelService.Map_CreateCatererViewModel_Benutzer(createCatererViewModel), BenutzerGruppenResource.Caterer);
                }
                else
                {
                    ModelState.AddModelError("", LoginResources.EMailVorhanden);
                    return(View(BenutzerViewModelService.AddListsToCreateCatererViewModel(createCatererViewModel)));
                }
                return(RedirectToAction("IndexCaterer"));
            }

            return(View(BenutzerViewModelService.AddListsToCreateCatererViewModel(createCatererViewModel)));
        }
Exemple #8
0
        public ActionResult Register(RegisterBenutzerViewModel registerBenutzerViewModel)
        {
            if (ModelState.IsValid)
            {
                if (BenutzerService.CheckEmailForRegistration(registerBenutzerViewModel.Mail))
                {
                    BenutzerService.RegisterBenutzer(BenutzerViewModelService.Map_RegisterBenutzerViewModel_Benutzer(registerBenutzerViewModel));
                }
                else
                {
                    ModelState.AddModelError("", LoginResources.EMailVorhanden);
                    return(View(BenutzerViewModelService.AddListsToRegisterViewModel(registerBenutzerViewModel)));
                }
                return(RedirectToAction("RegisterSuccsessfull"));
            }

            return(View(BenutzerViewModelService.AddListsToRegisterViewModel(registerBenutzerViewModel)));
        }
Exemple #9
0
        public BenutzerModule(BenutzerService benutzerService)
            : base("/benutzer")
        {
            Get["/"] = p =>
            {
                var benutzer = benutzerService.Get();
                return(new JsonResponse(benutzer, new JsonNetSerializer()));
            };

            Get["/{id}"] = p =>
            {
                var benutzer = benutzerService.Get(p.id);
                if (benutzer == null)
                {
                    return(HttpStatusCode.NotFound);
                }
                return(new JsonResponse(benutzer, new JsonNetSerializer()));
            };



            Post["/"] = p =>
            {
                Benutzer post = this.Bind();
                try
                {
                    var result = benutzerService.Add(post);
                }
                catch (Exception ex)
                {
                    log.errorLog(ex.Message);
                    return(HttpStatusCode.BadRequest);
                }
                return(HttpStatusCode.Created);
            };

            Put["/"] = p =>
            {
                Benutzer put = this.Bind();
                try
                {
                    var result = benutzerService.Update(put);
                }
                catch (Exception ex)
                {
                    log.errorLog(ex.Message);
                    return(HttpStatusCode.BadRequest);
                }
                return(HttpStatusCode.OK);
            };

            Delete["/{id}"] = p =>
            {
                try
                {
                    var result = benutzerService.Delete(p.id);
                    return(new JsonResponse(result, new DefaultJsonSerializer()));
                }
                catch (Exception ex)
                {
                    log.errorLog(ex.Message);
                    return(HttpStatusCode.BadRequest);
                }
            };
        }
        public ActionResult DeleteConfirmed(int?id)
        {
            BenutzerService.RemoveBenutzer(Convert.ToInt32(id));

            return(RedirectToAction("Index"));
        }