public async Task <ServiceResult> VerifyEmailAsync(VerifyEmail model)
{
ServiceResult result = new ServiceResult();
PassportUser user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.InvalidSignin),
Message = Errors.InvalidSignin
});
result.Code = 401;
return(result);
}
IdentityResult identityResult = await userManager.ConfirmEmailAsync(user, model.Token);
if (!identityResult.Succeeded)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.InvalidSignin),
Message = Errors.InvalidSignin
});
result.Code = 401;
}
return(result);
}
public async Task <ServiceResult> RegisterAsync(Register model)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
ServiceResult result = new ServiceResult();
if (!string.IsNullOrEmpty(model.ReturnUrl) && !await ValidateReturnUrlAsync(model.ReturnUrl))
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.InvalidReturnUrl),
Message = Errors.InvalidReturnUrl,
});
result.Code = 400;
return(result);
}
PassportUser existingUser = await userManager.FindByEmailAsync(model.Email);
if (existingUser != null)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.EmailAddressInUse),
Message = Errors.EmailAddressInUse
});
result.Code = 409;
return(result);
}
PassportUser user = new PassportUser(model.Email, model.Username);
IdentityResult identityResult = await userManager.CreateAsync(user, model.Password);
if (!identityResult.Succeeded)
{
foreach (IdentityError error in identityResult.Errors)
{
result.Errors.Add(new ServiceResult.Error
{
Key = error.Code,
Message = error.Description
});
result.Code = 400;
}
}
if (identityResult.Succeeded)
{
var client = clientFactory.GetProfileClient();
await client.CreateProfileAsync(new UserProfileCreate { Id = Guid.Parse(user.Id), Email = model.Email, DisplayName = user.UserName });
}
return(result);
}
public async Task <ServiceResult> ResetPasswordAsync(PasswordReset model)
{
ServiceResult result = new ServiceResult();
PassportUser user = await userManager.FindByIdAsync(model.UserId);
if (user == null)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.UserNotFound),
Message = Errors.UserNotFound
});
result.Code = 404;
return(result);
}
IdentityResult identityResult = await userManager.ResetPasswordAsync(user, model.Token, model.Password);
if (!identityResult.Succeeded)
{
foreach (IdentityError error in identityResult.Errors)
{
result.Errors.Add(new ServiceResult.Error
{
Key = error.Code,
Message = error.Description,
});
}
result.Code = 400;
}
return(result);
}
public async Task <string> GeneratePasswordResetTokenAsync(string email)
{
PassportUser user = await userManager.FindByEmailAsync(email);
if (user == null)
{
return(string.Empty);
}
return(await userManager.GeneratePasswordResetTokenAsync(user));
}
public static void Main()
{
WindowsUser wu = new WindowsUser();
wu.Username = "******";
Authentication.Logon(wu); //dynamic binding
PassportUser pu = new PassportUser();
pu.Email = "*****@*****.**";
Authentication.Logon(pu); //dynamic binding
}
public async Task <ServiceResult> SigninAsync(string email, string password, string returnUrl, bool rememberMe)
{
ServiceResult result = new ServiceResult();
if (!await ValidateReturnUrlAsync(returnUrl))
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.InvalidReturnUrl),
Message = Errors.InvalidReturnUrl
});
result.Code = 400;
return(result);
}
PassportUser user = await userManager.FindByEmailAsync(email);
if (user == null)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.InvalidSignin),
Message = Errors.InvalidSignin
});
result.Code = 401;
return(result);
}
SignInResult identityResult = await signInManager.PasswordSignInAsync(user, password, rememberMe, lockoutOnFailure : false);
if (!identityResult.Succeeded)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.InvalidSignin),
Message = Errors.InvalidSignin
});
result.Code = 401;
return(result);
}
await events.RaiseAsync(new UserLoginSuccessEvent(user.Email, user.Id, user.UserName));
return(result);
}
public async Task <ServiceResult> UpdateUserAccount(Guid userId, DTOs.UpdateAccount account)
{
ServiceResult result = new ServiceResult();
PassportUser user = await userManager.FindByIdAsync(userId.ToString());
if (user == null)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.UserNotFound),
Message = Errors.UserNotFound,
});
result.Code = 404;
return(result);
}
if (!user.Email.Equals(account.Email, StringComparison.InvariantCultureIgnoreCase))
{
user.EmailConfirmed = false;
}
user.Update(account.Email, account.UserName);
IdentityResult updateResult = await userManager.UpdateAsync(user);
if (!updateResult.Succeeded)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.UpdateFailed),
Message = Errors.UpdateFailed,
});
foreach (IdentityError error in updateResult.Errors)
{
result.Errors.Add(new ServiceResult.Error
{
Key = error.Code,
Message = error.Description,
});
}
result.Code = 400;
}
return(result);
}
public async Task <string> GenerateEmailVerificationTokenAsync(string emailAddress)
{
PassportUser user = await userManager.FindByEmailAsync(emailAddress);
return(await userManager.GenerateEmailConfirmationTokenAsync(user));
}
public async Task <ServiceResult> AddExternalLink(string userId, string scheme, ClaimsPrincipal externalPrincipal)
{
var result = new ServiceResult();
AuthenticationProperties signInProps = new AuthenticationProperties();
PassportUser user = await userManager.FindByIdAsync(userId);
if (user == null)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.UserNotFound),
Message = Errors.UserNotFound,
});
result.Code = 404;
return(result);
}
UserProfileCreateConnection dto = null;
switch (scheme)
{
case "battle.net":
dto = CreateBattlenetConnectionDto(userId, externalPrincipal);
break;
case "discord":
dto = CreateDiscordConnectionDto(userId, externalPrincipal);
break;
case "twitch":
dto = CreateTwitchConnectionDto(userId, externalPrincipal);
break;
}
if (dto == null)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.ExternalIdNotFound),
Message = Errors.ExternalIdNotFound,
});
result.Code = 400;
return(result);
}
try
{
var client = clientFactory.GetProfileConnectionClient();
await client.CreateConnectionAsync(dto);
}
catch (Exception)
{
result.Errors.Add(new ServiceResult.Error
{
Key = nameof(Errors.ExternalConnectionFailed),
Message = Errors.ExternalConnectionFailed,
});
result.Code = 500;
}
return(result);
}
