public void ValidRegisterShouldCreateANewUser()
        {
            var options = new DbContextOptionsBuilder <UsersDbContext>()
                          .UseInMemoryDatabase(databaseName: "ValidRegisterShouldCreateANewUser")
                          .Options;

            using (var context = new UsersDbContext(options))
            {
                var usersService = new UsersService(context, registerValidator, config);

                var added = new PostUserDto
                {
                    FirstName = "test_firstName",
                    LastName  = "test_lastName",
                    Username  = "******",
                    Password  = "******"
                };

                var result = usersService.Register(added);
                Assert.IsNull(result);

                var newUser = context.Users.Last();
                Assert.AreEqual(added.FirstName, newUser.FirstName);
                Assert.AreEqual(added.LastName, newUser.LastName);
                Assert.AreEqual(added.Username, newUser.Username);
            }
        }
        public void GetAllShouldReturnAllUsers()
        {
            var options = new DbContextOptionsBuilder <UsersDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(GetAllShouldReturnAllUsers))
                          .Options;

            using (var context = new UsersDbContext(options))
            {
                var usersService = new UsersService(context, registerValidator, config);
                var added1       = new PostUserDto

                {
                    FirstName = "aaaaa",
                    LastName  = "bbbbb",
                    Username  = "******",
                    Password  = "******"
                };
                var added2 = new PostUserDto

                {
                    FirstName = "ccccc",
                    LastName  = "ddddd",
                    Username  = "******",
                    Password  = "******"
                };

                usersService.Register(added1);
                usersService.Register(added2);

                int numberOfElements = usersService.GetAll().Count();

                Assert.NotZero(numberOfElements);
                Assert.AreEqual(2, numberOfElements);
            }
        }
        public void TestNewPost()
        {
            PostUserDto pdto = new PostUserDto("Test", "Test de tests");
            var         test = _postUserController.CreatePostUser(pdto);

            Assert.NotNull((test as ObjectResult).StatusCode);
        }
        public void DeleteShouldDeleteUser()
        {
            var options = new DbContextOptionsBuilder <UsersDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(DeleteShouldDeleteUser))
                          .Options;

            using (var context = new UsersDbContext(options))
            {
                var UsersService = new UsersService(context, registerValidator, config);

                var newUser = new PostUserDto
                {
                    FirstName = "toDel",
                    LastName  = "toDel",
                    Password  = "******",
                    Username  = "******"
                };

                UsersService.Register(newUser);

                User addedUser = context.Users.Last();

                context.Entry(addedUser).State = EntityState.Detached;

                //var addedUser = context.Users.Where(u => u.Username == "alina3").FirstOrDefault();

                UsersService.DeleteUser(addedUser.Id);

                int users = UsersService.GetAll().Count();

                Assert.Zero(users);
            }
        }
        public async Task <KorisnikDto> PostUser(PostUserDto postUser)
        {
            var user = new Korisnik()
            {
                UserName       = postUser.UserName,
                Ime            = postUser.Ime,
                Prezime        = postUser.Prezime,
                Email          = postUser.Email,
                Slika          = postUser.Slika,
                EmailConfirmed = true,
                LockoutEnabled = true,
                SecurityStamp  = Guid.NewGuid().ToString(),
                Lozinka        = postUser.Lozinka
            };

            await _userManager.CreateAsync(user, user.Lozinka);

            await _userManager.AddToRoleAsync(user, "korisnik");

            await _context.SaveChangesAsync();

            var korisnik = _mapper.Map <KorisnikDto>(user);

            return(korisnik);
        }
        public async Task <IActionResult> Token([FromForm] PostUserDto userDto)
        {
            _logger.LogInformation("Invoked api/Accounts/token");

            ClaimsIdentity identity = await GetIdentity(userDto.Username, userDto.Password);

            if (identity == null)
            {
                return(StatusCode(400, new { Message = "Invalid username or password." }));
            }

            var now = DateTime.UtcNow;

            // create token
            var jwt = new JwtSecurityToken(
                issuer: _authOptions.Issuer,
                audience: _authOptions.Audience,
                notBefore: now,
                claims: identity.Claims,
                expires: now.Add(TimeSpan.FromMinutes(_authOptions.Lifetime)),
                signingCredentials: new SigningCredentials(
                    new SymmetricSecurityKey(Encoding.ASCII.GetBytes(_authOptions.SecretKey)),
                    SecurityAlgorithms.HmacSha256));

            var encodedJwt = new JwtSecurityTokenHandler().WriteToken(jwt);

            var response = new
            {
                access_token = encodedJwt,
                username     = identity.Name
            };

            return(StatusCode(200, new { access_token = response.access_token, username = response.username }));
        }
Esempio n. 7
0
        public IActionResult Put(int id, [FromBody] PostUserDto userNew)
        {
            User addedBy = userService.GetCurrentUser(HttpContext);
            var  result  = userService.Upsert(id, userNew, addedBy);

            return(Ok(result));
        }
        public void AuthenticateShouldLoginAUser()
        {
            var options = new DbContextOptionsBuilder <UsersDbContext>()
                          .UseInMemoryDatabase(databaseName: nameof(AuthenticateShouldLoginAUser))
                          .Options;

            using (var context = new UsersDbContext(options))
            {
                var usersService = new UsersService(context, registerValidator, config);
                var added        = new PostUserDto

                {
                    FirstName = "test_first",
                    LastName  = "test_last",
                    Username  = "******",
                    Password  = "******"
                };
                var result        = usersService.Register(added);
                var authenticated = new PostLoginDto
                {
                    Username = "******",
                    Password = "******"
                };

                var authresult = usersService.Authenticate(added.Username, added.Password);
                Assert.IsNotNull(authresult);
                Assert.AreEqual(authenticated.Username, authresult.Username);
            }
        }
        public void TestChangePostLikeNumber()
        {
            PostUserDto pdto = new PostUserDto("Test", "Test de tests");
            var         test = _postUserController.CreatePostUser(pdto);

            var addLike = _postUserController.LikePostUser(((test as OkObjectResult).Value as PostsUser).postId);

            Assert.Equal(1, ((addLike as OkObjectResult).Value as PostsUser).postLike);
        }
Esempio n. 10
0
        public IActionResult Register([FromBody] PostUserDto registerModel)
        {
            var errors = _userService.Register(registerModel); //, out User user);

            if (errors != null)
            {
                return(BadRequest(errors));
            }
            return(Ok()); //user);
        }
Esempio n. 11
0
        public IActionResult Post([FromBody] PostUserDto userNew)
        {
            var user = _userService.Create(userNew);

            if (user == null)
            {
                return(BadRequest(user));
            }
            return(Ok());
        }
Esempio n. 12
0
 public async Task <IActionResult> Post(PostUserDto user)
 {
     try
     {
         return(Ok(await _userService.AddUser(user)));
     }
     catch (System.Exception)
     {
         return(BadRequest());
     }
 }
        public void TestMultiplePostUnlikeNumber()
        {
            PostUserDto pdto = new PostUserDto("Test", "Test de tests");
            var         test = _postUserController.CreatePostUser(pdto);

            var addLike1 = _postUserController.LikePostUser(((test as OkObjectResult).Value as PostsUser).postId);
            var addLike2 = _postUserController.LikePostUser(((test as OkObjectResult).Value as PostsUser).postId);
            var addLike3 = _postUserController.LikePostUser(((test as OkObjectResult).Value as PostsUser).postId);
            var unlike   = _postUserController.UnlikePostUser(((test as OkObjectResult).Value as PostsUser).postId);

            Assert.Equal(2, ((unlike as OkObjectResult).Value as PostsUser).postLike);
        }
Esempio n. 14
0
        public IActionResult CreatePostUser([FromBody] PostUserDto pu)
        {
            var post = pu.CreatePostUser();

            if (post != null)
            {
                _maBd.PostsUser.Add(post);
                _maBd.SaveChanges();

                return(new OkObjectResult(post));
            }
            return(new ObjectResult(null));
        }
Esempio n. 15
0
        public IActionResult Put(int id, [FromBody] PostUserDto userNew)
        {
            //User addedBy = _userService.GetCurrentUser(HttpContext);
            // var result = _userService.Upsert(id, userNew, addedBy);
            User currentLogedUser = _userService.GetCurrentUser(HttpContext);
            var  regDate          = currentLogedUser.CreatedAt;
            var  currentDate      = DateTime.Now;
            var  minDate          = currentDate.Subtract(regDate).Days / (365 / 12);

            if (currentLogedUser.UserRole == UserRole.UserManager)
            {
                User getUser = _userService.GetById(id);
                if (getUser == null)
                {
                    return(NotFound());
                }
            }

            if (currentLogedUser.UserRole == UserRole.UserManager)
            {
                User getUser = _userService.GetById(id);
                if (getUser.UserRole == UserRole.Admin)
                {
                    return(Forbid());
                }
            }

            if (currentLogedUser.UserRole == UserRole.UserManager)
            {
                User getUser = _userService.GetById(id);
                if (getUser.UserRole == UserRole.UserManager && minDate <= 6)
                {
                    return(Forbid());
                }
            }

            if (currentLogedUser.UserRole == UserRole.UserManager)
            {
                User getUser = _userService.GetById(id);
                if (getUser.UserRole == UserRole.UserManager && minDate >= 6)
                {
                    var result1 = _userService.Upsert(id, userNew);
                    return(Ok(result1));
                }
            }

            var result = _userService.Upsert(id, userNew);

            return(Ok(result));;
        }
Esempio n. 16
0
        public IActionResult ModifyPostUser([FromBody] PostUserDto updatedPost, int id)
        {
            var post = _maBd.PostsUser.FirstOrDefault(m => m.postId == id);

            if (post == null)
            {
                return(new ObjectResult(null));
            }

            _maBd.Entry(post).CurrentValues.SetValues(updatedPost);
            _maBd.SaveChanges();

            return(new OkObjectResult(post));
        }
        public async Task <ActionResult> RegisterUser([FromForm] PostUserDto userDto)
        {
            _logger.LogInformation("Invoked api/Accounts/register");

            CoreModels.User coreUser  = _mapper.Map <CoreModels.User>(userDto);
            bool            isCreated = await _userService.AddUserAsync(coreUser, userDto.Password);

            if (isCreated)
            {
                return(StatusCode(201));
            }

            return(StatusCode(400));
        }
        public void Setup()
        {
            config = Options.Create(new AppSettings
            {
                Secret = "adlkfadlkasfaskldffalaksfaDFLKAjdflkadjfaldkfjsd"
            });

            registerValidator = new RegisterValidator();

            user = new PostUserDto
            {
                FirstName = "user_test_big",
                LastName  = "user_test_big",
                Username  = "******",
                Password  = "******"
            };
        }
Esempio n. 19
0
        public async Task <IActionResult> Post([FromBody] PostUserDto postUserDto)
        {
            try
            {
                var serviceResult = await _userservice.CreateUser(postUserDto.Name, postUserDto.Password, (int)postUserDto.UserType);

                if (!serviceResult.Success)
                {
                    return(BadRequest(serviceResult.ValidationMessages));
                }

                var result = _mapper.Map <UserDto>(serviceResult.Result);

                return(Created($"User: {result.UserId}", result));
            }
            catch (Exception ex)
            {
                return(StatusCode(500, ex.Message));
            }
        }
Esempio n. 20
0
        public GetUserDto Register(PostUserDto registerInfo)
        {
            User existing = context.Users.FirstOrDefault(u => u.Username == registerInfo.Username);

            if (existing != null)
            {
                return(null);
            }

            context.Users.Add(new User
            {
                LastName  = registerInfo.LastName,
                FirstName = registerInfo.FirstName,
                Password  = ComputeSha256Hash(registerInfo.Password),
                Username  = registerInfo.Username
            });

            context.SaveChanges();
            return(Authenticate(registerInfo.Username, registerInfo.Password));
        }
Esempio n. 21
0
        public void userIsValid(PostUserDto user)
        {
            var errorMessagesList = new List <string> {
            };

            if (user.Username == null)
            {
                errorMessagesList.Add("Username cannot be empty");
            }
            if (user.Name == null)
            {
                errorMessagesList.Add("Name cannot be empty");
            }

            string pattern = null;

            pattern = "^[0-9]{10}$";

            if (!Regex.IsMatch(user.PhoneNumber, pattern))
            {
                errorMessagesList.Add("Invalid Phone, must have 10 digits");
            }
            try
            {
                MailAddress m = new MailAddress(user.Email);
            }
            catch (System.Exception)
            {
                errorMessagesList.Add("Invalid Format Email");
            }
            pattern = "^[a-zA-Z0-9]{3,}$";
            if (!Regex.IsMatch(user.Password, pattern))
            {
                errorMessagesList.Add("Invalid format password, minimun 4 length");
            }
            if (errorMessagesList.Count() != 0)
            {
                string errorMessages = string.Join(",", errorMessagesList);
                throw new Exception(errorMessages);
            }
        }
        public ErrorsCollection Register(PostUserDto registerInfo)
        {
            var errors = registerValidator.Validate(registerInfo, context);

            if (errors != null)
            {
                return(errors);
            }

            context.Users.Add(new User
            {
                LastName  = registerInfo.LastName,
                FirstName = registerInfo.FirstName,
                Password  = ComputeSha256Hash(registerInfo.Password),
                Username  = registerInfo.Username,
                UserRole  = UserRole.Regular
            });

            context.SaveChanges();
            //return Authenticate(registerInfo.Username, registerInfo.Password);
            return(null);
        }
Esempio n. 23
0
        public IActionResult CreateUser([FromBody] PostUserDto user)
        {
            if (user == null)
            {
                return(BadRequest());
            }

            var userEntity = mapper.Map <UserEntity>(user);

            userEntity = userRepository.Insert(userEntity);

            if (!ModelState.IsValid)
            {
                return(UnprocessableEntity(ModelState));
            }

            return(CreatedAtRoute(
                       nameof(GetUserById),
                       new { userId = userEntity.Id },
                       userEntity.Id
                       ));
        }
        public ErrorsCollection Validate(PostUserDto postUserDto, UsersDbContext usersDbContext)
        {
            ErrorsCollection errorsCollection = new ErrorsCollection {
                Entity = nameof(postUserDto)
            };

            User existing = usersDbContext.Users.FirstOrDefault(u => u.Username == postUserDto.Username);

            if (existing != null)
            {
                errorsCollection.ErrorMessages.Add($"Username {postUserDto.Username} is already used!");
            }


            if (postUserDto.Password.Length < 6)
            {
                errorsCollection.ErrorMessages.Add("The password has to have > 5 chars");
            }

            int numberOfDigits = 0;

            foreach (char c in postUserDto.Password)
            {
                if (c >= '0' && c <= '9')
                {
                    numberOfDigits++;
                }
            }
            if (numberOfDigits < 2)
            {
                errorsCollection.ErrorMessages.Add("The password must contain at least 2 digits");
            }

            if (errorsCollection.ErrorMessages.Count > 0)
            {
                return(errorsCollection);
            }
            return(null);
        }
Esempio n. 25
0
        public ErrorsCollection Register(PostUserDto registerInfo)
        {
            var errors = registerValidator.Validate(registerInfo, context);

            if (errors != null)
            {
                return(errors);
            }

            User userToAdd = new User
            {
                LastName      = registerInfo.LastName,
                FirstName     = registerInfo.FirstName,
                Password      = ComputeSha256Hash(registerInfo.Password),
                Username      = registerInfo.Username,
                UserUserRoles = new List <UserUserRole>(),
                DateAdded     = DateTime.Now
            };
            var regularRole = context
                              .UserRoles
                              .FirstOrDefault(ur => ur.Name == UserRoles.Regular);

            context.Users.Add(userToAdd);
            //context.SaveChanges();

            context.UserUserRoles.Add(new UserUserRole
            {
                User      = userToAdd,
                UserRole  = regularRole,
                StartTime = DateTime.Now,
                EndTime   = null
            });


            context.SaveChanges();
            //return Authenticate(registerInfo.Username, registerInfo.Password);
            return(null);
        }
Esempio n. 26
0
        public async Task <ResponseService <GetUserDto> > AddUser(PostUserDto user)
        {
            var response = new ResponseService <GetUserDto>();

            try
            {
                new ObjectValidation().userIsValid(user);

                User userTrueFormat = _mapper.Map <User>(user);
                User userExist      = _context.Users.FirstOrDefault(u => u.Username == user.Username || u.Email == user.Email);

                if (userExist != null)
                {
                    throw new System.Exception("User Already exist");
                }

                CreatePasswordHash(user.Password, out byte[] passwordHash, out byte[] passwordSalt);
                userTrueFormat.PasswordHash = passwordHash;
                userTrueFormat.Salt         = passwordSalt;

                await _context.Users.AddAsync(userTrueFormat);

                await _context.SaveChangesAsync();

                response.Data    = _mapper.Map <GetUserDto>(user);
                response.Success = true;
                response.Message = "User creation successfull!";
            }
            catch (System.Exception ex)
            {
                response.Success = false;
                response.Message = ex.Message;
            }

            return(response);
        }
Esempio n. 27
0
        public IActionResult Register([FromBody] PostUserDto registerModel)
        {
            var user = _userService.Register(registerModel);

            return(Ok(user));
        }
        public async Task <KorisnikDto> AddUser(PostUserDto postUser)
        {
            var user = await _service.PostUser(postUser);

            return(user);
        }