public async Task <bool> LikeUpload(string myId, int uploadId)
{
try
{
ToonUser user = await _context.Users.FirstOrDefaultAsync(u => u.Id == myId);
Upload upload = await _context.Upload.FirstOrDefaultAsync(u => u.Id == uploadId);
UserLike like = new UserLike()
{
ToonUser = user,
Upload = upload
};
if (user.Likes.Count(l => l.Id == uploadId) == 0)
{
upload.Likes.Add(like);
await _context.SaveChangesAsync();
return(true);
}
else
{
return(false);
}
}
catch (Exception ex)
{
Debug.WriteLine($"*** ERROR *** - Error liking media - {ex.Message}");
throw;
}
}
public async Task <bool> DoesUserAlreadyLike(string userId, int userLikeId)
{
ToonUser user = await _context.Users.FirstOrDefaultAsync(u => u.Id == userId);
UserLike like = user.Likes.FirstOrDefault(l => l.Id == userLikeId);
return(like != null);
}
public async Task <bool> IsUserFollowingMe(string myId, string toonUserId)
{
ToonUser toonUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == toonUserId);
bool result = toonUser.Following.Any(u => u.Id == myId);
return(result);
}
private async Task LoadAsync(ToonUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
Username = userName;
Input = new InputModel
{
PhoneNumber = phoneNumber
};
}
private async Task LoadAsync(ToonUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
public async Task <List <Upload> > GetNewestUpload(string artistId)
{
try
{
ToonUser artist = await _context.Users.FirstOrDefaultAsync(u => u.Id == artistId);
List <Upload> upload = artist.Uploads.OrderByDescending(u => u.Created).Take(1).ToList();
return(upload);
} catch (Exception ex)
{
Debug.WriteLine($"*** ERROR *** - Error getting most recent upload - {ex.Message}");
throw;
}
}
public async Task <List <Upload> > GetAllUploadsByArtist(string artistId)
{
try
{
ToonUser artist = await _context.Users.FirstOrDefaultAsync(u => u.Id == artistId);
var uploads = artist.Uploads?.ToList();
return(uploads);
}
catch (Exception ex)
{
Debug.WriteLine($"*** ERROR *** - Error getting uploads by artist - {ex.Message}");
throw;
}
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl ??= Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new ToonUser {
UserName = Input.Email, Email = Input.Email
};
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);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public async Task UnfollowUser(string myId, string toonUserId)
{
try
{
ToonUser user = await _context.Users.FirstOrDefaultAsync(u => u.Id == myId);
ToonUser toonUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == toonUserId);
user?.Following.Remove(toonUser);
toonUser?.Followers.Remove(user);
await _context.SaveChangesAsync();
}
catch (Exception)
{
throw;
}
}
private async Task LoadSharedKeyAndQrCodeUriAsync(ToonUser 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 UnLikeUpload(string myId, int uploadId)
{
try
{
ToonUser user = await _context.Users.FirstOrDefaultAsync(u => u.Id == myId);
Upload upload = await _context.Upload.FirstOrDefaultAsync(u => u.Id == uploadId);
UserLike like = upload.Likes.FirstOrDefault(l => l.ToonUser.Id == user.Id);
upload.Likes.Remove(like);
user.Likes.Remove(like);
await _context.SaveChangesAsync();
}
catch (Exception ex)
{
Debug.WriteLine($"*** ERROR *** - Error unliking media - {ex.Message}");
throw;
}
}
public async Task <bool> FollowUser(string myId, string toonUserId)
{
try
{
ToonUser user = await _context.Users.FirstOrDefaultAsync(u => u.Id == myId);
if (user is not null)
{
ToonUser toonUser = await _context.Users.FirstOrDefaultAsync(u => u.Id == toonUserId);
if (!await AmIFollowingUser(myId, toonUserId))
{
try
{
user?.Following.Add(toonUser);
toonUser?.Followers.Add(user);
await _context.SaveChangesAsync();
return(true);
}
catch (Exception)
{
throw;
}
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch (Exception ex)
{
Debug.WriteLine($"*** ERROR *** - Error following user. --> {ex.Message}");
return(false);
}
}
public async Task <List <Upload> > GetUploadsFromFollowers(string artistId)
{
try
{
ToonUser artist = await _context.Users.FirstOrDefaultAsync(u => u.Id == artistId);
List <ToonUser> followers = artist.Followers.ToList();
List <Upload> followerUploads = new();
foreach (ToonUser user in followers)
{
followerUploads?.AddRange(user.Uploads);
}
return(followerUploads);
}
catch (Exception ex)
{
Debug.WriteLine($"*** ERROR *** - Error getting your followers' uploads - {ex.Message}");
throw;
}
}
private async Task SeedUsersAsync()
{
var adminUser = new ToonUser()
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Kasey",
LastName = "Wahl",
PhoneNumber = "555-5555",
EmailConfirmed = true,
ImageData = await _imageService.EncodeImageAsync("cryingfrankenstein.jpg"),
ContentType = "jpg"
};
var modUser = new ToonUser()
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Turd",
LastName = "Ferguson",
PhoneNumber = "444-4444",
EmailConfirmed = true,
ImageData = await _imageService.EncodeImageAsync("turd_ferguson.jpg"),
ContentType = "jpg"
};
var artistUser1 = new ToonUser()
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "French",
LastName = "Stewart",
PhoneNumber = "333-3333",
EmailConfirmed = true,
ImageData = await _imageService.EncodeImageAsync("french_stewart.jpg"),
ContentType = "jpg"
};
var artistUser2 = new ToonUser()
{
Email = "*****@*****.**",
UserName = "******",
FirstName = "Sean",
LastName = "Connery",
PhoneNumber = "222-2222",
EmailConfirmed = true,
ImageData = await _imageService.EncodeImageAsync("sean_connery.png"),
ContentType = "png"
};
//Create Admin User
await _userManager.CreateAsync(adminUser, _configuration["AdminPassword"]);
//Assign User to Admin Role
await _userManager.AddToRoleAsync(adminUser, ToonerRole.Administrator.ToString());
//Create Mod User
await _userManager.CreateAsync(modUser, _configuration["ModPassword"]);
//Assign User to Mod Role
await _userManager.AddToRoleAsync(modUser, ToonerRole.Moderator.ToString());
//Create Artist 1 User
await _userManager.CreateAsync(artistUser1, _configuration["Artist1Password"]);
//Assign User to Artist Role
await _userManager.AddToRoleAsync(artistUser1, ToonerRole.Artist.ToString());
//Create Artist 2 User
await _userManager.CreateAsync(artistUser2, _configuration["Artist2Password"]);
//Assign User to Artist Role
await _userManager.AddToRoleAsync(artistUser2, ToonerRole.Artist.ToString());
}
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 ToonUser {
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());
}
public async Task <List <ToonUser> > GetFollowingAsync(string myId)
{
ToonUser user = await _context.Users.FirstOrDefaultAsync(u => u.Id == myId);
return(user?.Following.ToList());
}
