/// <summary>
        /// Update a user
        /// </summary>
        /// <param name="id"></param>
        /// <param name="users"></param>
        /// <returns>Returns the user after updated</returns>
        public async Task <Core.Model.Users> PutUsersAsync(int id, Core.Model.Users users)
        {
            var user = await _dbContext.Users.FindAsync(id);

            if (user is null)
            {
                _logger.LogError("User with ID {userId} does not exist", user.Id);
                return(null);
            }
            else
            {
                _logger.LogInformation("Updating user with ID {usersId}.", users.Id);

                // This method only marks the properties changed
                // as modified.

                var newUser = Mapper.MapUsers(users);

                _dbContext.Entry(user).CurrentValues.SetValues(newUser);

                await _dbContext.SaveChangesAsync();

                return(Mapper.MapUsers(newUser));
            }
        }
        /// <summary>
        /// Adds a new Ueser to the DB.
        /// </summary>
        /// <param name="users"></param>
        /// <returns>The user that was added</returns>
        public async Task <Core.Model.Users> PostUsersAsync(Core.Model.Users users)
        {
            var exists = await _dbContext.Users
                         .FirstOrDefaultAsync(u => u.UserName == users.UserName);

            // if username already exist in DB
            // return null.
            if (exists is null)
            {
                var newUser = new Users
                {
                    FirstName = users.FirstName,
                    LastName  = users.LastName,
                    UserName  = users.UserName
                };

                _logger.LogInformation("Adding a new User.");

                _dbContext.Add(newUser);
                await _dbContext.SaveChangesAsync();

                // After the Entity is added, return the Entity
                // by getting the max id (newest Entity).
                int id = await _dbContext.Users.MaxAsync(u => u.Id);

                var addedUser = _dbContext.Users.Find(id);
                return(Mapper.MapUsers(addedUser));
            }
            else
            {
                _logger.LogWarning("User name {username} already exist.", exists.UserName);
                return(null);
            }
        }
 public static Model.Users MapUsers(Core.Model.Users users)
 {
     return(new Model.Users
     {
         Id = users.Id,
         UserName = users.UserName,
         FirstName = users.FirstName,
         LastName = users.LastName,
         Score = users.Score,
         Dogs = users.Dogs.Select(MapDogs).ToList(),
     });
 }
        public void GetUsers()
        {
            //  var mockRepository = new Mock<IProject2Repository>();
            //  var user = new RevDogs.Core.Model.Users
            var listOfUsers = new Core.Model.Users();

            listOfUsers = new Core.Model.Users
            {
                Id        = 1,
                UserName  = "******",
                FirstName = "TestFirstName",
                LastName  = "TestLastName",
                Score     = 1,
            };


            var a = Mapper.MapUsers(listOfUsers);
            Mock <IProject2Repository> mockIProject2Repository = new Mock <IProject2Repository>();

            mockIProject2Repository.Setup(x => x.GetUsersAsync()).Verifiable();
            var usersController = new UsersController(mockIProject2Repository.Object);

            usersController.Should().NotBeNull();
        }