/// <summary>
/// Initialize a new instance of MSToolKit.Core.Authentication.SignInManager
/// </summary>
/// <param name="userManager">
/// An instance for MSToolKit.Core.Authentication.Abstraction.IUserManager.
/// </param>
/// <param name="authenticationOptions">
/// MSToolKit.Core.Authentication.Options.AuthenticationOptions,
/// that configures the behavior of the current instance.
/// </param>
public SignInManager(
IUserManager <TUser> userManager,
Options.AuthenticationOptions authenticationOptions)
{
this.userManager = userManager;
this.signInOptions = authenticationOptions.SignIn;
}
public void SetSignInPolicy(SignInOptions opts)
{
lock (_lock)
{
PolicyOptions.SignIn = opts;
}
}
async void SignIn(SignInOptions options, bool byUser)
{
if (context.ChatClient.IsLoggedIn)
{
return;
}
busyIndicator.IsBusy = true;
Exception ex = null;
await Task.Run(() =>
{
clientAvailable.Wait();
SettingsProvider.Current.Load();
var loginHelper = new LoginHelper(context.PluginLoader.AuthenticationProvider, SettingsProvider.Current.Settings, context.ChatClient);
ExceptionMonster.EatTheException(() => loginHelper.Login(options), "logging in", out ex);
});
busyIndicator.IsBusy = false;
if (ex != null && byUser)
{
MessageBox.Show(ex.Message, Translation.Instance.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
OnSignIn(options);
}
private static async Task <int> OnSignIn(SignInOptions signInOptions)
{
try
{
var devAccount = await ToolAuthentication.SignInAsync((DevAccountSource)signInOptions.AccountSource, signInOptions.UserName);
Console.WriteLine($"Developer account {devAccount.Name} has successfully signed in.");
DisplayDevAccount(devAccount, "\t");
return(0);
}
catch (HttpRequestException ex)
{
Console.WriteLine("Error: signin failed");
if (ex.Message.Contains(Convert.ToString((int)HttpStatusCode.Unauthorized)))
{
Console.WriteLine("Unable to authorize this account with Xbox Live. Please check your account.");
}
else
{
Console.WriteLine(ex.Message);
}
return(-1);
}
}
private static async Task <int> Main(string[] args)
{
int exitCode = 0;
try
{
string invokedVerb = string.Empty;
SignInOptions signInOptions = null;
// Only assign the option and verb here, as the commandlineParser doesn't support async callback yet.
var result = Parser.Default.ParseArguments <SignInOptions, SignOutOptions, ShowOptions>(args)
.WithParsed <SignInOptions>(options =>
{
invokedVerb = "signin";
signInOptions = options;
})
.WithParsed <SignOutOptions>(options => exitCode = OnSignOut())
.WithParsed <ShowOptions>(options => exitCode = OnShow())
.WithNotParsed(err => exitCode = -1);
if (invokedVerb == "signin" && signInOptions != null)
{
exitCode = await OnSignIn(signInOptions);
}
}
catch (Exception ex)
{
Console.WriteLine("Error: unexpected error found.");
Console.WriteLine(ex.Message);
exitCode = -1;
}
return(exitCode);
}
public static LoginResponse Generate(SignInOptions signInOptions)
{
return(new LoginResponse
{
RequireConfirmedEmail = signInOptions.RequireConfirmedEmail,
RequireConfirmedPhoneNumber = signInOptions.RequireConfirmedPhoneNumber,
});
}
public IdentityOptions()
{
ClaimsIdentity = new ClaimsIdentityOptions();
User = new UserOptions();
Password = new PasswordOptions();
Lockout = new LockoutOptions();
SignIn = new SignInOptions();
}
public AuthenticationOptions(
UserOptions userOptions,
PasswordOptions passwordOptions,
SignInOptions signInOptions)
{
this.User = userOptions;
this.Password = passwordOptions;
this.SignIn = signInOptions;
}
private void SetSignInSharedPolicy(SignInPolicy policy, SignInOptions shared = null)
{
if (shared == null)
{
shared = _sharedPolicyAccessor.GetPolicy().SignIn;
}
shared.RequireConfirmedEmail = policy.RequireConfirmedEmail;
shared.RequireConfirmedPhoneNumber = policy.RequireConfirmedPhoneNumber;
_sharedPolicyAccessor.SetSignInPolicy(shared);
}
private void SignInControl_LoginInitiated(object sender, Squiggle.UI.Controls.LogInEventArgs e)
{
var signInOptions = new SignInOptions()
{
Username = e.Username,
Password = e.Password,
Domain = e.Domain,
DisplayName = e.DisplayName,
GroupName = e.GroupName
};
SignIn(signInOptions, true);
}
void OnSignIn(SignInOptions signInOptions)
{
CreateMonitor();
VisualStateManager.GoToState(chatControl, "OnlineState", true);
autoSignout.OnSignIn(signInOptions);
foreach (var window in chatWindows)
{
window.Enabled = true;
}
CheckForUpdates();
}
/// <summary>
/// Signs in using the specified <see cref="SignInOptions"/>.
/// </summary>
/// <param name="signInOptions">The <see cref="SignInOptions"/> to use.</param>
/// <remarks>This function will apply <see cref="Prompt.ForceLogin"/> because
/// the Microsoft Identity Platform currently does not support real
/// logout, so we have to force a login prompt.
/// </remarks>
public async Task SignIn(SignInOptions signInOptions)
{
await SignIn(c =>
{
var builder = c.AcquireTokenInteractive(
_currentScopes = signInOptions?.Scopes != null ?
_currentScopes.Union(signInOptions.Scopes) :
_currentScopes)
.WithPrompt(Prompt.ForceLogin);
#if MONOANDROID
builder = builder.WithParentActivityOrWindow(Xamarin.Essentials.Platform.CurrentActivity);
#endif
return(builder);
}).ConfigureAwait(false);
}
public void Login(SignInOptions signInOptions)
{
var credential = new NetworkCredential(signInOptions.Username, signInOptions.Password, signInOptions.Domain);
AuthenticationResult result = authenticationProvider.Authenticate(credential);
if (result.Status == AuthenticationStatus.Failure)
{
throw new AuthenticationException(result.Status, Translation.Instance.Authentication_Failed);
}
if (result.Status == AuthenticationStatus.ServiceUnavailable)
{
throw new AuthenticationException(result.Status, Translation.Instance.Authentication_ServiceUnavailable);
}
var optionsFactory = new LoginOptionsFactory(settings, result.UserDetails, signInOptions);
LoginOptions clientOptions = optionsFactory.CreateInstance();
client.Login(clientOptions);
}
private async void Window_Loaded(object sender, RoutedEventArgs e)
{
if (App.RunInBackground)
{
this.Hide();
}
chatWindows = new ChatWindowCollection();
var settingsProvider = SettingsProvider.Current;
SquiggleSettings settings = settingsProvider.Settings;
settings.ContactSettings.ContactGroups.FlushItems();
settingsProvider.Save();
HistoryManager history = new HistoryManagerFactory().CreateInstance();
context = new SquiggleContextFactory(new PluginLoaderFactory(),
history,
this,
settings.ConnectionSettings.ClientID).CreateInstance();
context.PluginLoader.LoadAll(context);
SetupControls();
TrayPopup.Instance.Enabled = SettingsProvider.Current.Settings.GeneralSettings.ShowPopups;
AudioAlert.Instance.Enabled = SettingsProvider.Current.Settings.GeneralSettings.AudioAlerts;
chatControl.SignIn.LoadSettings(settings);
var client = context.ChatClient;
client.EnableLogging = settings.GeneralSettings.EnableStatusLogging;
client.ChatStarted += client_ChatStarted;
client.BuddyUpdated += client_BuddyUpdated;
client.BuddyOnline += client_BuddyOnline;
client.BuddyOffline += client_BuddyOffline;
clientViewModel = new ClientViewModel(client);
clientViewModel.CancelUpdateCommand = new RelayCommand <object>(CancelUpdateCommand_Execute);
DataContext = chatControl.ChatContext = clientViewModel;
autoSignout = new NetworkSignout(this.Dispatcher, options => SignIn(options, byUser: false), () => SignOut(byUser: false));
var singleSignOn = chatControl.SignIn.lblSingleSignOn.Visibility == Visibility.Visible;
if (singleSignOn || (settings.PersonalSettings.RememberMe && settings.PersonalSettings.AutoSignMeIn))
{
var signInOptions = new SignInOptions()
{
Username = settings.PersonalSettings.Username,
Password = settings.PersonalSettings.Password,
Domain = settings.PersonalSettings.Domain
};
await Task.Delay(5.Seconds());
SignIn(signInOptions, false);
}
else if (settings.PersonalSettings.RememberMe)
{
chatControl.SignIn.RememberMe = true;
}
}
public LoginOptionsFactory(SquiggleSettings settings, UserDetails userInfo, SignInOptions signInOptions)
{
this.settings = settings;
this.userInfo = userInfo;
this.signInOptions = signInOptions;
}
public void SignIn(SignInOptions options)
{
SignIn(options, true);
}
private static void SetSignInOptions(SignInOptions identityOptionsSignIn, SiteSettings siteSettings)
{
identityOptionsSignIn.RequireConfirmedEmail = siteSettings.RequireConfirmedEmail;
identityOptionsSignIn.RequireConfirmedPhoneNumber = siteSettings.RequireConfirmedPhoneNumber;
}
private static void setSignInOptions(SignInOptions identityOptionsSignIn, BehlogSetting setting)
{
identityOptionsSignIn.RequireConfirmedEmail = setting.EnableEmailConfirmation;
}
public void OnSignIn(SignInOptions signInOptions)
{
this.signInOptions = signInOptions;
loggedIn = true;
}
private static void setSignInOptions(SignInOptions identityOptionsSignIn, SiteSettings siteSettings)
{
identityOptionsSignIn.RequireConfirmedEmail = siteSettings.EnableEmailConfirmation;
}
public static IServiceCollection AddCustomIdentity(
this IServiceCollection services,
PasswordOptions passwordPolicies,
LockoutPolicies lockoutPolicies,
SignInOptions signinPolicies)
{
services
.AddIdentity <AppUser, AppRole>()
.AddDefaultTokenProviders();
services.Configure <IdentityOptions>(opts =>
{
// Password settings.
PasswordOptions passwordOpts = opts.Password;
passwordOpts.RequireDigit = passwordPolicies.RequireDigit;
passwordOpts.RequiredLength = passwordPolicies.RequiredLength;
passwordOpts.RequiredUniqueChars = passwordPolicies.RequiredUniqueChars;
passwordOpts.RequireNonAlphanumeric = passwordPolicies.RequireNonAlphanumeric;
passwordOpts.RequireLowercase = passwordPolicies.RequireLowercase;
passwordOpts.RequireUppercase = passwordPolicies.RequireUppercase;
// Lockout settings.
LockoutOptions lockoutOpts = opts.Lockout;
lockoutOpts.AllowedForNewUsers = lockoutPolicies.AllowedForNewUsers;
lockoutOpts.MaxFailedAccessAttempts = lockoutPolicies.MaxFailedAccessAttempts;
lockoutOpts.DefaultLockoutTimeSpan = TimeSpan.FromMinutes(lockoutPolicies.DefaultLockoutInMinutes);
// User settings.
//options.User.AllowedUserNameCharacters = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-._@";
opts.User.RequireUniqueEmail = true;
// SignIn settings.
SignInOptions signinOpts = opts.SignIn;
signinOpts.RequireConfirmedEmail = signinPolicies.RequireConfirmedEmail;
signinOpts.RequireConfirmedPhoneNumber = signinPolicies.RequireConfirmedPhoneNumber;
});
//services.ConfigureApplicationCookie(options =>
//{
// // Cookie settings.
// // options.LoginPath = string.Empty;
// // options.LogoutPath = string.Empty;
// // options.AccessDeniedPath = string.Empty;
// options.Events = new CookieAuthenticationEvents
// {
// OnRedirectToLogin = ctx =>
// {
// if (ctx.Request.Path.StartsWithSegments("/api") &&
// ctx.Response.StatusCode == (int)HttpStatusCode.OK)
// {
// ctx.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
// }
// else
// {
// ctx.Response.Redirect(ctx.RedirectUri);
// }
// return Task.CompletedTask;
// }
// };
//});
return(services);
}
