public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
var changePasswordResult = await _userManager.ChangePasswordAsync(user, Input.OldPassword, Input.NewPassword);
if (!changePasswordResult.Succeeded)
{
foreach (var error in changePasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
_logger.LogInformation($"User changed their password successfully (For user with ID '{_userManager.GetUserId(User)}').");
StatusMessage = "گذرواژه شما تغییر کرد.";
return(RedirectToPage());
}
// Run the command
public override void Run(List <string> arguments)
{
// ARGS: block <(l)eft|(r)ight|(h)ead>
// Make sure we are connected to a client
if (!attachedApplication.client.isConnected)
{
attachedApplication.output.PrintLine("$maNot $maconnected $mato $maany $maserver. $maMake $masure $mayour $maclient $mais $maconnected.");
return;
}
if (arguments.Count > 0)
{
// Create a new server command
Support.Networking.ServerCommands.ServerCommandBlock serverCommand = new Support.Networking.ServerCommands.ServerCommandBlock(attachedApplication.client.clientID);
// The name of the tool we want to use
string directionToBlock = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, 0, new List <string>()
{
}));
// Make sure we have all the arguments
if (directionToBlock == "")
{
attachedApplication.output.PrintLine(Describer.ToColor("$ma", "block <(l)eft|(r)ight|(h)ead>"));
return;
}
// Send the parsed arguments
serverCommand.arguments.Add(directionToBlock);
// Send the request to the server
attachedApplication.client.SendServerCommand(serverCommand);
}
else
{
attachedApplication.output.PrintLine(Describer.ToColor("$ma", "block <(l)eft|(r)ight|(h)ead>"));
}
}
public async Task <IActionResult> OnGetLinkLoginCallbackAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
var info = await _signInManager.GetExternalLoginInfoAsync(await _userManager.GetUserIdAsync(user));
if (info == null)
{
throw new InvalidOperationException($"خطای پیش بینی نشده در حین بارگذاری اطلاعات ورود خارجی برای کاربر '{user.Id}' پیش آمد.");
}
var result = await _userManager.AddLoginAsync(user, info);
if (!result.Succeeded)
{
StatusMessage = "ورود خارجی اضافه نشد. امکان استفاده همزمان از یک ورود خارجی، همزمان تنها برای یک حساب کاربری امکان پذیر است.";
return(RedirectToPage());
}
// Clear the existing external cookie to ensure a clean login process
await HttpContext.SignOutAsync(IdentityConstants.ExternalScheme);
StatusMessage = "ورود خارجی اضافه شد.";
return(RedirectToPage());
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
var addPasswordResult = await _userManager.AddPasswordAsync(user, Input.NewPassword);
if (!addPasswordResult.Succeeded)
{
foreach (var error in addPasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(Page());
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "گذرواژه ثبت شد.";
return(RedirectToPage());
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
var isTwoFactorEnabled = await _userManager.GetTwoFactorEnabledAsync(user);
var userId = await _userManager.GetUserIdAsync(user);
if (!isTwoFactorEnabled)
{
throw new InvalidOperationException($"امکان ساخت کد های بازیابی برای کاربر با شناسه '{userId}' وجود نداشت، چراکه احراز هویت دو مرحله ای برای وی فعال نیست.");
}
var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
RecoveryCodes = recoveryCodes.ToArray();
_logger.LogInformation($"برای کاربر با شناسه '{userId}' مجموعه جدیدی از کد های بازیابی ایجاد شد.", userId);
StatusMessage = "اکنون کد های بازیابی تازه ای در اختیار دارید.";
return(RedirectToPage("./ShowRecoveryCodes"));
}
static void Main(string[] args)
{
var per1 = new Person
{
Names = new List <Address>
{
new Address
{
Street = "asdasd",
Number = 2
}, new Address
{
Street = "aa",
Number = 3
}
}
};
IEnumerable <Person> arr = new List <Person> {
per1
};
Console.Write(Describer.Describe(arr));
}
private async Task ValidateEmail(UserManager <User> manager, User user, List <IdentityError> errors)
{
var email = await manager.GetEmailAsync(user);
if (string.IsNullOrWhiteSpace(email))
{
errors.Add(Describer.InvalidEmail(email));
return;
}
if (!new EmailAddressAttribute().IsValid(email))
{
errors.Add(Describer.InvalidEmail(email));
return;
}
var owner = await manager.FindByEmailAsync(email);
if (owner != null && !string.Equals(await manager.GetUserIdAsync(owner), await manager.GetUserIdAsync(user)))
{
errors.Add(Describer.DuplicateEmail(email));
}
}
public async Task <IActionResult> OnPostSetProfileImageAsync(IFormFile image)
{
var user = await _userManager.GetUserAsync(User);
//Invalid UserID
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
if (image == null)
{
return(RedirectToPage());
}
if (!string.IsNullOrEmpty(user.ProfileImagePath))
{
_ifileManager.DeleteFile(user.ProfileImagePath);
}
var avatarPath = $"uploads/avatars/{PersianDateTime.Now.ToString("yyyy/MM/dd/yyyyMMddhhmmss") + DateTime.Now.ToString("ffff") + new Random().Next(1000000, 9999999)}_{WebApp.Helpers.File.ValidateName(image.FileName)}";
await _ifileManager.SaveFile(image, avatarPath);
user.ProfileImagePath = $"/{avatarPath}";
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
var userId = await _userManager.GetUserIdAsync(user);
throw new InvalidOperationException($"به روز رسانی تصویر نمایه برای کاربر '{userId}' با خطا مواجه شد..");
}
StatusMessage = "تصویر نمایه به روز شد.";
return(RedirectToPage());
}
private async Task ValidateUserName(UserManager <TUser> manager, TUser user, ICollection <IdentityError> errors)
{
var userName = await manager.GetUserNameAsync(user);
if (userName?.Length < RequiredUsernameLength)
{
errors.Add(Describer.UsernameTooShort());
}
}
public async Task <IActionResult> OnGet()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
return(Page());
}
// Run the command
public override void Run(List <string> arguments)
{
// ARGS: fasten/attach <nameOfObjectToAttach> to <nameOfObjectToAttachTo> with/using <nameOfObjectToAttachWith>
// Make sure we are connected to a client
if (!attachedApplication.client.isConnected)
{
attachedApplication.output.PrintLine("$maNot $maconnected $mato $maany $maserver. $maMake $masure $mayour $maclient $mais $maconnected.");
return;
}
if (arguments.Count > 0)
{
// Create a new server command
Support.Networking.ServerCommands.ServerCommandAttach serverCommand = new Support.Networking.ServerCommands.ServerCommandAttach(attachedApplication.client.clientID);
// The index of the object to attach
int indexOfObjectToAttach = 0;
// The index of the object to attach to
int indexOfObjectToAttachTo = 0;
// The index of the object to attach with
int indexOfObjectToAttachWith = 0;
// Get the full name of the object to attach
string fullNameOfObjectToAttach = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, indexOfObjectToAttach, new List <string> {
"to"
}, ref indexOfObjectToAttachTo));
// After the to, get the full name of the object to attach to
string fullNameOfObjectToAttachTo = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, indexOfObjectToAttachTo, new List <string> {
"with", "using"
}, ref indexOfObjectToAttachWith));
// Finally, get the object to attach with
string fullNameOfObjectToAttachWith = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, indexOfObjectToAttachWith, new List <string> {
}));
// If we're missing any objects, throw an error
if (fullNameOfObjectToAttach == "" ||
fullNameOfObjectToAttachTo == "" ||
fullNameOfObjectToAttachWith == "")
{
attachedApplication.output.PrintLine(Describer.ToColor("$ma", "Usage: fasten/attach <nameOfObjectToAttach> to <nameOfObjectToAttachTo> with/using <nameOfObjectToAttachWith>"));
return;
}
// Add on the arguments to the server command
serverCommand.arguments.Add(fullNameOfObjectToAttach);
serverCommand.arguments.Add(fullNameOfObjectToAttachTo);
serverCommand.arguments.Add(fullNameOfObjectToAttachWith);
// Send the request to the server
attachedApplication.client.SendServerCommand(serverCommand);
}
else
{
attachedApplication.output.PrintLine(Describer.ToColor("$ma", "Usage: fasten/attach <nameOfObjectToAttach> to <nameOfObjectToAttachTo> with/using <nameOfObjectToAttachWith>"));
}
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
//Invalid UserID
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
if (ModelState.IsValid)
{
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
if (Input.PhoneNumber != phoneNumber)
{
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber.PersianNumberToEnglish());
if (!setPhoneResult.Succeeded)
{
var userId = await _userManager.GetUserIdAsync(user);
throw new InvalidOperationException($"تنظیم شماره تماس برای کاربر '{userId}' با خطا مواجه شد..");
}
}
user.DisplayName = Input.DisplayName;
user.FirstName = Input.FirstName;
user.LastName = Input.LastName;
user.BirthDate = Input.BirthDate;
user.Location = Input.LocationName;
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
var userId = await _userManager.GetUserIdAsync(user);
throw new InvalidOperationException($"به روز رسانی نمایه برای کاربر '{userId}' با خطا مواجه شد..");
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "نمایه به روز شد.";
return(RedirectToPage());
}
//Invalid Model
await LoadAsync(user);
return(Page());
}
public void Describe_with_leading_capital(int quantity, string adjective, string expected)
{
var describer = new Describer();
var item = new Item(quantity)
{
Name = "rock",
Adjective = adjective,
};
var desc = describer.Describe(item, DescMods.LeadingCapital);
Assert.That(desc, Is.EqualTo(expected));
}
private async Task ValidateEmail(
UserManager <TUser> manager,
TUser user,
List <IdentityError> errors)
{
var email = await manager.GetEmailAsync(user);
if (string.IsNullOrWhiteSpace(email))
{
errors.Add(Describer.InvalidEmail(email));
return;
}
}
public void Describe_with_quantity_and_indef_art(int quantity, string adjective, string expected)
{
var describer = new Describer();
var item = new Item(quantity)
{
Name = "rock",
Adjective = adjective,
};
var desc = describer.Describe(item, DescMods.Quantity | DescMods.Article);
Assert.That(desc, Is.EqualTo(expected));
}
public void Describe_without_options(int quantity, string adjective, string expected)
{
var describer = new Describer();
var item = new Item(quantity)
{
Name = "rock",
Adjective = adjective,
};
var desc = describer.Describe(item, DescMods.None);
Assert.That(desc, Is.EqualTo(expected));
}
private async Task ValidateUserName(
UserManager <TUser> manager,
TUser user,
ICollection <IdentityError> errors)
{
var userName = await manager.GetUserNameAsync(user);
if (string.IsNullOrWhiteSpace(userName))
{
errors.Add(Describer.InvalidUserName(userName));
return;
}
}
// Run the command
public override void Run(List <string> arguments)
{
// ARGS: strike/hit <nameOfObjectToStrike> with/using <nameOfObjectToUse> from <(l)eft/(r)ight>
// Make sure we are connected to a client
if (!attachedApplication.client.isConnected)
{
attachedApplication.output.PrintLine("$maNot $maconnected $mato $maany $maserver. $maMake $masure $mayour $maclient $mais $maconnected.");
return;
}
if (arguments.Count > 0)
{
// Create a new server command
Support.Networking.ServerCommands.ServerCommandStrike serverCommand = new Support.Networking.ServerCommands.ServerCommandStrike(attachedApplication.client.clientID);
// The index of the second argument
int indexOfSecondArgument = 0;
// The index of the third argument
int indexOfThirdArgument = 0;
// Get the name of the object to strike
string nameOfObjectToStrike = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, 0, new List <string>()
{
"with", "using"
}, ref indexOfSecondArgument));
// The name of the object to use
string nameOfObjectToUse = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, indexOfSecondArgument, new List <string>()
{
"from"
}, ref indexOfThirdArgument));
// The direction to strike
string directionToStrike = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, indexOfThirdArgument, new List <string>()
{
}));
// Make sure we aren't missing any arguments
if (nameOfObjectToStrike == "" || nameOfObjectToUse == "" || directionToStrike == "")
{
attachedApplication.output.PrintLine(Describer.ToColor("Usage: strike/hit <nameOfObjectToStrike> with/using <nameOfObjectToUse> from <(l)eft/(r)ight>", "$ma"));
return;
}
// Send the parsed arguments
serverCommand.arguments.Add(nameOfObjectToStrike);
serverCommand.arguments.Add(nameOfObjectToUse);
serverCommand.arguments.Add(directionToStrike);
// Send the request to the server
attachedApplication.client.SendServerCommand(serverCommand);
}
else
{
attachedApplication.output.PrintLine(Describer.ToColor("Usage: strike/hit <nameOfObjectToStrike> with/using <nameOfObjectToUse> from <(l)eft/(r)ight>", "$ma"));
}
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
if (!ModelState.IsValid)
{
await LoadSharedKeyAndQrCodeUriAsync(user);
return(Page());
}
// Strip spaces and hypens
var verificationCode = Input.Code.Replace(" ", string.Empty).Replace("-", string.Empty);
var is2faTokenValid = await _userManager.VerifyTwoFactorTokenAsync(
user, _userManager.Options.Tokens.AuthenticatorTokenProvider, verificationCode);
if (!is2faTokenValid)
{
ModelState.AddModelError("Input.Code", "کد فعال سازی نامعتبر است.");
await LoadSharedKeyAndQrCodeUriAsync(user);
return(Page());
}
await _userManager.SetTwoFactorEnabledAsync(user, true);
var userId = await _userManager.GetUserIdAsync(user);
_logger.LogInformation($"حساب کاربری با شناسه '{userId}' دارای احراز هویت فعال است.", userId);
StatusMessage = "نرم افزار احراز هویت شما فعال شد.";
if (await _userManager.CountRecoveryCodesAsync(user) == 0)
{
var recoveryCodes = await _userManager.GenerateNewTwoFactorRecoveryCodesAsync(user, 10);
RecoveryCodes = recoveryCodes.ToArray();
return(RedirectToPage("./ShowRecoveryCodes"));
}
else
{
return(RedirectToPage("./TwoFactorAuthentication"));
}
}
public override async Task <IdentityResult> ValidateAsync(UserManager <User> manager, User user)
{
List <IdentityError> errors = new List <IdentityError>();
Regex userNameRegex = new Regex(@"^[\p{L}\p{S}\p{N}\p{P}\p{Cs}]+( [\p{L}\p{S}\p{N}\p{P}\p{Cs}]+)*$", RegexOptions.Compiled);
if (!userNameRegex.IsMatch(user.UserName))
{
IdentityError invalidUserNameError = Describer.InvalidUserName(user.UserName);
invalidUserNameError.Description += " Username doesn't match the expected format.";
errors.Add(invalidUserNameError);
}
return(errors.Count > 0 ? IdentityResult.Failed(errors.ToArray()) : IdentityResult.Success);
}
public async Task <IActionResult> OnPost()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
await _signInManager.ForgetTwoFactorClientAsync();
StatusMessage = "مرورگر جاری فراموش شده است. زمان ورود مجدد از طریق این مرورگر مجدداً کد های بازیابی از شما درخواست می شوند.";
return(RedirectToPage());
}
public async Task <IActionResult> OnGet()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
if (!await _userManager.GetTwoFactorEnabledAsync(user))
{
throw new InvalidOperationException($"غیرفعال سازی احراز هویت دو مرحله ای برای کاربر یا شناسه '{_userManager.GetUserId(User)}' ممکن نبود. چرا که اینک احراز هویت دو مرحله ای برای ایشان فعال نیست.");
}
return(Page());
}
public async Task <IActionResult> OnGetAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
CurrentLogins = await _userManager.GetLoginsAsync(user);
OtherLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync())
.Where(auth => CurrentLogins.All(ul => auth.Name != ul.LoginProvider))
.ToList();
ShowRemoveButton = user.PasswordHash != null || CurrentLogins.Count > 1;
return(Page());
}
public async Task <IActionResult> OnGetAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
var hasPassword = await _userManager.HasPasswordAsync(user);
if (!hasPassword)
{
return(RedirectToPage("./SetPassword"));
}
return(Page());
}
public async Task <IActionResult> OnGet()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
HasAuthenticator = await _userManager.GetAuthenticatorKeyAsync(user) != null;
Is2faEnabled = await _userManager.GetTwoFactorEnabledAsync(user);
IsMachineRemembered = await _signInManager.IsTwoFactorClientRememberedAsync(user);
RecoveryCodesLeft = await _userManager.CountRecoveryCodesAsync(user);
return(Page());
}
public async Task <IActionResult> OnPostChangeEmailAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
var email = await _userManager.GetEmailAsync(user);
if (Input.NewEmail != email)
{
var userId = await _userManager.GetUserIdAsync(user);
var code = await _userManager.GenerateChangeEmailTokenAsync(user, Input.NewEmail);
var callbackUrl = Url.Page(
"/Account/ConfirmEmailChange",
pageHandler: null,
values: new { userId = userId, email = Input.NewEmail, code = code },
protocol: Request.Scheme);
await _emailSender.SendAsync(
from : WeblogApp.Helpers.EmailTypes.NoReply,
to : Input.NewEmail,
subject : "تایید رایانامه",
body : $"لطفاً حساب کاربری خود را با <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>کلیک روی نشانی</a> تایید کنید.",
isBodyHtml : true);
StatusMessage = "نشانی تاییدیه به رایانامه ارسال شد. لطفاً رایانامه خود را بررسی کنید.";
return(RedirectToPage());
}
StatusMessage = "رایانامه شما تغییر نکرد.";
return(RedirectToPage());
}
// Run the command
public override void Run(List <string> arguments)
{
// ARGS: dull <nameOfObject> with/using <nameOfTool>
// Make sure we are connected to a client
if (!attachedApplication.client.isConnected)
{
attachedApplication.output.PrintLine("$maNot $maconnected $mato $maany $maserver. $maMake $masure $mayour $maclient $mais $maconnected.");
return;
}
if (arguments.Count > 0)
{
// Create a new server command
Support.Networking.ServerCommands.ServerCommandDull serverCommand = new Support.Networking.ServerCommands.ServerCommandDull(attachedApplication.client.clientID);
// The index of the second argument
int indexOfSecondArgument = 0;
// Get the name of the object
string nameOfObject = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, 0, new List <string>()
{
"with", "using"
}, ref indexOfSecondArgument));
// The name of the tool we want to use
string nameOfTool = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, indexOfSecondArgument, new List <string>()
{
}));
// Make sure we have all the arguments
if (nameOfObject == "" || nameOfTool == "")
{
attachedApplication.output.PrintLine(Describer.ToColor("$ma", "dull/blunt <nameOfObject> with/using <nameOfTool>"));
return;
}
// Send the parsed arguments
serverCommand.arguments.Add(nameOfObject);
serverCommand.arguments.Add(nameOfTool);
// Send the request to the server
attachedApplication.client.SendServerCommand(serverCommand);
}
else
{
attachedApplication.output.PrintLine(Describer.ToColor("$ma", "dull/blunt <nameOfObject> with/using <nameOfTool>"));
}
}
// Run the command
public override void Run(List <string> arguments)
{
// ARGS: craft/make <nameOfCraftingRecipe> with/using <nameOfIngredient>
// Make sure we are connected to a client
if (!attachedApplication.client.isConnected)
{
attachedApplication.output.PrintLine("$maNot $maconnected $mato $maany $maserver. $maMake $masure $mayour $maclient $mais $maconnected.");
return;
}
if (arguments.Count > 0)
{
// Create a new server command
Support.Networking.ServerCommands.ServerCommandCraft serverCommand = new Support.Networking.ServerCommands.ServerCommandCraft(attachedApplication.client.clientID);
// The index of the second argument
int indexOfSecondArgument = 0;
// Get the crafting recipe name
string craftingRecipe = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, 0, new List <string>()
{
"with", "using", "from"
}, ref indexOfSecondArgument));
// The name of the ingredient to use
string ingredient = Parser.ScrubArticles(Parser.GetSubStringUpToWord(arguments, indexOfSecondArgument, new List <string>()
{
}));
// Make sure we aren't missing any arguments
if (craftingRecipe == "" || ingredient == "")
{
attachedApplication.output.PrintLine(Describer.ToColor("$ma", "Usage: craft/make <nameOfCraftingRecipe> with/using <nameOfIngredient>"));
return;
}
// Send the parsed arguments
serverCommand.arguments.Add(craftingRecipe);
serverCommand.arguments.Add(ingredient);
// Send the request to the server
attachedApplication.client.SendServerCommand(serverCommand);
}
else
{
attachedApplication.output.PrintLine(Describer.ToColor("$ma", "Usage: craft/make <nameOfCraftingRecipe> with/using <nameOfIngredient>"));
}
}
public async Task <IActionResult> OnGetAsync(string userId, string code)
{
if (userId == null || code == null)
{
return(RedirectToPage("/Index"));
}
var user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
code = Encoding.UTF8.GetString(WebEncoders.Base64UrlDecode(code));
var result = await _userManager.ConfirmEmailAsync(user, code);
StatusMessage = result.Succeeded ? "رایانامه شما با موفقیت تایید شد." : "در تایید رایانامه خطایی پیش آمد.";
return(Page());
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound(Describer.UnableToLoadUser(_userManager.GetUserId(User), Language.English)));
}
var disable2faResult = await _userManager.SetTwoFactorEnabledAsync(user, false);
if (!disable2faResult.Succeeded)
{
throw new InvalidOperationException($"مواجهه با خطای پیش بینی نشده در حین غیرفعال سازی احراز هویت دو مرحله ای برای کاربر با شناسه '{_userManager.GetUserId(User)}'.");
}
_logger.LogInformation($"احراز هویت دو مرحله ای برای کاربر با شناسه '{_userManager.GetUserId(User)}' غیر فعال است.");
StatusMessage = "احراز هویت دومرحله ای غیرفعال شد. شما میتوانید با تنظیم مجدد اقدام به فعال سازی دوباره کنید.";
return(RedirectToPage("./TwoFactorAuthentication"));
}
