public async Task <IHttpActionResult> CreateUser(CreateUserBinding newUser)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var user = new IdentityUser(newUser.ClientId, newUser.UserName)
            {
                Email     = newUser.Email,
                FirstName = newUser.FirstName,
                LastName  = newUser.LastName,
                Level     = 1,
                JoinDate  = DateTime.Now.Date,
            };

            var addUserResult = await JWTUserManager.CreateAsync(user, newUser.Password);

            if (!addUserResult.Succeeded)
            {
                return(GetErrorResult(addUserResult));
            }

            var code = await JWTUserManager.GenerateEmailConfirmationTokenAsync(user.Id);

            var callbackUrl = new Uri(Url.Link("ConfirmEmailRoute", new { userId = user.Id, code = code }));

            await JWTUserManager.SendEmailAsync(user.Id, JWTAuthServerConstants.ConfirmMailSubject,
                                                string.Format(JWTAuthServerConstants.ConfirmMailBody, callbackUrl));

            var locationHeader = new Uri(Url.Link("GetUserById", new { id = user.Id }));

            return(Created(locationHeader, EntityFactory.Create(user)));
        }
        public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var verifiedAccessToken = await VerifyExternalAccessToken(model.Provider, model.ExternalAccessToken);

            if (verifiedAccessToken == null)
            {
                return(BadRequest("Invalid Provider or External Access Token"));
            }

            var user =
                await JWTUserLoginManager.FindUserByLoginAsync(new IdentityUserLogin()
            {
                LoginProvider = model.Provider,
                ProviderKey   = verifiedAccessToken.user_id
            }
                                                               );

            var hasRegistered = user != null;

            if (hasRegistered)
            {
                return(BadRequest("External user is already registered"));
            }

            user = new IdentityUser(model.ClientId, model.UserName)
            {
                Email = model.EMail
            };

            var result = await JWTUserManager.CreateAsync(user);

            if (!result.Succeeded)
            {
                return(GetErrorResult(result));
            }

            var userRole = await JWTRoleManager.FindByNameAsync(IdentityConstants.User);

            if (userRole != null)
            {
                await JWTUserManager.AddToRoleAsync(user, userRole);
            }

            result = await JWTUserLoginManager.CreateAsync(new IdentityUserLogin()
            {
                UserId          = user.Id
                , ClientId      = user.ClientId
                , LoginProvider = model.Provider
                , ProviderKey   = verifiedAccessToken.user_id
            }
                                                           );

            if (!result.Succeeded)
            {
                return(GetErrorResult(result));
            }

            //generate access token response
            var accessTokenResponse = GenerateLocalAccessTokenResponse(user);

            return(Ok(accessTokenResponse));
        }