public async Task <dynamic> RegisterExternal(RegisterExternalViewModel viewModel)
{
return(await ExecuteInMonitoring(async() =>
{
return await service.RegisterExternalAsync(userManager, viewModel);
}));
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var info = await Authentication.GetExternalLoginInfoAsync();
if (info == null)
{
return(InternalServerError());
}
var user = new ApplicationUser()
{
UserName = model.Email, Email = model.Email
};
IdentityResult result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
result = await _userManager.AddLoginAsync(user.Id, info.Login);
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public ActionResult RegisterExternal(RegisterExternalViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
else
{
return(FinishResigration(new RegisterViewModel(model)));
}
}
public async Task <RegisterResponse> RegisterExternal(RegisterExternalViewModel viewModel)
{
var apiModel = new RegisterExternalApiModel()
{
provider = viewModel.Provider,
ExternalAccessToken = viewModel.ExternalAccessToken,
userName = viewModel.UserName
};
var response = await ApiClient.PostJsonEncodedContent(RegisterExternalUri, apiModel);
var registerResponse = await CreateJsonResponse <RegisterResponse>(response);
return(registerResponse);
}
public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
{
var result = new RegisterExternalViewModel();
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 _authAccess.FindAsync(new UserLoginInfo(model.Provider, verifiedAccessToken.user_id));
bool hasRegistered = user != null;
if (hasRegistered)
{
return(BadRequest("External user is already registered"));
}
user = new ApplicationUser()
{
UserName = string.Format("{0}_{1}", model.Provider, model.Email), Email = model.Email
};
var userResult = await _authAccess.CreateAsync(user);
if (!userResult.Succeeded)
{
return(GetErrorResult(userResult));
}
var roleResult = await _authAccess.AddToRoleAsync(user, "TimerUser");
if (!roleResult.Succeeded)
{
return(GetErrorResult(roleResult));
}
var info = new ExternalLoginInfo()
{
Email = model.Email,
DefaultUserName = user.UserName,
Login = new UserLoginInfo(model.Provider, verifiedAccessToken.user_id)
};
var loginResult = await _authAccess.AddLoginAsync(user.Id, info.Login);
if (!loginResult.Succeeded)
{
return(GetErrorResult(loginResult));
}
var signResult = await SignInManager.ExternalSignInAsync(info, false);
if (signResult != SignInStatus.Success)
{
return(BadRequest("Sign in failed"));
}
result.Result = true;
return(Ok(result));
}
public async Task <TokenAuthorizeModel> RegisterExternalAsync(MyUserManager userManager, RegisterExternalViewModel viewModel)
{
var identity = viewModel.ToEntity();
var authenticationType = Enum.Parse <ExternalAuthenticationType>(viewModel.Provider, true);
_externalAuthenticationFactory.Create(authenticationType).GetUserDetails(identity, viewModel.ProviderIdToken);
identity.UserName = identity.Email;
//If user exist in the system
var user = await userManager.FindByNameAsync(identity.UserName);
if (user != null)
{
return(await user.AuthorizeAsync(userManager, _extensionSettings.appSettings));
}
//if user is not exist in the system
IdentityResult result = await userManager.CreateAsync(identity);
if (result.Succeeded)
{
await updateOtherInfoForIdentity(userManager, identity);
return(await identity.AuthorizeAsync(userManager, _extensionSettings.appSettings));
}
throw new FoodCourtException(ErrorMessage.USER_CREATE_FAIL);
}
