public async Task <IHttpActionResult> RegisterExternal(RegisterExternalBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
if (externalLogin == null)
{
return(InternalServerError());
}
IdentityAccount account = new IdentityAccount {
UserName = model.UserName
};
account.Logins.Add(new IdentityAccountLogin
{
LoginProvider = externalLogin.LoginProvider,
ProviderKey = externalLogin.ProviderKey
});
IdentityResult result = await _userManager.CreateAsync(account);
IHttpActionResult errorResult = GetErrorResult(result);
return(errorResult ?? Ok());
}
async public Task <IdentityAccount> Get(string id, string userName)
{
IdentityUser user = null;
if (string.IsNullOrWhiteSpace(id))
{
user = await UserManager.FindByIdAsync(id);
}
else if (string.IsNullOrWhiteSpace(userName))
{
user = await UserManager.FindByNameAsync(userName);
}
IdentityAccount result = null;
if (user != null)
{
result = new IdentityAccount(user.Id, user.UserName);
result.IsLocked = await UserManager.IsLockedOutAsync(user.Id);
result.HasPassword = await UserManager.HasPasswordAsync(user.Id);
}
return(result);
}
protected override void OnCreate(IdentityAccount entity)
{
// Validate
var duplicate = this.FirstOrDefaultActiveAsync(q => q.UserName == entity.UserName && q.ChurchId == entity.ChurchId);
if (duplicate != null)
{
throw new ArgumentException("Account already exist");
}
base.OnCreate(entity);
}
public async Task <UserInfoViewModel> GetUserInfo(string accountName)
{
IdentityAccount account = string.IsNullOrWhiteSpace(accountName) ?
await _userManager.FindByIdAsync(User.Identity.GetUserId()) :
await _userManager.FindByNameAsync(accountName);
UserInfoViewModel view = new UserInfoViewModel();
if (account != null)
{
view.UserId = account.Id;
view.UserName = account.UserName;
view.HasRegistered = account.Logins.Any();
view.LoginProvider = string.Join("|", account.Logins);
}
return(view);
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
IdentityAccount account = new IdentityAccount
{
UserName = model.UserName
};
IdentityResult result = await _userManager.CreateAsync(account, model.Password);
IHttpActionResult errorResult = GetErrorResult(result);
return(errorResult ?? Ok());
}
async public Task Delete(IdentityAccount account)
{
if (account == null)
{
throw new ArgumentNullException(nameof(account));
}
var user = new IdentityUser
{
UserName = account.UserName,
Email = account.UserName
};
IdentityResult result = await UserManager.DeleteAsync(user);
if (!result.Succeeded)
{
throw new IdentityException(result.Errors);
}
}
public int CreateUser(IdentityUser user)
{
using (var db = new LogistoDb())
{
var userId = Convert.ToInt32(db.InsertWithIdentity(user));
var userManager = new UserManager(new UserStore(new LogistoDb()), Startup.IdentityFactoryOptions, new EmailService());
var stamp = userManager.PasswordHasher;
// добавить аккаунт
var account = new IdentityAccount
{
CreatedDate = DateTime.Now,
IsApproved = true,
Password = stamp.HashPassword("123456789"), // default password
UserId = userId
};
db.InsertWithIdentity(account);
return(userId);
}
}
public async Task <ManageInfoViewModel> GetManageInfo(string returnUrl, bool generateState = false)
{
IdentityAccount account = await _userManager.FindByIdAsync(User.Identity.GetUserId());
if (account == null)
{
return(null);
}
var logins = account.Logins.Select(la => new UserLoginInfoViewModel
{
LoginProvider = la.LoginProvider,
ProviderKey = la.ProviderKey
});
return(new ManageInfoViewModel
{
LocalLoginProvider = LocalLoginProvider,
UserName = account.UserName,
Logins = logins,
ExternalLoginProviders = GetExternalLogins(returnUrl, generateState)
});
}
public override async Task GrantResourceOwnerCredentials(OAuthGrantResourceOwnerCredentialsContext context)
{
using (UserManager <IdentityAccount> userManager = _accountManagerFactory())
{
IdentityAccount user = await userManager.FindAsync(context.UserName, context.Password);
if (user == null)
{
context.SetError("invalid_grant", "The user name or password is incorrect.");
return;
}
ClaimsIdentity oAuthIdentity = await userManager.CreateIdentityAsync(user,
context.Options.AuthenticationType);
ClaimsIdentity cookiesIdentity = await userManager.CreateIdentityAsync(user,
CookieAuthenticationDefaults.AuthenticationType);
AuthenticationProperties properties = CreateProperties(user.UserName);
AuthenticationTicket ticket = new AuthenticationTicket(oAuthIdentity, properties);
context.Validated(ticket);
context.Request.Context.Authentication.SignIn(cookiesIdentity);
}
}
public async Task <IHttpActionResult> GetExternalLogin(string provider, string error = null)
{
if (error != null)
{
return(Redirect(Url.Content("~/") + "#error=" + Uri.EscapeDataString(error)));
}
if (!User.Identity.IsAuthenticated)
{
return(new ChallengeResult(provider, this));
}
ExternalLoginData externalLogin = ExternalLoginData.FromIdentity(User.Identity as ClaimsIdentity);
if (externalLogin == null || externalLogin.LoginProvider != provider)
{
Authentication.SignOut(CookieAuthenticationDefaults.AuthenticationType);
return(Redirect(Url.Content("~/")));
}
IdentityAccount account = await _userManager.FindAsync(new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey));
if (account == null)
{
IdentityResult result = null;
account = await _userManager.FindByNameAsync(externalLogin.UserName);
if (account == null)
{
account = new IdentityAccount {
UserName = externalLogin.UserName
};
result = await _userManager.CreateAsync(account);
if (!result.Succeeded)
{
return(InternalServerError());
}
}
UserLoginInfo login = new UserLoginInfo(externalLogin.LoginProvider, externalLogin.ProviderKey);
result = await _userManager.AddLoginAsync(account.Id, login);
if (!result.Succeeded)
{
return(InternalServerError());
}
}
Authentication.SignOut(DefaultAuthenticationTypes.ExternalCookie);
ClaimsIdentity oAuthIdentity = await _userManager.CreateIdentityAsync(account,
OAuthDefaults.AuthenticationType);
ClaimsIdentity cookieIdentity = await _userManager.CreateIdentityAsync(account,
CookieAuthenticationDefaults.AuthenticationType);
AuthenticationProperties properties = ApplicationOAuthProvider.CreateProperties(account.UserName);
Authentication.SignIn(properties, oAuthIdentity, cookieIdentity);
return(Ok());
}
public async Task SetSecurityStampAsync(IdentityAccount account, string stamp)
{
account.SecurityStamp = stamp;
await this.UpdateAsync(account);
}
public async Task SetPasswordHashAsync(IdentityAccount account, string passwordHash)
{
account.PasswordHash = passwordHash;
await this.UpdateAsync(account);
}
async public Task <Access> Register(Register request)
{
var rule = DescriptorManager.Validate(request);
rule.Check();
var found = await Manager.Get(null, request.Email);
if (found != null)
{
rule.Add("Email", "Email already taken");
}
rule.Check();
var settings = SettingService.Get();
var customerRoleId = settings?.CustomerRoleId;
if (customerRoleId == null)
{
throw new InvalidOperationException("Customer Role nor configured");
}
// Start a transaction
Context.Start();
string token = string.Empty;
IdentityAccount account = null;
try
{
token = await Manager.Register(request.Email, request.Password);
account = await Manager.Get(null, request.Email);
}
catch (IdentityException ex)
{
Context.Rollback();
string message = ex.TranslatedReason();
throw new RuleException(message);
}
var user = new User
{
Email = request.Email,
Name = request.FullName,
RoleId = customerRoleId,
IdentityId = account?.Id
};
// Adds the user
await UserService.Add(user);
// Commmit the transaction
Context.Commit();
var result = new Access
{
UserName = request.Email,
FullName = request.FullName,
Token = token
};
return(result);
}
