public virtual async Task <IActionResult> OnPostAsync()
{
try
{
await AccountAppService.SendPasswordResetCodeAsync(
new SendPasswordResetCodeDto
{
Email = Email,
AppName = "MVC",
ReturnUrl = ReturnUrl,
ReturnUrlHash = ReturnUrlHash
}
);
return(RedirectToPage(
"./PasswordResetLinkSent",
new
{
returnUrl = ReturnUrl,
returnUrlHash = ReturnUrlHash
}));
}
catch (BusinessException e)
{
var message = GetLocalizeExceptionMessage(e);
MyAlerts.Warning(message, L["OperationFailed"]);
return(await OnGetAsync());
}
}
public virtual async Task <IActionResult> OnPostAsync()
{
try
{
ValidateModel();
await AccountAppService.ResetPasswordAsync(
new ResetPasswordDto
{
UserId = UserId,
ResetToken = ResetToken,
Password = Password
}
);
}
catch (Exception e)
{
var message = GetMessageFromException(e);
MyAlerts.Warning(message, L["OperationFailed"]);
return(await OnGetAsync());
}
//TODO: Try to automatically login!
return(RedirectToPage("./ResetPasswordConfirmation", new
{
returnUrl = ReturnUrl,
returnUrlHash = ReturnUrlHash
}));
}
//НАЧАЛО СКРИПТА WL - тестовая стратегия с двумя скользящими средними
protected override void Execute()
{
for (int bar = 20; bar < Bars.Count; bar++)
{
if (IsLastPositionActive)
{
if (Bars.Close[bar] < SMA.Value(bar, Bars.Low, 10))
{
SellAtLimit(bar + 1, LastActivePosition, Bars.Close[bar], "");
if (bar == Bars.Count - 1)
{
list_alerts.Add(MyAlerts.AlertAdd("sell", "limit", Bars.Close[bar], 0, "", "", bar, Bars));
}
}
}
else
{
if (Bars.Close[bar] > SMA.Value(bar, Bars.High, 20))
{
RiskStopLevel = Bars.Close[bar] * 0.9;
BuyAtLimit(bar + 1, Bars.Close[bar], "");
if (bar == Bars.Count - 1)
{
list_alerts.Add(MyAlerts.AlertAdd("buy", "limit", Bars.Close[bar], RiskStopLevel, "VP", "", bar, Bars));
}
}
}
}
}
public virtual async Task <IActionResult> OnGetExternalLoginCallbackAsync(string returnUrl = "",
string returnUrlHash = "", string remoteError = null)
{
if (remoteError != null)
{
Logger.LogWarning($"External login callback error: {remoteError}");
return(RedirectToPage("./Login"));
}
var loginInfo = await SignInManager.GetExternalLoginInfoAsync();
if (loginInfo == null)
{
Logger.LogWarning("External login info is not available");
return(RedirectToPage("./Login"));
}
var result = await SignInManager.ExternalLoginSignInAsync(
loginInfo.LoginProvider,
loginInfo.ProviderKey,
false,
true
);
if (!result.Succeeded)
{
await IdentitySecurityLogManager.SaveAsync(new IdentitySecurityLogContext
{
Identity = IdentitySecurityLogIdentityConsts.IdentityExternal,
Action = "Login" + result
});
}
if (result.IsLockedOut)
{
MyAlerts.Danger(L["UserLockedOutMessage"], L["OperationFailed"]);
return(await OnGetAsync());
}
if (result.Succeeded)
{
return(RedirectSafely(returnUrl, returnUrlHash));
}
return(RedirectToPage("./Register", new
{
IsExternalLogin = true,
UserName = loginInfo.Principal.FindFirstValue(ClaimTypes.Name),
Email = loginInfo.Principal.FindFirstValue(ClaimTypes.Email),
ReturnUrl = returnUrl,
ReturnUrlHash = returnUrlHash
}));
}
public virtual async Task <IActionResult> OnPostAsync()
{
try
{
await CheckSelfRegistrationAsync();
if (IsExternalLogin)
{
var externalLoginInfo = await SignInManager.GetExternalLoginInfoAsync();
if (externalLoginInfo == null)
{
Logger.LogWarning("External login info is not available");
return(RedirectToPage("./Login"));
}
await RegisterExternalUserAsync(externalLoginInfo, Input.EmailAddress);
}
else
{
await RegisterLocalUserAsync();
}
return(Redirect(ReturnUrl ?? "~/"));
}
catch (UserFriendlyException e)
{
var message = GetMessageFromException(e);
MyAlerts.Danger(message, L["OperationFailed"]);
}
catch (BusinessException e)
{
var message = GetMessageFromException(e);
MyAlerts.Warning(message, L["OperationFailed"]);
}
return(await OnGetAsync());
}
public virtual async Task <IActionResult> OnGetAsync(string userName = "", string email = "")
{
try
{
await CheckSelfRegistrationAsync();
}
catch (UserFriendlyException e)
{
var message = GetMessageFromException(e);
MyAlerts.Danger(message, L["OperationFailed"]);
ExternalProviderHelper.VisibleExternalProviders = new List <ExternalProviderModel>();
return(Page());
}
await ExternalProviderHelper.GetVisibleExternalProviders();
Input = new RegisterInputModel
{
UserName = userName,
EmailAddress = email
};
return(Page());
}
public virtual async Task <IActionResult> OnPostAsync()
{
if (!await SettingProvider.IsTrueAsync(AccountSettingNames.EnableLocalLogin))
{
MyAlerts.Danger(L["LocalLoginDisabledMessage"], L["OperationFailed"]);
return(await OnGetAsync());
}
try
{
ValidateModel();
}
catch (AbpValidationException e)
{
var message = GetMessageFromException(e);
MyAlerts.Warning(message, L["OperationFailed"]);
return(await OnGetAsync());
}
await ReplaceEmailToUsernameOfInputIfNeeds();
var result = await SignInManager.PasswordSignInAsync(
Input.UserNameOrEmailAddress,
Input.Password,
Input.RememberMe,
true
);
await IdentitySecurityLogManager.SaveAsync(new IdentitySecurityLogContext
{
Identity = IdentitySecurityLogIdentityConsts.Identity,
Action = result.ToIdentitySecurityLogAction(),
UserName = Input.UserNameOrEmailAddress
});
if (result.RequiresTwoFactor)
{
return(await TwoFactorLoginResultAsync());
}
if (result.IsLockedOut)
{
MyAlerts.Danger(L["UserLockedOutMessage"], L["OperationFailed"]);
return(await OnGetAsync());
}
if (result.IsNotAllowed)
{
MyAlerts.Danger(L["LoginIsNotAllowed"], L["OperationFailed"]);
return(await OnGetAsync());
}
if (!result.Succeeded)
{
MyAlerts.Warning(L["InvalidUserNameOrPassword"], L["OperationFailed"]);
return(await OnGetAsync());
}
//TODO: Find a way of getting user's id from the logged in user and do not query it again like that!
var user = await UserManager.FindByNameAsync(Input.UserNameOrEmailAddress) ??
await UserManager.FindByEmailAsync(Input.UserNameOrEmailAddress);
Debug.Assert(user != null, nameof(user) + " != null");
return(RedirectSafely(ReturnUrl, ReturnUrlHash));
}
