public async Task<User> MapData(UserModel um)
 {
     User u = new User();
     var iUser = await getIdentityUser(um.UserName, um.Password);           
    
     u.Id = um.Id;
     u.RNR = um.RNR;
     u.FirstName = um.FirstName;
     u.LastName = um.LastName;
     u.Street = um.Street;
     u.HouseNr = um.HouseNr;
     u.Bus = um.Bus;
     u.City = um.City;
     u.PostalCode = um.PostalCode;
     u.AuthUserId = iUser.Id;
     return u;
 }
        public UserModel getAccounts([FromUri] string username)
        {
            var identity = (ClaimsIdentity)User.Identity;
            var userModel = new UserModel();
            if (identity.GetUserId().Equals(_repo.FindByEmail(username).Id))
            {
                //In our application the username of a user is his/her email adres.
                var iUser = _repo.FindByEmail(username);
                var userToMap = _db.Users.Where(u => u.AuthUserId.Equals(iUser.Id)).Single();
                userModel = new UserETMAdapter().MapData(userToMap);
            }
            else
            {
                throw new HttpResponseException(HttpStatusCode.Unauthorized);
            }

            return userModel;
        }
        public async Task<IdentityResult> RegisterUser(UserModel userModel)
        {
            IdentityUser user = new IdentityUser
            {
                UserName = userModel.UserName,
                Email = userModel.UserName,
                PhoneNumber = userModel.PhoneNumber
            };

            var result = await _userManager.CreateAsync(user, userModel.Password);

            var users = _db.Users.ToList();
            if(!(users.Count > 0)){
                _roleManager.Create(new IdentityRole("Admin"));
                _userManager.AddToRole(user.Id, "Admin");
            }

            return result;
        }
        public UserModel MapData(User u)
        {
            UserModel um = new UserModel();
            IdentityUser iUser = GetUser(u.AuthUserId);

            um.UserName = iUser.UserName;
            um.RNR = u.RNR;
            um.FirstName = u.FirstName;
            um.LastName = u.LastName;
            um.Street = u.Street;
            um.HouseNr = u.HouseNr;
            um.Bus = u.Bus;
            um.City = u.City;
            um.PostalCode = u.PostalCode;
            um.PhoneNumber = iUser.PhoneNumber;
            um.AuthUserId = iUser.Id;
            um.Id = u.Id;
            um.Roles = iUser.Roles;

            return um;
        }
        public async Task<IHttpActionResult> Register(UserModel userModel)
        {         
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            IdentityResult result = await _repo.RegisterUser(userModel);

            IHttpActionResult errorResult = GetErrorResult(result);             

            if (errorResult != null)
            {
                return errorResult;
            }
            _db.Users.Add(await new UserMTEAdapter().MapData(userModel));

            _db.SaveChanges();

            return Ok();
        }