// Getting BlindtestClass Object from MainPage, then loading list of users
protected override void OnNavigatedTo(NavigationEventArgs e)
{
// If a parameter is given, and if it's a BlindtestClass element
if (e.Parameter is BlindtestClass)
{
// Get main element
var bt = e.Parameter;
blindtest = (BlindtestClass)bt;
// Filling listView with users according to dataTemplate
ObservableCollection <BTUser> listItems = new ObservableCollection <BTUser>();
foreach (BTUser user in blindtest.getAllUsers())
{
listItems.Add(user);
}
users_listView.ItemsSource = listItems;
selected_user = blindtest.getSelectedUser();
if (!selected_user.Equals(default(BTUser)))
{
// Check if user still exist
if (blindtest.checkIfUserExist(selected_user) == true)
{
userInformation_label.Text = "User information - Selected User : " + selected_user.nickname;
BitmapImage bmpImg = new BitmapImage();
bmpImg.UriSource = new Uri(selected_user.profile_picture);
profilePicture_Image.Source = bmpImg;
users_listView.SelectedIndex = blindtest.getSelectedUserIndex();
}
}
}
}
public async Task RemoveUserFromProjectAsync(string userId, int projectId)
{
try
{
if (await IsUserOnProjectAsync(userId, projectId))
{
BTUser user = await _userManager.FindByIdAsync(userId);
Project project = await _context.Projects.FindAsync(projectId);
try
{
project.Members.Remove(user);
await _context.SaveChangesAsync();
}
catch (Exception)
{
throw;
}
}
}
catch (Exception ex)
{
Debug.WriteLine($"*** Error *** - Error Removing user from project --> { ex.Message }");
}
}
// Edit user Page
private void EditUser_button_Click(object sender, Windows.UI.Xaml.RoutedEventArgs e)
{
// Disabling UI elements
editUser_button.IsEnabled = false;
back_button.IsEnabled = false;
newUser_textBox.IsEnabled = false;
newPP_textBox.IsEnabled = false;
passwordBox.IsEnabled = false;
editUser_button.Content = "Editing user...";
// Checking if some info is missing
if (newUser_textBox.Text == "" || newPP_textBox.Text == "" || passwordBox.Password == "")
{
editUser_button.Content = "You must give every info!";
}
else
{
// Edit user with that dedicated method, then reloading ui elements
switch (blindtest.editUser(blindtest.getSelectedUserIndex(), newUser_textBox.Text, newPP_textBox.Text, passwordBox.Password))
{
case 0:
editUser_button.Content = "User edited successfully!";
selected_user = blindtest.getUserByUserID(selected_user.user_id);
blindtest.setSelectedUser(selected_user, blindtest.getSelectedUserIndex());
username_label.Text = selected_user.nickname;
BitmapImage bmpImg = new BitmapImage();
bmpImg.UriSource = new Uri(selected_user.profile_picture);
profilePicture_Image.Source = bmpImg;
profilePicture_textBox.Text = selected_user.profile_picture;
break;
case 1:
editUser_button.Content = "You must give every info!";
break;
case 2:
editUser_button.Content = "Invalid PP URL!";
break;
case 3:
editUser_button.Content = "Invalid password!";
break;
case 42:
editUser_button.Content = blindtest.getError();
break;
}
}
// Reenabling UI elements
editUser_button.IsEnabled = true;
back_button.IsEnabled = true;
newUser_textBox.IsEnabled = true;
newPP_textBox.IsEnabled = true;
passwordBox.IsEnabled = true;
}
public async Task <IEnumerable <Notification> > GetUnreadNotificationsAsync(ClaimsPrincipal currentUser)
{
BTUser user = await _userManager.GetUserAsync(currentUser);
var userNotifications = _context.Notifications.Where(n => n.RecipientId == user.Id).Include(n => n.Sender);
var unreadNotifications = await userNotifications.Where(n => !n.Viewed).ToListAsync();
//var undreadNotifications = _context.Notifications.Where(n => n.RecipientId == user.Id && !n.Viewed).ToList();
return(unreadNotifications);
}
// Getting BlindtestClass Object from MainPage, then loading list of users
protected override void OnNavigatedTo(NavigationEventArgs e)
{
// If a parameter is given, and if it's a BlindtestClass element
if (e.Parameter is BlindtestClass)
{
// Get main element
var bt = e.Parameter;
blindtest = (BlindtestClass)bt;
// Getting user and game information
connected_user = blindtest.getConnectedUser();
selected_game = blindtest.getSelectedGame();
// loading game info in UI, and filling listView with tracks according to datatemplate
gameInformation_label.Text = "List of tracks - " + selected_game.game_title;
ObservableCollection <DeezerTrack> listItems = new ObservableCollection <DeezerTrack>();
foreach (DeezerTrack track in selected_game.tracklist)
{
listItems.Add(track);
}
tracklist_listView.ItemsSource = listItems;
// Loading scoreboard for this game
foreach (BTGameHistory history in selected_game.scores.history)
{
BTScoreboard score = new BTScoreboard();
score.username = "******";
score.profile_picture = "ms-appx:///Assets/Users/unselected-user.png";
foreach (BTUser user in blindtest.getAllUsers())
{
if (user.user_id == history.user_id)
{
score.username = user.nickname;
score.profile_picture = user.profile_picture;
}
}
score.date = history.date;
score.score = history.score.ToString();
scoreboard.Add(score);
}
// Filling scoreboard listView with scores loaded before according to dataTemplate
ObservableCollection <BTScoreboard> listItems2 = new ObservableCollection <BTScoreboard>();
foreach (BTScoreboard score in scoreboard)
{
listItems2.Add(score);
}
scoreboard_listView.ItemsSource = listItems2;
}
}
private async Task LoadAsync(BTUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
private async Task LoadAsync(BTUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
Username = userName;
Input = new InputModel
{
PhoneNumber = phoneNumber
};
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new BTUser {
UserName = Input.Email, Email = Input.Email, FirstName = Input.FirstName, LastName = Input.LastName, CompanyId = Input.CompanyId
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
ViewData["CompanyId"] = new SelectList(_context.Companies, "Id", "Name");
ReturnUrl = returnUrl;
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task <ICollection <Project> > ListUserProjects(string userId)
{
// Build an intermediate table and store it as user
// Get the users table from the database
BTUser user = await _context.Users
// Include the rows of the ProjectUsers table
.Include(p => p.ProjectUsers)
// Also include the project objects
.ThenInclude(p => p.Project)
// And get the first row where the identity user id matches the given userId
.FirstOrDefaultAsync(u => u.Id == userId); // Ends query
List <Project> projects = user.ProjectUsers
.Select(p => p.Project)
.ToList();
return(projects);
}
private async Task LoadSharedKeyAndQrCodeUriAsync(BTUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
public async Task <IActionResult> SetRoles(ManageUserRolesViewModel item, string name)
{
BTUser user = _context.Users.Find(item.UserId);
IEnumerable <string> roles = await _BTRoles.ListUserRoles(user);
await _userManager.RemoveFromRolesAsync(user, roles);
string userRole = name;
if (Enum.TryParse(userRole, out Roles roleValue))
{
await _BTRoles.AddUserToRole(user, userRole);
return(RedirectToAction("SetRoles"));
}
return(RedirectToAction("SetRoles"));
}
// Getting BlindtestClass Object from MainPage, then loading list of users
protected override void OnNavigatedTo(NavigationEventArgs e)
{
// If a parameter is given, and if it's a BlindtestClass element
if (e.Parameter is BlindtestClass)
{
// Get main element
var bt = e.Parameter;
blindtest = (BlindtestClass)bt;
// Get that selected user
selected_user = blindtest.getSelectedUser();
// Show user's info on page
username_label.Text = selected_user.nickname;
BitmapImage bmpImg = new BitmapImage();
bmpImg.UriSource = new Uri(selected_user.profile_picture);
user_Image.Source = bmpImg;
}
}
// When an item is selected in listView, display info in UI
private void Users_listView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (users_listView.SelectedIndex != -1)
{
selected_user = (BTUser)users_listView.SelectedItem;
userInformation_label.Text = "User information - Selected User : "******"ms-appx:///Assets/Users/unselected-user.png");
profilePicture_Image.Source = bmpImg;
}
}
public async Task <IActionResult> ManageRoles(List <string> userIds, string roleName)
{
foreach (var userId in userIds)
{
BTUser user = await _context.Users.FindAsync(userId);
if (!await _roleService.IsUserInRoleAsync(user, roleName))
{
var userRoles = await _roleService.ListUserRolesAsync(user);
foreach (var role in userRoles)
{
await _roleService.RemoveUserFromRoleAsync(user, role);
}
await _roleService.AddUserToRoleAsync(user, roleName);
}
}
return(View());
}
// Getting BlindtestClass Object from MainPage, then loading list of users
protected override void OnNavigatedTo(NavigationEventArgs e)
{
// If a parameter is given, and if it's a BlindtestClass element
if (e.Parameter is BlindtestClass)
{
// Get main element
var bt = e.Parameter;
blindtest = (BlindtestClass)bt;
// Get connected user information
connected_user = blindtest.getConnectedUser();
connected_user_index = blindtest.getConnectedUserIndex();
// Loading each playlist created by connected user
foreach (BTPlaylist playlist in blindtest.getAllPlaylists(connected_user.user_id))
{
basePlaylist_comboBox.Items.Add(playlist.name + " - N° of tracks: " + playlist.tracklist.Count.ToString() + " tracks");
}
}
}
public async Task <IActionResult> ManageUserRoles(ManageUserRolesViewModel btuser)
{
BTUser user = await _context.Users.FindAsync(btuser.User.Id);
IEnumerable <string> roles = await _rolesService.ListUserRoles(user);
await _userManager.RemoveFromRolesAsync(user, roles);
var userRoles = btuser.SelectedRole;
foreach (var role in userRoles)
{
if (Enum.TryParse(userRoles, out Roles roleValue))
{
await _rolesService.AddUserToRole(user, userRoles);
//return RedirectToAction("ManageUserRoles");
}
}
return(RedirectToAction("ManageUserRoles"));
}
public async Task <IActionResult> Register(RegisterViewModel vm)
{
if (ModelState.IsValid)
{
// Create a new user object with data from the View Model
BTUser user = new BTUser
{
UserName = vm.Email,
Email = vm.Email
};
// Create a new user using the user manager service
IdentityResult result = await userMgr.CreateAsync(user, vm.Password);
// On a succesful registration add the user to the default user role and then log the user in
if (result.Succeeded)
{
user = await userMgr.FindByNameAsync(user.UserName);
BTRole role = await roleMgr.FindByNameAsync("User");
await userMgr.AddToRoleAsync(user, role.Name);
await signInMgr.SignInAsync(user, isPersistent : false);
return(RedirectToAction("index", "home"));
}
// On an unsuccesful registration add errors to ModelState for display in validation error summary on the view
foreach (IdentityError error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View(vm));
}
public async Task AddUserToProjectAsync(string userId, int projectId)
{
//Needs to check for Project Manager - only one allowed
try
{
if (!await IsUserOnProjectAsync(userId, projectId))
{
BTUser user = await _userManager.FindByIdAsync(userId);
if (await _roleService.IsUserInRoleAsync(user, Roles.ProjectManager.ToString()))
{
var oldManager = await ProjectManagerOnProjectAsync(projectId);
if (oldManager != null)
{
await RemoveUserFromProjectAsync(oldManager.Id, projectId);
}
}
Project project = await _context.Projects.FindAsync(projectId);
try
{
project.Members.Add(user);
await _context.SaveChangesAsync();
}
catch (Exception)
{
throw;
}
}
}
catch (Exception ex)
{
Debug.WriteLine($"*** Error *** - Error Adding user to project --> { ex.Message }");
}
}
public async Task <string> InviteWizardAsync(InviteViewModel inviteViewModel)
{
var companyId = await CreateCompanyAsync(inviteViewModel.CompanyName, inviteViewModel.CompanyDescription);
var user = new BTUser
{
Email = inviteViewModel.Email,
UserName = inviteViewModel.Email,
FirstName = inviteViewModel.FirstName,
LastName = inviteViewModel.LastName,
EmailConfirmed = true,
CompanyId = companyId
};
await _userManager.CreateAsync(user, "Abc&123!");
await _roleService.AddUserToRoleAsync(user, Roles.Admin.ToString());
var projectId = await CreateProjectAsync(inviteViewModel.ProjectName, inviteViewModel.ProjectDescription, companyId);
await _projectService.AddUserToProjectAsync(user.Id, projectId);
return(user.Id);
}
// When a scoreboard entry is selected
private void Scoreboard_listView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
nbr_time_played = 0;
// if it's a correct entry
if (scoreboard_listView.SelectedIndex != -1)
{
// Loading every information in UI
username_label.Text = scoreboard[scoreboard_listView.SelectedIndex].username;
date_label.Text = scoreboard[scoreboard_listView.SelectedIndex].date;
score_label.Text = scoreboard[scoreboard_listView.SelectedIndex].score + " points";
foreach (BTGameHistory history in selected_game.scores.history)
{
if (history.user_id == scoreboard[scoreboard_listView.SelectedIndex].user_id)
{
nbr_time_played++;
}
}
nbrTimePlayed_label.Text = nbr_time_played.ToString() + " times";
int games_created = 0, games_played = 0;
BTUser user = blindtest.getUserByUserID(scoreboard[scoreboard_listView.SelectedIndex].user_id);
foreach (BTGame game in blindtest.getAllGames())
{
if (game.user_id == user.user_id)
{
games_created++;
}
foreach (BTGameHistory history in game.scores.history)
{
if (history.user_id == user.user_id)
{
games_played++;
}
}
}
if (games_played > 1)
{
nbrGamesPlayed_label.Text = games_played.ToString() + " games";
}
else
{
nbrGamesPlayed_label.Text = games_played.ToString() + " game";
}
if (games_created > 1)
{
nbrGamesCreated_label.Text = games_created.ToString() + " games";
}
else
{
nbrGamesCreated_label.Text = games_created.ToString() + " game";
}
//selectedUser_score_label.Text = scoreboard[scoreboard_listView.SelectedIndex].score + " points";
BitmapImage bmpImg = new BitmapImage();
bmpImg.UriSource = new Uri(scoreboard[scoreboard_listView.SelectedIndex].profile_picture);
ppUser_Image.Source = bmpImg;
}
}
private static async Task SeedDefaultUsersAsync(UserManager <BTUser> userManager, IImageService imageService)
{
#region Seed Admin
var defaultAdmin = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Charlie",
LastName = "Tincher",
FileName = "defaultavatar.jpg",
FileData = await imageService.AssignAvatarAsync("defaultavatar.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultAdmin.Email);
if (user == null)
{
await userManager.CreateAsync(defaultAdmin, "Charlie@123");
await userManager.AddToRoleAsync(defaultAdmin, Roles.Admin.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Admin User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
#endregion
#region Seed Project Manager
var defaultProjectManager = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "DustinPM",
LastName = "Kensrue",
FileName = "defaultavatar.jpg",
FileData = await imageService.AssignAvatarAsync("defaultavatar.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultProjectManager.Email);
if (user == null)
{
await userManager.CreateAsync(defaultProjectManager, "Kensrue@123");
await userManager.AddToRoleAsync(defaultProjectManager, Roles.ProjectManager.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Project Manager User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
defaultProjectManager = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "JakePM",
LastName = "Smith",
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultProjectManager.Email);
if (user == null)
{
await userManager.CreateAsync(defaultProjectManager, "Jake@123");
await userManager.AddToRoleAsync(defaultProjectManager, Roles.ProjectManager.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Project Manager User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
#endregion
#region Seed Developer
var defaultDeveloper = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "BobbyDev",
LastName = "Long",
FileName = "defaultavatar.jpg",
FileData = await imageService.AssignAvatarAsync("defaultavatar.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultDeveloper.Email);
if (user == null)
{
await userManager.CreateAsync(defaultDeveloper, "Bobby@123");
await userManager.AddToRoleAsync(defaultDeveloper, Roles.Developer.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Developer User.");
Debug.WriteLine(ex.Message);
Debug.WriteLine("*******************************");
}
#endregion
#region Seed Submitter
var defaultSubmitter = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Chris",
LastName = "Cornell",
FileName = "defaultavatar.jpg",
FileData = await imageService.AssignAvatarAsync("defaultavatar.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultSubmitter.Email);
if (user == null)
{
await userManager.CreateAsync(defaultSubmitter, "Chris@123");
await userManager.AddToRoleAsync(defaultSubmitter, Roles.Submitter.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Submitter User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
#endregion
#region Seed New User
var defaultNewUser = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "James",
LastName = "Taylor",
FileName = "defaultavatar.jpg",
FileData = await imageService.AssignAvatarAsync("defaultavatar.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultNewUser.Email);
if (user == null)
{
await userManager.CreateAsync(defaultNewUser, "James@123");
await userManager.AddToRoleAsync(defaultNewUser, Roles.NewUser.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default New User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
#endregion
//Start demo user seeds
//Each user occupies a "main" role and this new demo version of the role
//We will target this Demo role in order to demo this project without giving the abilty to this demo users to access the database
//Below is the password for all of the demo users
string demoPassword = "******";
//Anthony Stark
#region Demo Seed Admin
defaultAdmin = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Anthony",
LastName = "Stark",
FileName = "stark.jpg",
FileData = await imageService.AssignAvatarAsync("stark.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultAdmin.Email);
if (user == null)
{
await userManager.CreateAsync(defaultAdmin, demoPassword);
await userManager.AddToRoleAsync(defaultAdmin, Roles.Admin.ToString());
await userManager.AddToRoleAsync(defaultAdmin, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Admin User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
#endregion
//Harley Keener
#region Demo Seed Project Manager
defaultProjectManager = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Harley",
LastName = "Keener",
FileName = "harley-keener.jpg",
FileData = await imageService.AssignAvatarAsync("harley-keener.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultProjectManager.Email);
if (user == null)
{
await userManager.CreateAsync(defaultProjectManager, demoPassword);
await userManager.AddToRoleAsync(defaultProjectManager, Roles.ProjectManager.ToString());
await userManager.AddToRoleAsync(defaultProjectManager, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Project Manager User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
//defaultProjectManager = new BTUser
//{
// UserName = "******",
// Email = "*****@*****.**",
// FirstName = "JakeDemo",
// LastName = "Smith",
// EmailConfirmed = true
//};
//try
//{
// var user = await userManager.FindByEmailAsync(defaultProjectManager.Email);
// if (user == null)
// {
// await userManager.CreateAsync(defaultProjectManager, demoPassword);
// await userManager.AddToRoleAsync(defaultProjectManager, Roles.ProjectManager.ToString());
// await userManager.AddToRoleAsync(defaultProjectManager, Roles.Demo.ToString());
// }
//}
//catch (Exception ex)
//{
// Debug.WriteLine("************ ERROR ************");
// Debug.WriteLine("Error Seeding Default Project Manager User.");
// Debug.WriteLine("ex.Message");
// Debug.WriteLine("*******************************");
//}
#endregion
//Carol Danvers
#region Demo Seed Developer
defaultDeveloper = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Carol",
LastName = "Danvers",
FileName = "carol.png",
FileData = await imageService.AssignAvatarAsync("carol.png"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultDeveloper.Email);
if (user == null)
{
await userManager.CreateAsync(defaultDeveloper, demoPassword);
await userManager.AddToRoleAsync(defaultDeveloper, Roles.Developer.ToString());
await userManager.AddToRoleAsync(defaultDeveloper, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Developer User.");
Debug.WriteLine(ex.Message);
Debug.WriteLine("*******************************");
}
#endregion
//Clint Barton
#region Demo Seed Submitter
defaultSubmitter = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "Clint",
LastName = "Barton",
FileName = "clint.jpg",
FileData = await imageService.AssignAvatarAsync("clint.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultSubmitter.Email);
if (user == null)
{
await userManager.CreateAsync(defaultSubmitter, demoPassword);
await userManager.AddToRoleAsync(defaultSubmitter, Roles.Submitter.ToString());
await userManager.AddToRoleAsync(defaultSubmitter, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default Submitter User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
#endregion
//James Gunn
#region Demo Seed New User
defaultNewUser = new BTUser
{
UserName = "******",
Email = "*****@*****.**",
FirstName = "James",
LastName = "Gunn",
FileName = "james.jpg",
FileData = await imageService.AssignAvatarAsync("james.jpg"),
EmailConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultNewUser.Email);
if (user == null)
{
await userManager.CreateAsync(defaultNewUser, demoPassword);
await userManager.AddToRoleAsync(defaultNewUser, Roles.NewUser.ToString());
await userManager.AddToRoleAsync(defaultNewUser, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("************ ERROR ************");
Debug.WriteLine("Error Seeding Default New User.");
Debug.WriteLine("ex.Message");
Debug.WriteLine("*******************************");
}
#endregion
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
var user = new BTUser {
UserName = Input.Email, Email = Input.Email
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
_logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("./RegisterConfirmation", new { Email = Input.Email }));
}
await _signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
ProviderDisplayName = info.ProviderDisplayName;
ReturnUrl = returnUrl;
return(Page());
}
// Getting BlindtestClass Object from MainPage, then loading list of users
protected override void OnNavigatedTo(NavigationEventArgs e)
{
// If a parameter is given, and if it's a BlindtestClass element
if (e.Parameter is BlindtestClass)
{
// Get main element
var bt = e.Parameter;
blindtest = (BlindtestClass)bt;
// Loading UI elements and filling scoreboard listView
connected_user = blindtest.getConnectedUser();
selected_game = blindtest.getSelectedGame();
correctAnswers_label.Text = "Correct Answers - " + selected_game.game_title;
gameStatus_label.Text = "Game in progress...";
foreach (BTGameHistory history in selected_game.scores.history)
{
BTScoreboard score = new BTScoreboard();
score.username = "******";
score.profile_picture = "ms-appx:///Assets/Users/unselected-user.png";
foreach (BTUser user in blindtest.getAllUsers())
{
if (user.user_id == history.user_id)
{
score.username = user.nickname;
score.profile_picture = user.profile_picture;
}
}
score.date = history.date;
score.score = history.score.ToString();
scoreboard.Add(score);
}
ObservableCollection <BTScoreboard> listItems2 = new ObservableCollection <BTScoreboard>();
foreach (BTScoreboard score in scoreboard)
{
listItems2.Add(score);
}
scoreboard_listView.ItemsSource = listItems2;
// Launching the game
is_album_correct = false;
is_artist_correct = false;
is_duration_correct = false;
is_title_correct = false;
score = 0;
// Loading tracklist
foreach (DeezerTrack track in selected_game.tracklist)
{
tracklist_src.Add(track);
}
nbr_track = tracklist_src.Count;
total_tracks = tracklist_src.Count;
current_track_int = 1;
songStatus_label.Text = "Track " + current_track_int.ToString() + " of " + total_tracks.ToString();
Random random = new Random();
int random_int = random.Next(0, nbr_track - 1);
current_track = tracklist_src[random_int];
tracklist_src.Remove(current_track);
gameStatus_label.Text = "Game in progress... - score : " + score.ToString() + " points";
blindtest.readPreview(current_track);
total_correct_answer = 0;
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new BTUser
{
FirstName = Input.FirstName,
LastName = Input.LastName,
UserName = Input.Email,
Email = Input.Email,
FileName = "defaultavatar.jpg",
FileData = await _imageService.AssignAvatarAsync("defaultavatar.jpg")
};
if (Input.FormFile != null)
{
user.FileName = Input.FormFile.FileName;
user.FileData = _imageService.ConvertFileToByteArray(Input.FormFile);
}
;
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
await _userManager.AddToRoleAsync(user, Roles.NewUser.ToString());
var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = user.Id, code = code, returnUrl = returnUrl },
protocol: Request.Scheme);
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
TempData["ConfirmEmail"] = "Please verify your email";
return(RedirectToPage("/Account/Login", new { area = "Identity" }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
// Seed Users
public static async Task SeedDefaultUsersAsync(UserManager <BTUser> userManager)
{
#region AdminUser
//Create our userObject
var defaultAdmin = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Admin",
LastName = "Istrator",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(defaultAdmin.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(defaultAdmin, "Abc123!@#");
await userManager.AddToRoleAsync(defaultAdmin, Roles.Admin.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default Admin User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region ProjectManagerUser
//Create our userObject
var projectManager = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Project",
LastName = "Manager",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(projectManager.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(projectManager, "Abc123!@#");
await userManager.AddToRoleAsync(projectManager, Roles.ProjectManager.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default PM User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region DeveloperUser
//Create our userObject
var developer = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Dev",
LastName = "Eloper",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(developer.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(developer, "Abc123!@#");
await userManager.AddToRoleAsync(developer, Roles.Developer.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default Dev User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region Submitter
//Create our userObject
var submitter = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Sub",
LastName = "Human",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(submitter.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(submitter, "Abc123!@#");
await userManager.AddToRoleAsync(submitter, Roles.Submitter.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default Submitter User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region NewUser
//Create our userObject
var newUser = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Noob",
LastName = "User",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(newUser.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(newUser, "Abc123!@#");
await userManager.AddToRoleAsync(newUser, Roles.NewUser.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default NewUser User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region Demo AdminUser
//Create our userObject
var demoAdmin = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Demo",
LastName = "Admin",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(demoAdmin.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(demoAdmin, "Abc123!@#");
await userManager.AddToRoleAsync(demoAdmin, Roles.Admin.ToString());
await userManager.AddToRoleAsync(demoAdmin, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default Admin User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region DemoProjectManagerUser
//Create our userObject
var demoPm = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Demo",
LastName = "PM",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(demoPm.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(demoPm, "Abc123!@#");
await userManager.AddToRoleAsync(demoPm, Roles.ProjectManager.ToString());
await userManager.AddToRoleAsync(demoPm, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default PM User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region DemoDeveloperUser
//Create our userObject
var demoDeveloper = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Demo",
LastName = "Dev",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(demoDeveloper.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(demoDeveloper, "Abc123!@#");
await userManager.AddToRoleAsync(demoDeveloper, Roles.Developer.ToString());
await userManager.AddToRoleAsync(demoDeveloper, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default Dev User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region DemoSubmitter
//Create our userObject
var demoSubmitter = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Demo",
LastName = "Submitter",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(demoSubmitter.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(demoSubmitter, "Abc123!@#");
await userManager.AddToRoleAsync(demoSubmitter, Roles.Submitter.ToString());
await userManager.AddToRoleAsync(demoSubmitter, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default Submitter User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
#region DemoNewUser
//Create our userObject
var demoNewUser = new BTUser
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Demo",
LastName = "Noob",
EmailConfirmed = true,
PhoneNumberConfirmed = true
};
try
{
var user = await userManager.FindByEmailAsync(demoNewUser.Email);
if (user == null)
{
//userManager.CreateAsync(userObject, password)
await userManager.CreateAsync(demoNewUser, "Abc123!@#");
await userManager.AddToRoleAsync(demoNewUser, Roles.NewUser.ToString());
await userManager.AddToRoleAsync(demoNewUser, Roles.Demo.ToString());
}
}
catch (Exception ex)
{
Debug.WriteLine("********** ERROR *********");
Debug.WriteLine("Error Seeding Default NewUser User");
Debug.WriteLine(ex.Message);
Debug.WriteLine("***************************");
throw;
}
#endregion
}
public async Task <bool> RemoveUserFromRole(BTUser user, string roleName)
{
var result = await _userManager.RemoveFromRoleAsync(user, roleName);
return(result.Succeeded);
}
public async Task <IEnumerable <string> > ListUserRoles(BTUser user)
{
return(await _userManager.GetRolesAsync(user));
}
public async Task <bool> IsUserInRole(BTUser user, string roleName)
{
return(await _userManager.IsInRoleAsync(user, roleName));
}
public async Task <bool> AddUserToRole(BTUser user, string roleName)
{
var result = await _userManager.AddToRoleAsync(user, roleName);
return(result.Succeeded);
}
// Getting BlindtestClass Object from MainPage, then loading list of users
protected override void OnNavigatedTo(NavigationEventArgs e)
{
// If a parameter is given, and if it's a BlindtestClass element
if (e.Parameter is BlindtestClass)
{
// Get main element
var bt = e.Parameter;
blindtest = (BlindtestClass)bt;
// Loading information in UI elements
connected_user = blindtest.getConnectedUser();
ObservableCollection <BTGame> listItems = new ObservableCollection <BTGame>();
BitmapImage bmpImg = new BitmapImage();
bmpImg.UriSource = new Uri(connected_user.profile_picture);
userPP_Image.Source = bmpImg;
all_games = blindtest.getAllGames();
foreach (BTGame game in all_games)
{
listItems.Add(game);
}
games_listView.ItemsSource = listItems;
username_label.Text = connected_user.nickname;
int games_created = 0, games_played = 0, playlists_created = 0;
foreach (BTGame game in blindtest.getAllGames())
{
if (game.user_id == connected_user.user_id)
{
games_created++;
}
foreach (BTGameHistory history in game.scores.history)
{
if (history.user_id == connected_user.user_id)
{
games_played++;
}
}
}
if (games_played > 1)
{
nbrPlayedGames_label.Text = games_played.ToString() + " games";
}
else
{
nbrPlayedGames_label.Text = games_played.ToString() + " game";
}
if (games_created > 1)
{
nbrGames_label.Text = games_created.ToString() + " games";
}
else
{
nbrGames_label.Text = games_created.ToString() + " game";
}
playlists_created = blindtest.getAllPlaylists(connected_user.user_id).Count;
if (playlists_created > 1)
{
nbrPlaylists_label.Text = playlists_created.ToString() + " playlists";
}
else
{
nbrPlaylists_label.Text = playlists_created.ToString() + " playlist";
}
}
}
