Пример #1
0
        public async Task <EditPatientViewModel> GetPatient(string email)
        {
            var user = new EClinicUser();

            if (String.IsNullOrEmpty(email))
            {
                throw new ArgumentException("email is Null");
            }

            try
            {
                user = this.db.Users.FirstOrDefault(x => x.Email == email && x.IsDeleted == false);
            }
            catch (Exception e)
            {
                throw new ArgumentException("email is Null");
            }

            var exams = await this.examService.GetAllExamForPatient(email);

            var userToReturnn = new EditPatientViewModel()
            {
                Address    = user.Address,
                Age        = user.Age,
                CreatedOn  = user.CreatedOn,
                FirstName  = user.FirstName,
                MiddleName = user.MiddleName,
                LastName   = user.LastName,
                ImageUrl   = user.ImageUrl,
                Email      = user.Email,
                Exams      = exams
            };

            return(userToReturnn);
        }
Пример #2
0
        public async void ShowLastAppointmentForUserShoulThrowExeption()
        {
            //Arrange

            var options = new DbContextOptionsBuilder <EClinicDbContext>()
                          .UseInMemoryDatabase(databaseName: "Appointment_CreateAppointment")
                          .Options;
            var dbContext = new EClinicDbContext(options);

            var appointmentService = new Mock <AppointmentService>(dbContext).Object;

            AutoMapperConfig.RegisterMappings(typeof(SetingViewModel).GetTypeInfo().Assembly);
            var mockUserStore = new Mock <IUserStore <EClinicUser> >();

            var userManager = new UserManager <EClinicUser>(mockUserStore.Object, null, null, null, null, null, null, null, null);

            var AdminUserToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Ivo",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "Nqkyde Tam 35",
                Age           = 25,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            var userToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Petyr",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "I tuk i tam",
                Age           = 30,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            dbContext.Users.Add(AdminUserToAdd);
            dbContext.Users.Add(userToAdd);

            dbContext.SaveChanges();

            var date = new DateTime(2019, 08, 03, 09, 00, 00);

            await appointmentService.CreateAppointment("*****@*****.**", "*****@*****.**", date);

            dbContext.Appointments.Where(x => true).ToList();


            await Assert.ThrowsAsync <ArgumentException>(async() => await appointmentService.ShowLastAppointmentForUser(""));
        }
Пример #3
0
        public async Task <bool> DeleteUser(string email)
        {
            var user = new EClinicUser();

            if (String.IsNullOrWhiteSpace(email))
            {
                throw new ArgumentException("Delete User needs valid email");
            }

            try
            {
                user = await this.db.Users.FirstOrDefaultAsync(x => x.Email == email);
            }
            catch (Exception e)
            {
                throw new ArgumentException("Delete User needs valid email");
            }


            if (user == null)
            {
                return(false);
            }

            user.IsDeleted = true;
            user.DeletedOn = DateTime.UtcNow;

            await this.db.SaveChangesAsync();

            return(true);
        }
Пример #4
0
        public async Task <IActionResult> OnPostAsync(string returnUrl = null)
        {
            returnUrl = returnUrl ?? Url.Content("~/");
            if (ModelState.IsValid)
            {
                var isRoot = _userManager.Users.Any();

                var user = new EClinicUser {
                    UserName   = Input.Email,
                    Address    = Input.Address,
                    Age        = Input.Age,
                    CreatedOn  = DateTime.UtcNow,
                    FirstName  = Input.FirstName,
                    MiddleName = Input.MiddleName,
                    LastName   = Input.LastName,
                    Email      = Input.Email
                };
                var result = await _userManager.CreateAsync(user, Input.Password);

                if (result.Succeeded)
                {
                    if (!isRoot)
                    {
                        await _userManager.AddToRoleAsync(user, GlobalConstants.AdministratorRoleName);
                    }
                    else
                    {
                        await _userManager.AddToRoleAsync(user, GlobalConstants.UserRoleName);
                    }

                    #region Email sender
                    //_logger.LogInformation("User created a new account with password.");

                    //var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                    //var callbackUrl = Url.Page(
                    //    "/Account/ConfirmEmail",
                    //    pageHandler: null,
                    //    values: new { userId = user.Id, code = code },
                    //    protocol: Request.Scheme);

                    //await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
                    //    $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
                    #endregion


                    await _signInManager.SignInAsync(user, isPersistent : false);

                    return(LocalRedirect(returnUrl));
                }
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }

            // If we got this far, something failed, redisplay form
            return(Page());
        }
Пример #5
0
        public async Task <bool> EditUser(EditUserViewModel viewModel)
        {
            EClinicUser user = new EClinicUser();

            try
            {
                user = this.db.Users.First(x => x.Email == viewModel.Email);
            }
            catch (Exception e)
            {
                throw new ArgumentException("Edit user model is mising Email");
            }

            if (user == null)
            {
                return(false);
            }

            var rolesToChange = viewModel.UserRoles;
            var allRoles      = this.db.Roles.Select(x => x.Name).ToList();

            foreach (var role in allRoles)
            {
                if (viewModel.UserRoles.Contains(role))
                {
                    if (!await this.userManager.IsInRoleAsync(user, role))
                    {
                        await this.userManager.AddToRoleAsync(user, role);
                    }
                }
                else
                {
                    if (user.Email != "*****@*****.**" && role != "Administrator")
                    {
                        await this.userManager.RemoveFromRoleAsync(user, role);
                    }
                }
            }

            user.FirstName  = viewModel.FirstName;
            user.MiddleName = viewModel.MiddleName;
            user.LastName   = viewModel.LastName;
            user.Address    = viewModel.Address;
            user.Age        = viewModel.Age;
            user.ModifiedOn = DateTime.UtcNow;


            var changesCount = this.db.SaveChanges();

            if (changesCount > 0)
            {
                return(true);
            }

            return(false);
        }
Пример #6
0
        public async Task <bool> EditPatient(EditPatientViewModel viewModel)
        {
            EClinicUser user = new EClinicUser();

            try
            {
                user = this.db.Users.First(x => x.Email == viewModel.Email);
            }
            catch (Exception e)
            {
                throw new ArgumentException("Edit user model is mising Email");
            }

            if (user == null)
            {
                return(false);
            }


            user.FirstName  = viewModel.FirstName;
            user.MiddleName = viewModel.MiddleName;
            user.LastName   = viewModel.LastName;
            user.Address    = viewModel.Address;
            user.Age        = viewModel.Age;
            user.ModifiedOn = DateTime.UtcNow;
            user.ImageUrl   = viewModel.ImageUrl;;


            var changesCount = this.db.SaveChanges();

            if (changesCount > 0)
            {
                return(true);
            }

            return(false);
        }
Пример #7
0
        public async void GetUserWhitEmptyModelShoulThrowExeption()
        {
            var options = new DbContextOptionsBuilder <EClinicDbContext>()
                          .UseInMemoryDatabase(databaseName: "Appointment_CreateAppointment")
                          .Options;
            var dbContext = new EClinicDbContext(options);

            //var mockUserStore = new Mock<IUserStore<EClinicUser>>();
            //var mockRoleManager = new Mock<IUserRoleStore<EClinicUser>>();

            //var userManager = new UserManager<EClinicUser>(mockUserStore.Object, null, null, null, null, null, null, null, null);
            var userManager = MockHelpers.MockUserManager <EClinicUser>().Object;

            var examService        = new Mock <ExamService>(dbContext).Object;
            var appointmentService = new Mock <AppointmentService>(dbContext).Object;
            var usersService       = new Mock <UsersService>(dbContext, userManager, examService).Object;

            AutoMapperConfig.RegisterMappings(typeof(SetingViewModel).GetTypeInfo().Assembly);



            var AdminUserToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Ivo",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "Nqkyde Tam 35",
                Age           = 25,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            var userToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Petyr",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "I tuk i tam",
                Age           = 30,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            dbContext.Users.Add(AdminUserToAdd);
            dbContext.Users.Add(userToAdd);

            dbContext.SaveChanges();

            var date = new DateTime(2019, 08, 03, 09, 00, 00);
            await appointmentService.CreateAppointment("*****@*****.**", "*****@*****.**", date);

            var exam = new CreateExamInputModel()
            {
                Condition       = "good",
                DoctorUserName  = "******",
                Diagnose        = "adss",
                PatientUserName = "******",
                Prescription    = "sdfsdd"
            };

            await examService.CreateExam(exam);

            dbContext.Appointments.Where(x => true).ToList();


            await Assert.ThrowsAsync <ArgumentException>(async() => await usersService.GetUser(""));
        }
Пример #8
0
        public async void CreateAppointmentForUnexistingUserAndDoctorShouldReturnTrue()
        {
            //Arrange

            var options = new DbContextOptionsBuilder <EClinicDbContext>()
                          .UseInMemoryDatabase(databaseName: "Appointment_CreateAppointment")
                          .Options;
            var dbContext = new EClinicDbContext(options);

            var appointmentService = new AppointmentService(dbContext);

            //var usrManager = MockHelpers.MockUserManager<EClinicUser>();

            var mockUserStore = new Mock <IUserStore <EClinicUser> >();

            var userManager = new UserManager <EClinicUser>(mockUserStore.Object, null, null, null, null, null, null, null, null);
            //userManager.UserValidators.Add(new UserValidator<EClinicUser>());
            //userManager.PasswordValidators.Add(new PasswordValidator<EClinicUser>());


            var AdminUserToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Ivo",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "Nqkyde Tam 35",
                Age           = 25,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            var userToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Petyr",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "I tuk i tam",
                Age           = 30,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };


            //await userManager.CreateAsync(AdminUserToAdd);
            //await userManager.CreateAsync(userToAdd);
            dbContext.Users.Add(AdminUserToAdd);
            dbContext.Users.Add(userToAdd);

            dbContext.SaveChanges();


            int count = dbContext.Users.Count();

            var result = await appointmentService.CreateAppointment("*****@*****.**", "*****@*****.**", new DateTime(2019, 08, 03, 09, 00, 00));


            Assert.True(result);
        }
Пример #9
0
        public async void GetAllAppointsmentDatesForDoctorForDayShoulReturnOne()
        {
            //Arrange

            var options = new DbContextOptionsBuilder <EClinicDbContext>()
                          .UseInMemoryDatabase(databaseName: "Appointment_CreateAppointment")
                          .Options;
            var dbContext = new EClinicDbContext(options);

            var appointmentService = new Mock <AppointmentService>(dbContext).Object;

            AutoMapperConfig.RegisterMappings(typeof(SetingViewModel).GetTypeInfo().Assembly);
            var mockUserStore = new Mock <IUserStore <EClinicUser> >();

            var userManager = new UserManager <EClinicUser>(mockUserStore.Object, null, null, null, null, null, null, null, null);

            var AdminUserToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Ivo",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "Nqkyde Tam 35",
                Age           = 25,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            var userToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Petyr",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "I tuk i tam",
                Age           = 30,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            dbContext.Users.Add(AdminUserToAdd);
            dbContext.Users.Add(userToAdd);

            dbContext.SaveChanges();

            var date = new DateTime(2019, 08, 03, 09, 00, 00);

            await appointmentService.CreateAppointment("*****@*****.**", "*****@*****.**", date);

            dbContext.Appointments.Where(x => true).ToList();

            //Act
            var result = await appointmentService.GetAllAppointsmentDatesForDoctorForDay(userToAdd.UserName, date);

            var actual = dbContext.Appointments.Where(x => x.DoctorId == dbContext.Users.FirstOrDefault(d => d.Email == "*****@*****.**").Id).ToList();

            //Assert
            Assert.Equal(actual.Count(), result.Count());
        }
Пример #10
0
        public async Task SeedAsync(EClinicDbContext dbContext, IServiceProvider serviceProvider)
        {
            if (dbContext == null)
            {
                throw new ArgumentNullException(nameof(dbContext));
            }

            if (serviceProvider == null)
            {
                throw new ArgumentNullException(nameof(serviceProvider));
            }

            var logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger(typeof(SiteDbContextSeeder));

            var userStore = serviceProvider.GetService <UserManager <EClinicUser> >();

            var seeders = new List <ISeeder>
            {
                new SiteSeeder(),
            };

            foreach (var seeder in seeders)
            {
                await seeder.SeedAsync(dbContext, serviceProvider);

                await dbContext.SaveChangesAsync();

                logger.LogInformation($"Seeder {seeder.GetType().Name} done.");
            }

            var AdminUserToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Ivo",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "Nqkyde Tam 35",
                Age           = 25,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            var userToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Petyr",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "I tuk i tam",
                Age           = 30,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };


            await userStore.CreateAsync(AdminUserToAdd, "123456");

            await userStore.CreateAsync(userToAdd, "123456");

            dbContext.SaveChanges();
            var adminUser = await userStore.FindByEmailAsync("*****@*****.**");

            var user = await userStore.FindByEmailAsync("*****@*****.**");

            await userStore.AddToRoleAsync(adminUser, GlobalConstants.AdministratorRoleName);

            await userStore.AddToRoleAsync(user, GlobalConstants.UserRoleName);
        }
Пример #11
0
        public async void CreateExamWithNoPRescriptionShoulReturnFalse()
        {
            var options = new DbContextOptionsBuilder <EClinicDbContext>()
                          .UseInMemoryDatabase(databaseName: "Appointment_CreateAppointment")
                          .Options;
            var dbContext = new EClinicDbContext(options);

            //var mockUserStore = new Mock<IUserStore<EClinicUser>>();
            //var mockRoleManager = new Mock<IUserRoleStore<EClinicUser>>();

            //var userManager = new UserManager<EClinicUser>(mockUserStore.Object, null, null, null, null, null, null, null, null);
            var userManager = MockHelpers.MockUserManager <EClinicUser>().Object;

            var examService        = new Mock <ExamService>(dbContext).Object;
            var appointmentService = new Mock <AppointmentService>(dbContext).Object;
            var usersService       = new Mock <UsersService>(dbContext, userManager, examService).Object;

            AutoMapperConfig.RegisterMappings(typeof(SetingViewModel).GetTypeInfo().Assembly);



            var AdminUserToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Ivo",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "Nqkyde Tam 35",
                Age           = 25,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            var userToAdd = new EClinicUser
            {
                Email              = "*****@*****.**",
                FirstName          = "Petyr",
                MiddleName         = "Peshov",
                LastName           = "Petrov",
                UserName           = "******",
                NormalizedEmail    = "*****@*****.**",
                NormalizedUserName = "******",
                Address            = "I tuk i tam",
                Age           = 30,
                SecurityStamp = Guid.NewGuid().ToString(),
                CreatedOn     = DateTime.UtcNow,
            };

            dbContext.Users.Add(AdminUserToAdd);
            dbContext.Users.Add(userToAdd);

            dbContext.SaveChanges();


            var exam = new CreateExamInputModel()
            {
                Condition       = "good",
                DoctorUserName  = "******",
                Diagnose        = "ssdcsds",
                PatientUserName = "******",
                Prescription    = ""
            };

            bool result = await examService.CreateExam(exam);


            Assert.False(result);
        }