using Microsoft.Extensions.Localization; using MongoDB.Driver; using MongoDB.Entities; using PrivaPub.ClientModels; using PrivaPub.ClientModels.User; using PrivaPub.Models; using PrivaPub.Models.User; using PrivaPub.Resources; using PrivaPub.Infrastructure.Jobs; using PrivaPub.Models.Jobs; using PrivaPub.StaticServices; using System.Globalization; using System.Text.Json; #pragma warning disable 8603 #pragma warning disable 8625 namespace PrivaPub.Services { public class RootUsersService( IJobQueue jobs, IRootSessions sessions, IRootRemoval removal, IStringLocalizer localizer, ILogger logger, IPasswordHasher passwordHasher, DbEntities dbEntities, AppConfigurationService appConfigurationService) : IRootUsersService { public const string NoMatch = "That username and password do not match."; static string _decoy; // a hash nobody's password matches, so an unknown login costs the same hashing as a wrong password string Decoy => _decoy ??= passwordHasher.Hash(Convert.ToHexString(System.Security.Cryptography.RandomNumberGenerator.GetBytes(16))); public async Task SignUpAsync(LoginForm signUpForm, CancellationToken token = default) { var result = new WebResult(); try { signUpForm.UserName = signUpForm.UserName.ToLower(); if (await dbEntities.RootUsers.Match(u => u.UserName == signUpForm.UserName).ExecuteAnyAsync(token)) return result.Invalidate(30001.ToCodedError(localizer["Username '{0}' already taken.", signUpForm.UserName])); var signUpPasswordHashed = passwordHasher.Hash(signUpForm.Password); var newUser = new RootUser { UserName = signUpForm.UserName, HashedPassword = signUpPasswordHashed }; var cultureLanguage = CultureInfo.CurrentCulture.TwoLetterISOLanguageName; var language = await dbEntities.Languages.Match(l => l.International2Code == cultureLanguage).ExecuteFirstAsync(token); newUser.Settings = new RootUserSettings { LanguageCode = language?.International2Code ?? "en", LightThemeIndexColour = signUpForm.LightThemeIndexColour, DarkThemeIndexColour = signUpForm.DarkThemeIndexColour, IconsThemeIndexColour = signUpForm.IconsThemeIndexColour, ThemeIsDarkGray = signUpForm.ThemeIsDarkGray, ThemeIsLightGray = signUpForm.ThemeIsLightGray, PreferSystemTheming = signUpForm.PreferSystemTheming, ThemeIsDarkMode = signUpForm.ThemeIsDarkMode }; await DB.Default.SaveAsync(newUser, token); result.Data = (newUser, ToViewSettings(newUser.Settings)); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(SignUpAsync)}()"); return result.Invalidate(30002.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task LoginAsync(LoginForm loginForm, CancellationToken token = default) { var result = new WebResult(); try { // One answer, after the same work, whether the login is unknown, deleted or the password wrong: sign-in must not // tell anyone which logins exist. Only someone who knows the password learns the login is banned. loginForm.UserName = loginForm.UserName.ToLower(); var user = await dbEntities.RootUsers.Match(u => u.UserName == loginForm.UserName && u.DeletedAt == null).ExecuteFirstAsync(token); var (verified, needsUpgrade) = passwordHasher.Check(user?.HashedPassword ?? Decoy, loginForm.Password); if (user?.HashedPassword == default || !verified) return result.Invalidate(30003.ToCodedError(localizer[NoMatch])); if (user.IsBanned) return result.Invalidate(30004.ToCodedError(localizer["User '{0}' banned.", user.UserName])); // only a correct password learns that two-factor is on: it is asked for with a 428 if (user.Totp?.EnabledAt != default) { if (string.IsNullOrWhiteSpace(loginForm.OneTimeCode)) return result.Invalidate(30005.ToCodedError(localizer[TwoFactor.CodeNeeded]), StatusCodes.Status428PreconditionRequired); if (!await TwoFactor.Consume(user, loginForm.OneTimeCode, CancellationToken.None)) return result.Invalidate(30006.ToCodedError(localizer[TwoFactor.CodeInvalid])); } // hashed again at today's iterations; matched on the old hash, so two sign-ins at once never undo each other if (needsUpgrade) { var oldHash = user.HashedPassword; user.HashedPassword = passwordHasher.Hash(loginForm.Password); await DB.Default.Update() .Match(u => u.ID == user.ID && u.HashedPassword == oldHash) .Modify(u => u.HashedPassword, user.HashedPassword) .ExecuteAsync(token); } var userSettingsResult = await GetUserSettingsAsync(user.ID, loginForm, token); var userSettings = (ViewUserSettings)userSettingsResult.Data; result.Data = (user, userSettings); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(LoginAsync)}()"); return result.Invalidate(30007.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task UpdateUserSettingsAsync(ViewUserSettings userSettings, string userId, CancellationToken token = default) { var result = new WebResult(); try { var isSupportedLanguage = appConfigurationService.AppConfiguration.SupportedLanguages.Contains(userSettings.LanguageCode); if (!isSupportedLanguage) return result.Invalidate(30008.ToCodedError(localizer["Language code '{0}' unsupported.", userSettings.LanguageCode])); var languageCodeExists = await dbEntities.Languages .Match(l => l.International2Code == userSettings.LanguageCode).ExecuteAnyAsync(token); if (!languageCodeExists) return result.Invalidate(30009.ToCodedError(localizer["Language code '{0}' doesn't exist.", userSettings.LanguageCode])); var language = await dbEntities.Languages.Match(l => l.International2Code == userSettings.LanguageCode) .ExecuteFirstAsync(token); _ = await DB.Default.Update() .MatchID(userId) .Modify(u => u.Settings.LanguageCode, language.International2Code) .Modify(u => u.Settings.LightThemeIndexColour, userSettings.LightThemeIndexColour) .Modify(u => u.Settings.DarkThemeIndexColour, userSettings.DarkThemeIndexColour) .Modify(u => u.Settings.PreferSystemTheming, userSettings.PreferSystemTheming) .Modify(u => u.Settings.ThemeIsDarkMode, userSettings.ThemeIsDarkMode) .Modify(u => u.Settings.ThemeIsDarkGray, userSettings.ThemeIsDarkGray) .Modify(u => u.Settings.ThemeIsLightGray, userSettings.ThemeIsLightGray) .Modify(u => u.Settings.IconsThemeIndexColour, userSettings.IconsThemeIndexColour) .Modify(u => u.Settings.SavedAt, DateTime.UtcNow) .Modify(u => u.UpdatedAt, DateTime.UtcNow) .ExecuteAsync(token); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(UpdateUserSettingsAsync)}()"); return result.Invalidate(30010.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task UpdateUserPasswordAsync(UserPasswordForm userPasswordForm, string userId, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.Match(u => u.ID == userId && u.DeletedAt == null).ExecuteFirstAsync(token); if (user == null) return result.Invalidate(30011.ToCodedError(localizer["Username '{0}' not found.", userId])); var (verified, needsUpgrade) = passwordHasher.Check(user.HashedPassword, userPasswordForm.OldPassword); if (!verified) return result.Invalidate(30012.ToCodedError(localizer["Wrong password."])); await DB.Default.Update().MatchID(user.ID) .Modify(u => u.HashedPassword, passwordHasher.Hash(userPasswordForm.NewPassword)) .Modify(u => u.UpdatedAt, DateTime.UtcNow) .ExecuteAsync(token); // whoever else is signed in may be why the password changed: every session ends, and the caller gets a new one await sessions.Revoke(user.ID, CancellationToken.None); user = await dbEntities.RootUsers.MatchID(user.ID).ExecuteFirstAsync(token); result.Data = (user, ToViewSettings(user.Settings)); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(UpdateUserPasswordAsync)}()"); return result.Invalidate(30013.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task RemoveUserAsync(UsersIds usersIds, CancellationToken token = default) { var result = new WebResult(); try { var removed = 0; foreach (var id in usersIds.UserIdList.Distinct()) if (await removal.Remove(id, CancellationToken.None)) removed++; if (removed == 0) return result.Invalidate(30014.ToCodedError(localizer["User already deleted."])); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(RemoveUserAsync)}()"); return result.Invalidate(30015.ToCodedError(localizer["Something went wrong."]), exception: ex); } } // A root deletes itself only with its password, so a stolen session cannot. public async Task RemoveSelfAsync(string rootId, string password, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token); var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty); if (user?.HashedPassword == default || !verified) return result.Invalidate(30016.ToCodedError(localizer[NoMatch]), StatusCodes.Status403Forbidden); await removal.Remove(user.ID, CancellationToken.None); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(RemoveSelfAsync)}()"); return result.Invalidate(30017.ToCodedError(localizer["Something went wrong."]), exception: ex); } } // what can't be undone asks for the password again (a persona's or a group's deletion, by its login or an administrator) public async Task PasswordMatches(string rootId, string password, CancellationToken token = default) { var user = string.IsNullOrEmpty(rootId) ? default : await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token); var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty); return user?.HashedPassword != default && verified; } public async Task BanUserAsync(UsersIds usersIds, CancellationToken token = default) { var result = new WebResult(); try { await DB.Default.Update() .Match(u => usersIds.UserIdList.Contains(u.ID)) .Modify(u => u.IsBanned, true) .ExecuteAsync(token); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(BanUserAsync)}()"); return result.Invalidate(30018.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task UnbanUserAsync(UsersIds usersIds, CancellationToken token = default) { var result = new WebResult(); try { await DB.Default.Update() .Match(u => usersIds.UserIdList.Contains(u.ID)) .Modify(u => u.IsBanned, false) .ExecuteAsync(token); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(UnbanUserAsync)}()"); return result.Invalidate(30019.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task GetUserSettingsAsync(string userId, LoginForm loginForm = default, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.MatchID(userId).ExecuteFirstAsync(token); if (user == default) return result.Invalidate(30020.ToCodedError(localizer["User not found."]), StatusCodes.Status404NotFound); if (loginForm != default && loginForm.ThemeIsDarkMode != user.Settings.ThemeIsDarkMode) { user.Settings.ThemeIsDarkMode = loginForm.ThemeIsDarkMode; await DB.Default.Update() .MatchID(userId) .Modify(u => u.Settings.ThemeIsDarkMode, loginForm.ThemeIsDarkMode) .ExecuteAsync(token); } result.Data = ToViewSettings(user.Settings); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(GetUserSettingsAsync)}()"); return result.Invalidate(30021.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public const string RecoverySent = "If that account has an email address, a recovery link is on its way. It works for one hour."; // The same answer, after the same work, whether the account exists, has an email or can be written to: recovery must // not tell anyone which logins or addresses exist. RecoveryJob does the rest, out of the request. public async Task SetupAndSendRecoveryEmail(PasswordRecoveryForm passwordRecoveryForm, string host, CancellationToken token = default) { var result = new WebResult(); try { var userName = passwordRecoveryForm.UserName?.ToLowerInvariant(); var user = passwordRecoveryForm.IsEmailDisabled ? await dbEntities.RootUsers.Match(u => u.UserName == userName && u.DeletedAt == null).ExecuteFirstAsync(token) : await dbEntities.RootUsers.Match(u => u.Email == passwordRecoveryForm.Email && u.IsEmailValidated && u.DeletedAt == null).ExecuteFirstAsync(token); await jobs.Enqueue(JobKind.SendRecovery, JsonSerializer.Serialize(new RecoveryPayload(user?.ID, host)), RecoveryJob.Host, dedupeKey: default, CancellationToken.None); result.Data = (string)localizer[RecoverySent]; return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(SetupAndSendRecoveryEmail)}()"); return result.Invalidate(30022.ToCodedError(localizer["Something went wrong."]), exception: ex); } } Task LiveRecovery(string recoveryCode, CancellationToken token = default) { var hash = RecoveryJob.Hash(recoveryCode); var now = DateTime.UtcNow; return dbEntities.EmailRecoveries.Match(er => er.CodeHash == hash && er.ExpiresAt > now).ExecuteFirstAsync(token); } public async Task IsValidRecoveryCode(string recoveryCode, CancellationToken token = default) { var result = new WebResult(); try { result.Data = await LiveRecovery(recoveryCode, token) != default; return result; } catch (Exception ex) { return result.Invalidate(30023.ToCodedError(localizer["Something went wrong."]), exception: ex); } } // A recovered password ends every session the root had: whoever had them may be why it was recovered. public async Task ChangePassword(NewPasswordForm newPasswordForm, CancellationToken token = default) { var result = new WebResult(); try { var recovery = await LiveRecovery(newPasswordForm.RecoveryCode, token); var user = recovery == default ? default : await dbEntities.RootUsers.MatchID(recovery.RootUserId).Match(u => u.DeletedAt == null && !u.IsBanned).ExecuteFirstAsync(token); if (user == default) return result.Invalidate(30024.ToCodedError(localizer["Invalid recovery code."]), StatusCodes.Status404NotFound); await DB.Default.Update().MatchID(user.ID) .Modify(u => u.HashedPassword, passwordHasher.Hash(newPasswordForm.NewPassword)) .Modify(u => u.UpdatedAt, DateTime.UtcNow) .ExecuteAsync(token); await DB.Default.DeleteAsync(er => er.RootUserId == user.ID); await sessions.Revoke(user.ID, CancellationToken.None); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(ChangePassword)}()"); return result.Invalidate(30025.ToCodedError(localizer["Something went wrong."]), exception: ex); } } static ViewUserSettings ToViewSettings(RootUserSettings settings) => new() { LanguageCode = settings.LanguageCode, LightThemeIndexColour = settings.LightThemeIndexColour, DarkThemeIndexColour = settings.DarkThemeIndexColour, PreferSystemTheming = settings.PreferSystemTheming, ThemeIsDarkMode = settings.ThemeIsDarkMode, IconsThemeIndexColour = settings.IconsThemeIndexColour, ThemeIsDarkGray = settings.ThemeIsDarkGray, ThemeIsLightGray = settings.ThemeIsLightGray, SavedAt = settings.SavedAt }; public const string EmailCodeSent = "If that address can be used, a code is on its way to it. It works for one hour."; public const string EmailCodeInvalid = "That code is not valid."; public async Task AccountAsync(string rootId, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token); if (user == default) return result.Invalidate(30026.ToCodedError(localizer["User not found."]), StatusCodes.Status404NotFound); var now = DateTime.UtcNow; var pending = await DB.Default.Find().Match(v => v.RootUserId == rootId && v.ExpiresAt > now).ExecuteFirstAsync(token); result.Data = new ViewAccount { UserName = user.UserName, Email = user.Email, IsEmailValidated = user.IsEmailValidated, PendingEmail = pending?.Email, CreatedAt = user.CreatedAt, TwoFactorEnabled = user.Totp?.EnabledAt != default, RecoveryCodesLeft = user.Totp?.EnabledAt != default ? user.Totp.RecoveryCodeHashes.Count : 0 }; return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(AccountAsync)}()"); return result.Invalidate(30027.ToCodedError(localizer["Something went wrong."]), exception: ex); } } // Only with the password, so a stolen session can't move recovery to its own inbox. The answer is the same sentence // whether or not the address is free; EmailVerificationJob sends the code, or nothing when another login holds it. public async Task RequestEmailChangeAsync(string rootId, EmailChangeForm form, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token); var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, form.Password ?? string.Empty); if (user?.HashedPassword == default || !verified) return result.Invalidate(30028.ToCodedError(localizer["Wrong password."]), StatusCodes.Status403Forbidden); await DB.Default.DeleteAsync(v => v.RootUserId == user.ID); var pending = new EmailVerification { RootUserId = user.ID, Email = form.Email.Trim().ToLowerInvariant(), ExpiresAt = DateTime.UtcNow + EmailVerification.Lifetime }; await DB.Default.SaveAsync(pending, token); await jobs.Enqueue(JobKind.SendEmailVerification, JsonSerializer.Serialize(new EmailVerificationPayload(pending.ID)), EmailVerificationJob.Host, dedupeKey: default, CancellationToken.None); result.Data = (string)localizer[EmailCodeSent]; return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(RequestEmailChangeAsync)}()"); return result.Invalidate(30029.ToCodedError(localizer["Something went wrong."]), exception: ex); } } // One answer for every failure (wrong, expired, five tries spent, or the address verified by another login meanwhile) public async Task VerifyEmailAsync(string rootId, string code, CancellationToken token = default) { var result = new WebResult(); try { var now = DateTime.UtcNow; var pending = await DB.Default.Find().Match(v => v.RootUserId == rootId && v.ExpiresAt > now).ExecuteFirstAsync(token); if (pending == default || string.IsNullOrEmpty(pending.CodeHash)) return result.Invalidate(30030.ToCodedError(localizer[EmailCodeInvalid])); if (pending.CodeHash != RecoveryJob.Hash(code?.Trim())) { if (pending.Attempts + 1 >= EmailVerification.MaxAttempts) await DB.Default.DeleteAsync(pending.ID); else await DB.Default.Update().MatchID(pending.ID).Modify(b => b.Inc(v => v.Attempts, 1)).ExecuteAsync(token); return result.Invalidate(30031.ToCodedError(localizer[EmailCodeInvalid])); } await DB.Default.DeleteAsync(pending.ID); if (await dbEntities.RootUsers.Match(u => u.Email == pending.Email && u.IsEmailValidated && u.ID != rootId && u.DeletedAt == null).ExecuteAnyAsync(token)) return result.Invalidate(30032.ToCodedError(localizer[EmailCodeInvalid])); await DB.Default.Update().MatchID(rootId) .Modify(u => u.Email, pending.Email) .Modify(u => u.IsEmailValidated, true) .Modify(u => u.UpdatedAt, now) .ExecuteAsync(token); return await AccountAsync(rootId, token); } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(VerifyEmailAsync)}()"); return result.Invalidate(30033.ToCodedError(localizer["Something went wrong."]), exception: ex); } } // Two-factor sign-in (TwoFactor): set up with the password, turned on by the app's first code (which also proves the // app holds the secret), turned off with the password and a code. Turning it on ends every other session. public async Task TotpSetupAsync(string rootId, string password, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token); var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty); if (user?.HashedPassword == default || !verified) return result.Invalidate(30034.ToCodedError(localizer["Wrong password."]), StatusCodes.Status403Forbidden); if (user.Totp?.EnabledAt != default) return result.Invalidate(30035.ToCodedError(localizer["Two-factor sign-in is on already: turn it off first."]), StatusCodes.Status409Conflict); var secret = TwoFactor.NewSecret(); await DB.Default.Update().MatchID(rootId) .Modify(u => u.Totp, new RootTotp { PendingSecret = secret, PendingSince = DateTime.UtcNow }) .ExecuteAsync(token); var uri = TwoFactor.OtpAuthUri(secret, user.UserName); result.Data = new ViewTotpSetup { Secret = secret, OtpAuthUri = uri, QrDataUri = TwoFactor.QrDataUri(uri) }; return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(TotpSetupAsync)}()"); return result.Invalidate(30036.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task TotpEnableAsync(string rootId, string code, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token); if (user?.Totp is not { EnabledAt: null, PendingSecret: not null } pending || pending.PendingSince < DateTime.UtcNow.AddHours(-1)) return result.Invalidate(30037.ToCodedError(localizer["Set up two-factor sign-in again: that setup expired."]), StatusCodes.Status409Conflict); if (TwoFactor.Step(pending.PendingSecret, code) is not { } step) return result.Invalidate(30038.ToCodedError(localizer[TwoFactor.CodeInvalid])); var codes = TwoFactor.NewRecoveryCodes(); await DB.Default.Update().MatchID(rootId) .Modify(u => u.Totp, new RootTotp { Secret = pending.PendingSecret, EnabledAt = DateTime.UtcNow, LastStep = step, RecoveryCodeHashes = codes.Select(TwoFactor.HashRecovery).ToList() }) .ExecuteAsync(token); await sessions.Revoke(rootId, CancellationToken.None); user = await dbEntities.RootUsers.MatchID(rootId).ExecuteFirstAsync(token); result.Data = (user, ToViewSettings(user.Settings), codes); return result; } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(TotpEnableAsync)}()"); return result.Invalidate(30039.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task TotpDisableAsync(string rootId, string password, string code, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token); var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty); if (user?.HashedPassword == default || !verified) return result.Invalidate(30040.ToCodedError(localizer["Wrong password."]), StatusCodes.Status403Forbidden); if (user.Totp?.EnabledAt == default) return await AccountAsync(rootId, token); if (!await TwoFactor.Consume(user, code, CancellationToken.None)) return result.Invalidate(30041.ToCodedError(localizer[TwoFactor.CodeInvalid])); await DB.Default.Update().MatchID(rootId).Modify(u => u.Totp, null).ExecuteAsync(token); return await AccountAsync(rootId, token); } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(TotpDisableAsync)}()"); return result.Invalidate(30042.ToCodedError(localizer["Something went wrong."]), exception: ex); } } public async Task RemoveEmailAsync(string rootId, string password, CancellationToken token = default) { var result = new WebResult(); try { var user = await dbEntities.RootUsers.MatchID(rootId).Match(u => u.DeletedAt == null).ExecuteFirstAsync(token); var (verified, _) = passwordHasher.Check(user?.HashedPassword ?? Decoy, password ?? string.Empty); if (user?.HashedPassword == default || !verified) return result.Invalidate(30043.ToCodedError(localizer["Wrong password."]), StatusCodes.Status403Forbidden); await DB.Default.Update().MatchID(rootId) .Modify(u => u.Email, null) .Modify(u => u.IsEmailValidated, false) .Modify(u => u.UpdatedAt, DateTime.UtcNow) .ExecuteAsync(token); await DB.Default.DeleteAsync(v => v.RootUserId == rootId); await DB.Default.DeleteAsync(r => r.RootUserId == rootId); return await AccountAsync(rootId, token); } catch (Exception ex) { logger.LogError(ex, $"{nameof(RootUsersService)}.{nameof(RemoveEmailAsync)}()"); return result.Invalidate(30044.ToCodedError(localizer["Something went wrong."]), exception: ex); } } } }