public ImmutableArray <CardVersion> Run(MemCheckUser user, DateTime?now = null)
{
var cardVersions = dbContext.Cards.Include(card => card.UsersWithView)
.Join(
dbContext.CardNotifications.Where(cardNotif => cardNotif.UserId == user.Id),
card => card.Id,
cardNotif => cardNotif.CardId,
(card, cardNotif) => new { card, cardNotif }
)
.Where(cardAndNotif => cardAndNotif.card.VersionUtcDate > cardAndNotif.cardNotif.LastNotificationUtcDate);
now = now ?? DateTime.UtcNow;
foreach (var cardVersion in cardVersions)
{
cardVersion.cardNotif.LastNotificationUtcDate = now.Value;
}
return(cardVersions.Select(cardToReport =>
new CardVersion(
cardToReport.card.Id,
cardToReport.card.FrontSide,
cardToReport.card.VersionCreator.UserName,
cardToReport.card.VersionUtcDate,
cardToReport.card.VersionDescription,
!cardToReport.card.UsersWithView.Any() || cardToReport.card.UsersWithView.Any(u => u.UserId == user.Id)
)
).ToImmutableArray());
}
public Request(MemCheckUser currentUser, int pageSize, int pageNo, string filter)
{
CurrentUser = currentUser;
PageSize = pageSize;
PageNo = pageNo;
Filter = filter;
}
private async Task <UserNotifications> GetUserNotificationsAsync(MemCheckUser user)
{
var subscribedCardCount = await userCardSubscriptionCounter.RunAsync(user.Id);
var cardVersions = await userCardVersionsNotifier.RunAsync(user.Id);
var cardDeletions = await userCardDeletionsNotifier.RunAsync(user.Id);
var subscribedSearches = await userSearchSubscriptionLister.RunAsync(user.Id);
var searchNotifs = new List <UserSearchNotifierResult>();
foreach (var subscribedSearch in subscribedSearches)
{
searchNotifs.Add(await userSearchNotifier.RunAsync(subscribedSearch.Id));
}
await userLastNotifDateUpdater.RunAsync(user.Id);
return(new UserNotifications(
user.UserName,
user.Email,
subscribedCardCount,
cardVersions,
cardDeletions,
searchNotifs
));
}
public GetCurrentUserViewModel(MemCheckUser user, MemCheckDbContext dbContext)
{
UserId = user.Id;
UserName = user.UserName;
var cardLanguage = user.PreferredCardCreationLanguage ?? dbContext.CardLanguages.OrderBy(lang => lang.Name).First();
PreferredCardCreationLanguageId = cardLanguage.Id;
}
public void Run(MemCheckUser user, string cultureName)
{
if (!supportedUILanguages.Contains(cultureName))
{
throw new InvalidProgramException($"Invalid culture '{cultureName}'");
}
user.UILanguage = cultureName;
dbContext.SaveChanges();
}
public Request(MemCheckUser owner, string name, string description, string source, string contentType, byte[] blob)
{
Name = name.Trim();
Description = description.Trim();
Source = source.Trim();
ContentType = contentType.Trim();
Owner = owner;
Blob = blob;
}
private async Task <MemCheckUser> CreateUserAsync(DbContextOptions <MemCheckDbContext> testDB)
{
using var dbContext = new MemCheckDbContext(testDB);
var result = new MemCheckUser();
dbContext.Users.Add(result);
await dbContext.SaveChangesAsync();
return(result);
}
public ImageVersionFromDb(Guid id, Guid?previousVersion, DateTime versionUtcDate, MemCheckUser author, string name, string description, string source, string versionDescription)
{
Id = id;
PreviousVersion = previousVersion;
VersionUtcDate = versionUtcDate;
Author = author;
Name = name;
Description = description;
Source = source;
VersionDescription = versionDescription;
}
public async Task <IEnumerable <string> > GetRolesAsync(MemCheckUser user)
{
await Task.CompletedTask;
if (await UserIsAdminAsync(user))
{
return(IRoleChecker.AdminRoleName.AsArray());
}
return(Array.Empty <string>());
}
public Result(Guid imageId, MemCheckUser owner, string name, string description, string source, int cardCount, DateTime initialUploadUtcDate, DateTime lastChangeUtcDate, string currentVersionDescription)
{
ImageId = imageId;
Owner = owner;
Name = name;
Description = description;
Source = source;
CardCount = cardCount;
InitialUploadUtcDate = initialUploadUtcDate;
LastChangeUtcDate = lastChangeUtcDate;
CurrentVersionDescription = currentVersionDescription;
}
public async Task <IActionResult> OnPostAsync()
{
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new MemCheckUser {
UserName = Input.UserName, 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 },
protocol: Request.Scheme) !;
var mailBody = new StringBuilder();
mailBody.Append($"<p>{localizer["Hello"].Value} {user.UserName}</p>");
mailBody.Append($"<p>{localizer["BeforeHyperLink"].Value}</p>");
mailBody.Append($"<p><a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>{localizer["HyperLinkText"].Value}</a></p>");
mailBody.Append($"<p>{localizer["AfterHyperLink"].Value}</p>");
mailBody.Append($"<p>{localizer["Final"].Value}</p>");
await _emailSender.SendEmailAsync(Input.Email, localizer["MailSubject"].Value, mailBody.ToString());
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { UserAddress = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(Input.Email)) }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect("/"));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
private async Task LoadAsync(MemCheckUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
public ResultCard(Guid cardId, string frontSide, IEnumerable <string> tags, IEnumerable <UserWithViewOnCard> visibleTo, IEnumerable <ResultCardDeckInfo> deckInfo, int currentUserRating, double averageRating, int countOfUserRatings, MemCheckUser versionCreator, DateTime versionUtcDate, string versionDescription)
{
CardId = cardId;
FrontSide = frontSide.Truncate(150);
Tags = tags;
VisibleTo = visibleTo;
DeckInfo = deckInfo;
CurrentUserRating = currentUserRating;
AverageRating = averageRating;
CountOfUserRatings = countOfUserRatings;
VersionCreator = versionCreator;
VersionUtcDate = versionUtcDate;
VersionDescription = versionDescription;
}
public Request(MemCheckUser versionCreator, string frontSide, IEnumerable <Guid> frontSideImageList, string backSide, IEnumerable <Guid> backSideImageList, string additionalInfo, IEnumerable <Guid> additionalInfoImageList, Guid languageId, IEnumerable <Guid> tags, IEnumerable <Guid> usersWithVisibility, string versionDescription)
{
VersionCreator = versionCreator;
FrontSide = frontSide.Trim();
BackSide = backSide.Trim();
AdditionalInfo = additionalInfo.Trim();
FrontSideImageList = frontSideImageList;
BackSideImageList = backSideImageList;
AdditionalInfoImageList = additionalInfoImageList;
LanguageId = languageId;
Tags = tags;
UsersWithVisibility = usersWithVisibility;
VersionDescription = versionDescription;
}
public ResultCardBeforeDeckInfo(Guid cardId, string frontSide, IEnumerable <string> tags, IEnumerable <UserWithViewOnCard> visibleTo, MemCheckUser versionCreator, DateTime versionUtcDate, string versionDescription, int userRating, double averageRating, int ratingCount)
{
CardId = cardId;
FrontSide = frontSide;
Tags = tags;
VisibleTo = visibleTo;
CurrentUserRating = userRating;
AverageRating = averageRating;
CountOfUserRatings = ratingCount;
VersionCreator = versionCreator;
VersionUtcDate = versionUtcDate;
VersionDescription = versionDescription;
}
private async Task SendWelcomeMailAsync(MemCheckUser user)
{
var hello = localizer["Hello"];
var welcome = localizer["Welcome"];
var docLine = localizer["DocLine"];
var p = Url.Page(pageName: "/Doc/MdRenderer", pageHandler: null, values: null, protocol: Request.Scheme);
var docUrl = HtmlEncoder.Default.Encode(p);
var docLinkText = localizer["DocLinkText"];
var appLine = localizer["AppLine"];
var appUrl = HtmlEncoder.Default.Encode(Url.Page(pageName: "/Index", pageHandler: null, values: null, protocol: Request.Scheme));
var appLinkText = localizer["AppLinkText"];
var thank = localizer["Thank"];
var body = $"<p>{hello} {user.UserName}</p><p>{welcome}</p><p>{docLine} <a href='{docUrl}'>{docLinkText}</a>.</p><p>{appLine} <a href='{appUrl}'>{appLinkText}</a>.</p><p>{thank}.</p>";
await emailSender.SendEmailAsync(user.Email, localizer["WelcomeMailSubject"], body);
}
public async Task <IActionResult> OnPostAsync()
{
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new MemCheckUser {
UserName = Input.UserName, 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 },
protocol: Request.Scheme);
var body = MailHelper.GetBody(user, callbackUrl, "Please confirm your account");
await _emailSender.SendEmailAsync(Input.Email, "Confirm your email", body);
if (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { userName = Input.UserName }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect("/"));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
private async Task InsertImageInDbAsync(Region region, MemCheckUser user)
{
if (region.GetImageDbId(dbContext) != Guid.Empty)
{
logger.LogDebug($"Image for region '{region.Name}' already in DB");
return;
}
logger.LogDebug($"Inserting image in DB for region '{region.Name}'");
using var stream = File.OpenRead(Path.Combine(sourceDir, region.ImageFileName));
using var reader = new BinaryReader(stream);
var blob = reader.ReadBytes((int)stream.Length);
var request = new StoreImage.Request(user.Id, region.ImageDbName, $"Région {region.Name} dans la carte de France", region.ImageSource, "image/svg+xml", blob);
await new StoreImage(dbContext.AsCallContext()).RunAsync(request);
}
public CardVersionFromDb(Guid id, Guid?previousVersion, DateTime versionUtcDate, MemCheckUser versionCreator, string versionDescription, Guid languageId, string frontSide, string backSide, string additionalInfo, IEnumerable <Guid> tagIds, IEnumerable <Guid> userWithViewIds, IEnumerable <Guid> frontSideImages, IEnumerable <Guid> backSideImages, IEnumerable <Guid> additionalInfoImages)
{
Id = id;
PreviousVersion = previousVersion;
VersionUtcDate = versionUtcDate;
VersionCreator = versionCreator;
VersionDescription = versionDescription;
LanguageId = languageId;
FrontSide = frontSide;
BackSide = backSide;
AdditionalInfo = additionalInfo;
TagIds = tagIds;
UserWithViewIds = userWithViewIds;
FrontSideImages = frontSideImages;
BackSideImages = backSideImages;
AdditionalInfoImages = additionalInfoImages;
}
public async Task DeletionByAdmin()
{
var db = DbHelper.GetEmptyTestDB();
var loggedUser = await UserHelper.CreateInDbAsync(db);
var userToDeleteName = RandomHelper.String();
var userToDeleteEmail = RandomHelper.String();
var userToDeleteId = await UserHelper.CreateInDbAsync(db, userName : userToDeleteName, userEMail : userToDeleteEmail);
await UserHelper.SetRandomPasswordAsync(db, userToDeleteId);
var runDate = RandomHelper.Date();
using (var dbContext = new MemCheckDbContext(db))
//Check user is all set
{
MemCheckUser userToDelete = dbContext.Users.Single(u => u.Id == userToDeleteId);
Assert.AreEqual(userToDeleteName, userToDelete.UserName);
Assert.AreEqual(userToDeleteEmail, userToDelete.Email);
Assert.IsTrue(userToDelete.EmailConfirmed);
Assert.IsFalse(userToDelete.LockoutEnabled);
Assert.IsNull(userToDelete.LockoutEnd);
Assert.IsNull(userToDelete.DeletionDate);
Assert.IsNotNull(userToDelete.PasswordHash);
}
using (var dbContext = new MemCheckDbContext(db))
{
using var userManager = UserHelper.GetUserManager(dbContext);
await new DeleteUserAccount(dbContext.AsCallContext(new TestRoleChecker(loggedUser)), userManager, runDate).RunAsync(new DeleteUserAccount.Request(loggedUser, userToDeleteId));
}
using (var dbContext = new MemCheckDbContext(db))
{
var deletedUser = await dbContext.Users.SingleAsync(u => u.Id == userToDeleteId);
Assert.AreEqual(DeleteUserAccount.DeletedUserName, deletedUser.UserName);
Assert.AreEqual(DeleteUserAccount.DeletedUserEmail, deletedUser.Email);
Assert.IsFalse(deletedUser.EmailConfirmed);
Assert.IsTrue(deletedUser.LockoutEnabled);
Assert.AreEqual(DateTime.MaxValue, deletedUser.LockoutEnd);
Assert.AreEqual(runDate, deletedUser.DeletionDate);
Assert.IsNull(deletedUser.PasswordHash);
}
}
private async Task LoadSharedKeyAndQrCodeUriAsync(MemCheckUser 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);
}
private async Task CreateCard_WhatIsThisRegionAsync(Region region, MemCheckUser user, Guid regionsAndDepartmentsWithNamesImageId, Guid frenchLanguageId, Guid tagId)
{
var frontSide = "Comment s'appelle cette région française ?";
var backSide = region.Name;
if (dbContext.Cards.Where(card => card.VersionCreator.Id == user.Id && card.FrontSide == frontSide && card.BackSide == backSide).Any())
{
logger.LogInformation($"Card already exists for {region.Name}: {frontSide}");
return;
}
var frontSideImages = new[] { region.GetImageDbId(dbContext) };
var backSideImages = new[] { regionsAndDepartmentsWithNamesImageId };
var additionalInfo = $"Elle est constituée de ces {region.Departments.Count()} départements :{Environment.NewLine}{string.Join(Environment.NewLine, region.Departments)}{Environment.NewLine}{Environment.NewLine}En 2017, sa densité était de {region.Density} habitants par km² (la moyenne métropolitaine étant de 168 h/km²).";
var request = new CreateCard.Request(user, frontSide, frontSideImages, backSide, backSideImages, additionalInfo, new Guid[0], frenchLanguageId, new[] { tagId }, new Guid[0], CardVersionDescription);
await new CreateCard(dbContext).RunAsync(request, new FakeStringLocalizer());
}
public async Task PasswordEmpty()
{
var db = DbHelper.GetEmptyTestDB();
using (var dbContext = new MemCheckDbContext(db))
using (var userManager = UserHelper.GetUserManager(dbContext))
{
var user = new MemCheckUser {
UserName = RandomHelper.String(), Email = RandomHelper.String()
};
var result = await userManager.CreateAsync(user, "");
Assert.IsFalse(result.Succeeded);
}
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(0, dbContext.Users.Count());
}
private async Task CreateCard_WhereIsThisRegionAsync(Region region, MemCheckUser user, Guid regionsWithoutNamesImageId, Guid regionsAndDepartmentsWithNamesImageId, Guid frenchLanguageId, Guid tagId)
{
var frontSide = $"Où est la région {region.Name} ?";
if (dbContext.Cards.Where(card => card.VersionCreator.Id == user.Id && card.FrontSide == frontSide).Any())
{
logger.LogInformation($"Card already exists for {region.Name}: {frontSide}");
return;
}
var backSide = "";
var frontSideImages = new[] { regionsWithoutNamesImageId };
var backSideImages = new[] { region.GetImageDbId(dbContext) };
var additionalInfo = $"Elle est constituée de ces {region.Departments.Length} départements :{Environment.NewLine}{string.Join(Environment.NewLine, region.Departments)}{Environment.NewLine}{Environment.NewLine}En 2017, sa densité était de {region.Density} habitants par km² (la moyenne métropolitaine étant de 168 h/km²).";
var additionalInfoImages = new[] { regionsAndDepartmentsWithNamesImageId };
var request = new CreateCard.Request(user.Id, frontSide, frontSideImages, backSide, backSideImages, additionalInfo, additionalInfoImages, frenchLanguageId, tagId.AsArray(), Array.Empty <Guid>(), CardVersionDescription);
await new CreateCard(dbContext.AsCallContext()).RunAsync(request);
}
public ResultImageModel(Guid imageId, string imageName, int cardCount, string originalImageContentType,
MemCheckUser uploader, string description, string source, int originalImageSize, int smallSize, int mediumSize, int bigSize,
DateTime initialUploadUtcDate, DateTime lastChangeUtcDate, string currentVersionDescription)
{
ImageId = imageId;
ImageName = imageName;
CardCount = cardCount;
OriginalImageContentType = originalImageContentType;
Uploader = uploader;
Description = description;
Source = source;
OriginalImageSize = originalImageSize;
SmallSize = smallSize;
MediumSize = mediumSize;
BigSize = bigSize;
InitialUploadUtcDate = initialUploadUtcDate;
LastChangeUtcDate = lastChangeUtcDate;
CurrentVersionDescription = currentVersionDescription;
}
public async Task NameTooLong()
{
var db = DbHelper.GetEmptyTestDB();
using (var dbContext = new MemCheckDbContext(db))
using (var userManager = UserHelper.GetUserManager(dbContext))
{
var user = new MemCheckUser {
UserName = RandomHelper.String(MemCheckUserManager.MaxUserNameLength + 1), Email = RandomHelper.String()
};
var result = await userManager.CreateAsync(user, RandomPassword());
Assert.IsFalse(result.Succeeded);
Assert.AreEqual(MemCheckUserManager.BadUserNameLengthErrorCode, result.Errors.First().Code);
}
using (var dbContext = new MemCheckDbContext(db))
Assert.AreEqual(0, dbContext.Users.Count());
}
public ImmutableArray <CardDeletion> Run(MemCheckUser user)
{
//It is a little strange to keep checking for deleted cards when the user has been notified of their deletion. But I'm not clear right now about what to do in case a card is undeleted
var deletedCards = from previousVersion in dbContext.CardPreviousVersions.Include(pv => pv.UsersWithView)
join cardNotif in dbContext.CardNotifications
on previousVersion.Card equals cardNotif.CardId
where (cardNotif.UserId == user.Id) && (previousVersion.VersionType == CardPreviousVersionType.Deletion) && (previousVersion.VersionUtcDate > cardNotif.LastNotificationUtcDate)
select new { previousVersion.FrontSide, previousVersion.VersionCreator, previousVersion.VersionUtcDate, previousVersion.VersionDescription, previousVersion.UsersWithView };
return(deletedCards.Select(cardToReport =>
new CardDeletion(
cardToReport.FrontSide,
cardToReport.VersionCreator.UserName,
cardToReport.VersionUtcDate,
cardToReport.VersionDescription,
!cardToReport.UsersWithView.Any() || cardToReport.UsersWithView.Any(u => u.AllowedUserId == user.Id)
)
).ToImmutableArray());
}
private async Task <UserNotifications> GetUserNotificationsAsync(MemCheckUser user)
{
var registeredCardCount = await dbContext.CardNotifications.Where(notif => notif.UserId == user.Id).CountAsync();
var cardVersions = userCardVersionsNotifier.Run(user);
var cardDeletions = userCardDeletionsNotifier.Run(user);
//var endOfRequest = DateTime.UtcNow;
//foreach (var registeredCard in registeredCardsForUser.Values)
// registeredCard.LastNotificationUtcDate = endOfRequest;
await dbContext.SaveChangesAsync();
return(new UserNotifications(
user.UserName,
user.Email,
registeredCardCount,
cardVersions,
cardDeletions
));
}
public async Task Success()
{
var db = DbHelper.GetEmptyTestDB();
string userName = RandomHelper.String(MemCheckUserManager.MaxUserNameLength);
string email = RandomHelper.String();
var userToCreate = new MemCheckUser {
UserName = userName, Email = email
};
using (var dbContext = new MemCheckDbContext(db))
using (var userManager = UserHelper.GetUserManager(dbContext))
{
var creationResult = await userManager.CreateAsync(userToCreate, RandomPassword());
Assert.IsTrue(creationResult.Succeeded);
}
using (var dbContext = new MemCheckDbContext(db))
using (var userManager = UserHelper.GetUserManager(dbContext))
{
var userFromDb = await userManager.FindByIdAsync(userToCreate.Id.ToString());
Assert.IsNotNull(userFromDb);
Assert.AreEqual(userToCreate.UserName, userFromDb.UserName);
Assert.AreEqual(userToCreate.Email, userFromDb.Email);
Assert.IsNull(userFromDb.DeletionDate);
Assert.IsFalse(userFromDb.EmailConfirmed);
var getUserDecks = new GetUserDecks(dbContext.AsCallContext());
var userDecks = await getUserDecks.RunAsync(new GetUserDecks.Request(userToCreate.Id));
Assert.AreEqual(1, userDecks.Count());
var deck = userDecks.First();
Assert.AreEqual(0, deck.CardCount);
Assert.AreEqual(MemCheckUserManager.DefaultDeckName, deck.Description);
Assert.AreEqual(HeapingAlgorithms.DefaultAlgoId, deck.HeapingAlgorithmId);
}
}
public async Task <Card> RunAsync(Guid cardId, MemCheckUser newVersionCreator, string newVersionDescription, DateTime?cardNewVersionUtcDate = null)
{
var card = await dbContext.Cards
.Include(card => card.Images)
.Include(card => card.UsersWithView)
.ThenInclude(userWithView => userWithView.User)
.Include(card => card.PreviousVersion)
.Include(card => card.CardLanguage)
.Include(card => card.TagsInCards)
.Include(card => card.VersionCreator)
//.AsSingleQuery()
.SingleAsync(img => img.Id == cardId);
var previousVersion = await CreatePreviousVersionAsync(card);
card.PreviousVersion = previousVersion;
card.VersionCreator = newVersionCreator;
card.VersionUtcDate = cardNewVersionUtcDate ?? DateTime.UtcNow;
card.VersionDescription = newVersionDescription;
card.VersionType = CardVersionType.Changes;
return(card);
}
