static SettingProvider()
{
Default = new SettingProvider()
{
Name = "Default Instance"
};
}
public void TryCreateNetworkUnderOtherNetworkTest()
{
var environmentFactory = EnvironmentFactoryFactory.Create();
var authenticationContext = Substitute.For <IAuthenticationContext>();
var userOperations = environmentFactory.ManagementEnvironment.MgmtUserOperations;
var companyOperations = environmentFactory.ManagementEnvironment.MgmtCompanyOperations;
var settingProvider = new SettingProvider(environmentFactory.ManagementEnvironment.MgmtSettingOperations);
var userService = new UserService(userOperations, authenticationContext, settingProvider, null);
var userId1 = userService.Register(new RegisterDto()
{
Name = "user", Email = EmailHelper.Generate(), Password = "******"
}, null);
var companyService = new CompanyService(companyOperations, authenticationContext, null, new CapabilityProvider(settingProvider));
authenticationContext.GetContextUser().Returns(userId1);
var companyId1 = companyService.Create("new company1");
var serviceOperations = environmentFactory.ManagementEnvironment.MgmtServiceOperations;
var serviceService = new ServiceService(serviceOperations, companyOperations, authenticationContext, null, new CapabilityProvider(settingProvider));
var serviceId1 = serviceService.Create(new ServiceDto {
CompanyId = companyId1, Name = "svc"
});
var companyId2 = companyService.Create("new company2");
var serviceId2 = serviceService.Create(new ServiceDto()
{
CompanyId = companyId2, Name = "svc"
});
var networkOperations = environmentFactory.ManagementEnvironment.MgmtNetworkOperations;
var networkService = new NetworkService(networkOperations, serviceOperations, companyOperations, authenticationContext, null);
var networkId2 = networkService.Create(new NetworkDto()
{
ServiceId = serviceId2, CompanyId = companyId2, Name = "svc"
});
var network = new NetworkDto()
{
ParentNetworkId = networkId2,
CompanyId = companyId1,
ServiceId = serviceId1,
Name = "test"
};
networkService.Create(network);
}
public void LoginFailed2Test()
{
var environmentFactory = EnvironmentFactoryFactory.Create();
var authenticationContext = Substitute.For <IAuthenticationContext>();
var settingProvider = new SettingProvider(environmentFactory.ManagementEnvironment.MgmtSettingOperations);
var userOperations = environmentFactory.ManagementEnvironment.MgmtUserOperations;
var userService = new UserService(userOperations, authenticationContext, settingProvider, null);
userService.Login("*****@*****.**", "password2");
}
public static void UpdateRefreshToken(Guid organizationId, string refreshToken)
{
if (!string.IsNullOrEmpty(refreshToken))
{
Setting setting = SettingProvider.GetSettingByShortName("RefreshToken");
if (setting != null)
{
setting.Value = refreshToken;
SettingProvider.UpdateSettingValue(setting, organizationId, null, null);
}
}
}
private static void PreRequestHandlerExecute(object sender, EventArgs e)
{
if (bool.Parse(SettingProvider.GetConfigSettingValue("EnableCompressContent")) == false)
{
return;
}
var app = (HttpApplication)sender;
HttpRequest request = app.Context.Request;
HttpResponse response = app.Context.Response;
//if (app.Context.CurrentHandler == null) return;
//if (!(app.Context.CurrentHandler is Page || app.Context.CurrentHandler.GetType().Name == "SyncSessionlessHandler") || app.Request["http_x_microsoftajax"] != null)
//{
// return;
//}
if (request.FilePath == "/" || request.FilePath.Contains(".aspx") || request.FilePath.Contains(".js") || request.FilePath.Contains(".css") || request.FilePath.Contains(".ashx") || request.FilePath.Contains(".tpl"))
{
if (request.RawUrl.Contains(".aspx") && request.RawUrl.Contains("TSM_HiddenField"))
{
return;
}
if (request.RawUrl.Contains(".js") && request.RawUrl.Contains(".axd"))
{
return;
}
if (!(request.Browser.IsBrowser("IE") && request.Browser.MajorVersion <= 6))
{
string acceptEncoding = request.Headers[HttpConstants.HttpAcceptEncoding];
if (!string.IsNullOrEmpty(acceptEncoding))
{
acceptEncoding = acceptEncoding.ToLower(CultureInfo.InvariantCulture);
if (acceptEncoding.Contains(HttpConstants.HttpContentEncodingGzip))
{
response.Filter = new HttpCompressStream(response.Filter, CompressionMode.Compress, HttpCompressStream.CompressionType.GZip);
response.AddHeader(HttpConstants.HttpContentEncoding, HttpConstants.HttpContentEncodingGzip);
}
else if (acceptEncoding.Contains(HttpConstants.HttpContentEncodingDeflate))
{
response.Filter = new HttpCompressStream(response.Filter, CompressionMode.Compress, HttpCompressStream.CompressionType.Deflate);
response.AddHeader(HttpConstants.HttpContentEncoding, HttpConstants.HttpContentEncodingDeflate);
}
}
}
else
{
response.Filter = new HttpCompressStream(response.Filter, CompressionMode.Compress, HttpCompressStream.CompressionType.None);
}
}
}
public TicketReviewDialog(SettingProvider settingProvider)
: base(nameof(TicketReviewDialog))
{
_settingProvider = settingProvider;
AddDialog(new WaterfallDialog(nameof(WaterfallDialog), new WaterfallStep[]
{
AskDoneStep,
AskPlanStep,
ProcessResultStep,
}));
InitialDialogId = nameof(WaterfallDialog);
}
static void Main(string[] args)
{
SettingProvider settingProvider = new SettingProvider();
GameLogic game = new GameLogic(
phraseProvider: new JsonPhraseProvider(string.Format("Resource/Lang{0}.json", settingProvider.GetGameSettings().Lang)),
inputAndOutput: new ConsoleProvider(),
getDoors: new DoorsNumberRandom(settingProvider),
doorsStorage: new StackStorageProvider(),
settingProvider: settingProvider);
game.StartGame();
}
public static SettingMessage AddScene(Scene scene)
{
var newScenes = new List <Scene>(Scenes);
newScenes.Add(scene);
var message = SettingProvider.Serialize(newScenes);
if (!message.IsError)
{
Scenes = newScenes;
}
return(message);
}
protected override void OnStart(string[] args)
{
try
{
string baseAddress = new SettingProvider().GetValue("BaseUrl");
webApp = WebApp.Start <Startup>(url: baseAddress);
}
catch (Exception e)
{
File.WriteAllText("C:/log.txt", e.Message);
}
}
public virtual async Task ChangeTwoFactorEnabledAsync(ChangeTwoFactorEnabledDto input)
{
if (!await SettingProvider.IsTrueAsync(IdentitySettingNames.TwoFactor.UsersCanChange))
{
throw new BusinessException(Volo.Abp.Identity.IdentityErrorCodes.CanNotChangeTwoFactor);
}
var user = await UserManager.GetByIdAsync(CurrentUser.GetId());
(await UserManager.SetTwoFactorEnabledWithAccountConfirmedAsync(user, input.Enabled)).CheckErrors();
await CurrentUnitOfWork.SaveChangesAsync();
}
public virtual async Task SendAsync(SmsMessage smsMessage)
{
var domain = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.Domain);
var action = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.ActionName);
var version = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.Version);
Check.NotNullOrWhiteSpace(domain, AliyunSmsSettingNames.Sms.Domain);
Check.NotNullOrWhiteSpace(action, AliyunSmsSettingNames.Sms.ActionName);
Check.NotNullOrWhiteSpace(version, AliyunSmsSettingNames.Sms.Version);
CommonRequest request = new CommonRequest
{
Method = MethodType.POST,
Domain = domain,
Action = action,
Version = version
};
await TryAddTemplateCodeAsync(request, smsMessage);
await TryAddSignNameAsync(request, smsMessage);
await TryAddSendPhoneAsync(request, smsMessage);
TryAddTemplateParam(request, smsMessage);
try
{
var client = await AcsClientFactory.CreateAsync();
CommonResponse response = client.GetCommonResponse(request);
var responseContent = Encoding.Default.GetString(response.HttpResponse.Content);
var aliyunResponse = JsonSerializer.Deserialize <AliyunSmsResponse>(responseContent);
if (!aliyunResponse.IsSuccess())
{
if (await SettingProvider.IsTrueAsync(AliyunSmsSettingNames.Sms.VisableErrorToClient))
{
throw new UserFriendlyException(aliyunResponse.Code, aliyunResponse.Message);
}
throw new AliyunSmsException(aliyunResponse.Code, $"Text message sending failed, code:{aliyunResponse.Code}, message:{aliyunResponse.Message}!");
}
}
catch (ServerException se)
{
throw new AliyunSmsException(se.ErrorCode, $"Sending text messages to aliyun server is abnormal,type: {se.ErrorType}, error: {se.ErrorMessage}");
}
catch (ClientException ce)
{
throw new AliyunSmsException(ce.ErrorCode, $"A client exception occurred in sending SMS messages,type: {ce.ErrorType}, error: {ce.ErrorMessage}");
}
}
[UnitOfWork] //TODO: Will be removed when we implement action filter
public virtual async Task <IActionResult> OnPostAsync(string action)
{
EnableLocalLogin = await SettingProvider.IsTrueAsync(AccountSettingNames.EnableLocalLogin);
ValidateModel();
await ReplaceEmailToUsernameOfInputIfNeeds();
var result = await SignInManager.PasswordSignInAsync(
LoginInput.UserNameOrEmailAddress,
LoginInput.Password,
LoginInput.RememberMe,
true
);
if (result.RequiresTwoFactor)
{
return(RedirectToPage("./SendSecurityCode", new
{
returnUrl = ReturnUrl,
returnUrlHash = ReturnUrlHash,
rememberMe = LoginInput.RememberMe
}));
}
if (result.IsLockedOut)
{
Alerts.Warning(L["UserLockedOutMessage"]);
return(Page());
}
if (result.IsNotAllowed)
{
Alerts.Warning(L["LoginIsNotAllowed"]);
return(Page());
}
if (!result.Succeeded)
{
Alerts.Danger(L["InvalidUserNameOrPassword"]);
return(Page());
}
//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(LoginInput.UserNameOrEmailAddress) ??
await UserManager.FindByEmailAsync(LoginInput.UserNameOrEmailAddress);
Debug.Assert(user != null, nameof(user) + " != null");
return(RedirectSafely(ReturnUrl, ReturnUrlHash));
}
public virtual async Task OnGetAsync()
{
ServerSide = await SettingProvider.GetAsync <bool>("EasyAbp.EShop.Plugins.Baskets.EnableServerSideBaskets") &&
await AuthorizationService.IsGrantedAsync(BasketsPermissions.BasketItem.Default);
if (!ServerSide)
{
return;
}
var dto = await _service.GetAsync(Id);
ViewModel = ObjectMapper.Map <BasketItemDto, EditBasketItemViewModel>(dto);
}
protected void rdRight_CheckedChanged(object sender, EventArgs e)
{
divSideBar.Attributes.Remove("style");
divSideBar.Attributes.Add("style", "float:right");
divSideBar.Attributes.Add("class", "sideBarRight");
SettingProvider sageSP = new SettingProvider();
sageSP.SaveSageSetting(SettingType.SiteAdmin.ToString(), SageFrameSettingKeys.AdminSidebarPosition, "right", GetUsername, GetPortalID.ToString());
Response.Redirect(Request.RawUrl);
divSideBar.Attributes.Remove("style");
divSideBar.Attributes.Add("style", "float:right");
divSideBar.Attributes.Add("class", "sideBarRight");
sageSP.SaveSageSetting(SettingType.SiteAdmin.ToString(), SageFrameSettingKeys.AdminSidebarPosition, "right", GetUsername, GetPortalID.ToString());
}
protected void Page_Load(object sender, EventArgs e)
{
CommonHelper.DisableBrowserCache();
Response.TrySkipIisCustomErrors = true;
Response.StatusCode = 500;
Response.Status = "500 Internal Server Error";
if (bool.Parse(SettingProvider.GetConfigSettingValue("EnableCompressContent")))
{
Response.Filter = new HttpCompressStream(Response.Filter, CompressionMode.Compress,
HttpCompressStream.CompressionType.GZip);
Response.AddHeader(HttpConstants.HttpContentEncoding, HttpConstants.HttpContentEncodingGzip);
}
}
protected void btnDisableDashboardhelp_Click(object sender, EventArgs e)
{
try
{
SettingProvider objSettingProvider = new SettingProvider();
objSettingProvider.SaveSageSetting(SettingType.SiteAdmin.ToString(), SageFrameSettingKeys.EnableDasboardHelp, "false", GetUsername, GetPortalID.ToString());
divDashboardHelp.Visible = false;
ShowMessage("", GetSageMessage("DashboardHelp", "Cancelled"), "", SageMessageType.Success);
}
catch (Exception exec)
{
ProcessException(exec);
}
}
private void UpdateValues(Guid organizationId, Guid?instanceId, Guid?groupId)
{
if (ValuesUpdating != null)
{
ValuesUpdating(this, new SettingCollectionUpdateValuesEventArgs(organizationId, instanceId, groupId));
}
SettingProvider.UpdateSettingsValues(this, organizationId, instanceId, groupId);
if (ValuesUpdated != null)
{
ValuesUpdated(this, new SettingCollectionUpdateValuesEventArgs(organizationId, instanceId, groupId));
}
}
public ProgramSettings(string programName, SettingProviderFactory settingProviderFactory, ConsoleWriter writer)
{
_writer = writer;
var appData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
var folder = Path.Combine(appData, companyName, programName);
_path = Path.Combine(folder, "settings.xml");
_settings = new List <Setting>();
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
_settingProvider = settingProviderFactory.GetProvider(_path, _settings);
}
private void BindPortalSetting()
{
Hashtable hst = new Hashtable();
SettingProvider sep = new SettingProvider();
DataTable dt = sep.GetSettingsByPortal(GetPortalID.ToString(), string.Empty); //GetSettingsByPortal();
if (dt != null && dt.Rows.Count > 0)
{
for (int i = 0; i < dt.Rows.Count; i++)
{
hst.Add(dt.Rows[i]["SettingKey"].ToString(), dt.Rows[i]["SettingValue"].ToString());
}
}
HttpContext.Current.Cache.Insert("SageSetting", hst);
}
protected override void OnViewLoaded(object view)
{
base.OnViewReady(view);
// load the saved window positions
_window = view as Window;
_window.Closing += windowClosing;
// SetPlacement will adjust the position if it's outside of the visible boundaries
//_window.SetPlacement(Properties.Settings.Default.MainWindowPlacement);
_window.SetPlacement(SettingProvider.GetWindowPosition());
notifyIcon = new NotifyIcon(_window);
if (_host.DebugLogging)
{
ShowLoggingEnabledNotification();
}
}
private void BinSitePortal()
{
try
{
SettingProvider spr = new SettingProvider();
ddlHostPortal.DataSource = spr.GetAllPortals();
ddlHostPortal.DataTextField = "Name";
ddlHostPortal.DataValueField = "PortalID";
ddlHostPortal.DataBind();
}
catch (Exception ex)
{
ProcessException(ex);
}
}
private async Task TryAddTemplateCodeAsync(CommonRequest request, SmsMessage smsMessage)
{
if (smsMessage.Properties.TryGetValue("TemplateCode", out object template) && template != null)
{
request.AddQueryParameters("TemplateCode", template.ToString());
smsMessage.Properties.Remove("TemplateCode");
}
else
{
var defaultTemplateCode = await SettingProvider.GetOrNullAsync(AliyunSmsSettingNames.Sms.DefaultTemplateCode);
Check.NotNullOrWhiteSpace(defaultTemplateCode, "TemplateCode");
request.AddQueryParameters("TemplateCode", defaultTemplateCode);
}
}
public TeamReviewDialog(IIssueTrackingIntegrationService issueTrackingIntegrationService, SettingProvider settingProvider)
: base(nameof(TeamReviewDialog))
{
_issueTrackingIntegrationService = issueTrackingIntegrationService;
_settingProvider = settingProvider;
AddDialog(new WaterfallDialog(nameof(WaterfallDialog), new WaterfallStep[]
{
Init,
SelectionStep,
LoopStep,
}));
InitialDialogId = nameof(WaterfallDialog);
}
public virtual async Task <IActionResult> OnGetAsync()
{
LoginInput = new LoginInputModel();
ExternalProviders = await GetExternalProviders();
EnableLocalLogin = await SettingProvider.IsTrueAsync(AccountSettingNames.EnableLocalLogin);
if (IsExternalLoginOnly)
{
return(await OnPostExternalLogin(ExternalProviders.First().AuthenticationScheme));
}
return(Page());
}
public virtual async Task BeforeSendAsync(string type, string receiver)
{
var exist = await CaptchaStore.FindAsync(type, receiver, CurrentTenant.Id);
if (exist == null)
{
return;
}
int expireSeconds = await SettingProvider.GetAsync(AbpCaptchaSettings.CaptchaFrequencyLimitSeconds, 60);
if (exist.CreationTime.AddSeconds(expireSeconds) > Clock.Now)//检查是否超过请求频率限制
{
throw new BusinessException(CaptchaErrorCodes.FrequencyLimit);
}
}
private static void Fill(ConfigurationDataSet dataSet, ActionElementCollection actions, Guid?parentActionId)
{
foreach (ActionElement action in actions)
{
ConfigurationDataSet.ActionRow actionRow = dataSet.Action.FindByActionId(action.Id);
if (actionRow != null)
{
if (!actionRow.BuiltIn)
{
actionRow = null;
}
}
if (actionRow == null)
{
actionRow = dataSet.Action.NewActionRow();
LoadActionAttributes(actionRow, action, parentActionId);
dataSet.Action.AddActionRow(actionRow);
}
FillAlternativeParents(dataSet.ActionsParentActions, action);
RoleProvider.FillRolesActions(dataSet, action);
int visibleChildSettingsCount = 0;
foreach (SettingElement s in action.Settings)
{
if (s.Visible)
{
visibleChildSettingsCount++;
}
}
if (visibleChildSettingsCount > 0)
{
if (string.IsNullOrEmpty(action.NavigateUrl))
{
actionRow.NavigateUrl = ResourceProvider.SettingsPageVirtualPath + "?actionid=" + actionRow.ActionId.ToString("N");
}
SettingProvider.Fill(dataSet.Setting, dataSet.SettingListsValues, action.Settings, null, actionRow.ActionId, GetActionSettingLevels(actionRow.AuthenticationRequired, actionRow.InstanceRequired));
dataSet.Setting.AcceptChanges();
dataSet.SettingListsValues.AcceptChanges();
}
Fill(dataSet, action.Actions, actionRow.ActionId);
}
}
/// <summary>
/// 验证手机号码
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
/// <remarks>
/// 用户传递手机号码及认证类型
/// 1、如果认证类型为注册：
/// 先查询是否存在此手机号的缓存验证码信息,如果存在,抛出不能重复发送验证码异常
/// 随机生成6位纯数字验证码,通过短信接口服务发送到用户手机,并缓存验证码,设定一个有效时长
///
/// 2、如果认证类型为登录：
/// 先查询是否存在此手机号的缓存验证码信息,如果存在,抛出不能重复发送验证码异常
/// 通过手机号查询用户信息,如果用户不存在,抛出手机号未注册异常
/// 调用PhoneNumberTokenProvider接口生成6位手机验证码,用途为 phone_verify
/// 发送手机验证码到用户手机,并缓存验证码,设定一个有效时长
///
/// 用户调用 IdentityServer4/connect/token 登录系统（需要引用LINGYUN.Abp.IdentityServer.SmsValidator模块）
/// 参数1:grant_type=phone_verify
/// 参数2:phone_number=手机号码
/// 参数3:phone_verify_code=手机验证码
/// 参数4:client_id=客户端标识
/// 参数5:client_secret=客户端密钥
/// </remarks>
public virtual async Task VerifyPhoneNumberAsync(VerifyDto input)
{
// TODO: 借用TOTP算法生成6位动态验证码
var verifyCodeExpiration = await SettingProvider.GetAsync <int>(AccountSettingNames.PhoneVerifyCodeExpiration);
var phoneVerifyCacheKey = NormalizeCacheKey(input.PhoneNumber);
var verifyCacheItem = await Cache.GetAsync(phoneVerifyCacheKey);
if (verifyCacheItem != null)
{
throw new UserFriendlyException(L["PhoneVerifyCodeNotRepeatSend", verifyCodeExpiration]);
}
verifyCacheItem = new AccountRegisterVerifyCacheItem
{
PhoneNumber = input.PhoneNumber,
};
switch (input.VerifyType)
{
case PhoneNumberVerifyType.Register:
var phoneVerifyCode = new Random().Next(100000, 999999);
verifyCacheItem.VerifyCode = phoneVerifyCode.ToString();
var templateCode = await SettingProvider.GetOrDefaultAsync(AccountSettingNames.SmsRegisterTemplateCode, ServiceProvider);
await SendPhoneVerifyMessageAsync(templateCode, input.PhoneNumber, phoneVerifyCode.ToString());
break;
case PhoneNumberVerifyType.Signin:
var phoneSigninCode = await SendSigninVerifyCodeAsync(input.PhoneNumber);
verifyCacheItem.VerifyCode = phoneSigninCode;
break;
case PhoneNumberVerifyType.ResetPassword:
var resetPasswordCode = new Random().Next(100000, 999999);
verifyCacheItem.VerifyCode = resetPasswordCode.ToString();
var resetPasswordToken = await SendResetPasswordVerifyCodeAsync(input.PhoneNumber, verifyCacheItem.VerifyCode);
verifyCacheItem.VerifyToken = resetPasswordToken;
break;
}
var cacheOptions = new DistributedCacheEntryOptions
{
AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(verifyCodeExpiration)
};
await Cache.SetAsync(phoneVerifyCacheKey, verifyCacheItem, cacheOptions);
}
public virtual async Task SendPhoneResetPasswordCodeAsync(SendPhoneResetPasswordCodeDto input)
{
/*
* 注解: 微软的重置密码方法通过 UserManager.GeneratePasswordResetTokenAsync 接口生成密码重置Token
* 而这个Token设计的意义就是用户通过链接来重置密码,所以不适合短信验证
* 某些企业是把链接生成一个短链发送短信的,不过这种方式不是很推荐,因为现在是真没几个人敢随便点短信链接的
*
* 此处设计方式为:
*
* step1: 例行检查是否重复发送,这一点是很有必要的
* step2: 通过已确认的手机号来查询用户,如果用户未确认手机号,那就不能发送,这一点也是很有必要的
* step3(重点): 通过 UserManager.GenerateTwoFactorTokenAsync 接口来生成二次认证码,这就相当于伪验证码,只是用于确认用户传递的验证码是否通过
* 比起自己生成随机数,这个验证码利用了TOTP算法,有时间限制的
* step4(重点): 用户传递验证码后,通过 UserManager.VerifyTwoFactorTokenAsync 接口来校验验证码
* 验证通过后,再利用 UserManager.GeneratePasswordResetTokenAsync 接口来生成真正的用于重置密码的Token
*/
var securityTokenCacheKey = SmsSecurityTokenCacheItem.CalculateCacheKey(input.PhoneNumber, "SmsVerifyCode");
var securityTokenCacheItem = await SecurityTokenCache.GetAsync(securityTokenCacheKey);
var interval = await SettingProvider.GetAsync(IdentitySettingNames.User.SmsRepetInterval, 1);
// 传递 isConfirmed 用户必须是已确认过手机号的
var user = await GetUserByPhoneNumberAsync(input.PhoneNumber, isConfirmed : true);
// 能查询到缓存就是重复发送
if (securityTokenCacheItem != null)
{
throw new UserFriendlyException(L["SendRepeatSmsVerifyCode", interval]);
}
var template = await SettingProvider.GetOrNullAsync(IdentitySettingNames.User.SmsResetPassword);
// 生成二次认证码
var code = await UserManager.GenerateTwoFactorTokenAsync(user, TokenOptions.DefaultPhoneProvider);
// 发送短信验证码
await SecurityCodeSender.SendPhoneConfirmedCodeAsync(input.PhoneNumber, code, template);
// 缓存这个手机号的记录,防重复
securityTokenCacheItem = new SmsSecurityTokenCacheItem(code, user.SecurityStamp);
await SecurityTokenCache
.SetAsync(securityTokenCacheKey, securityTokenCacheItem,
new DistributedCacheEntryOptions
{
AbsoluteExpiration = DateTimeOffset.Now.AddMinutes(interval)
});
}
public virtual async Task <IActionResult> OnGetAsync()
{
LoginInput = new LoginInputModel();
ExternalProviders = await GetExternalProviders();
EnableLocalLogin = await SettingProvider.IsTrueAsync(AccountSettingNames.EnableLocalLogin);
if (IsExternalLoginOnly)
{
//return await ExternalLogin(vm.ExternalLoginScheme, returnUrl);
throw new NotImplementedException();
}
return(Page());
}
/// <summary>
/// Resetsetting keys based on portal ID.
/// </summary>
/// <param name="PortalID">PortalID</param>
public void ResetSettingKeys(int PortalID)
{
SettingProvider sep = new SettingProvider();
Hashtable hst = new Hashtable();
DataTable dt = sep.GetSettingsByPortal(PortalID.ToString(), string.Empty);
if (dt != null && dt.Rows.Count > 0)
{
for (int i = 0; i < dt.Rows.Count; i++)
{
hst.Add(dt.Rows[i]["SettingKey"].ToString(), dt.Rows[i]["SettingValue"].ToString());
}
}
//need to be cleared when any key is chnaged
HttpRuntime.Cache.Insert(CacheKeys.SageSetting, hst);//
}
protected virtual async Task <string> SendResetPasswordVerifyCodeAsync(string phoneNumber, string phoneVerifyCode)
{
// 查找用户信息
var user = await GetUserByPhoneNumberAsync(phoneNumber);
// 获取登录验证码模板号
var templateCode = await SettingProvider.GetOrDefaultAsync(AccountSettingNames.SmsResetPasswordTemplateCode, ServiceProvider);
// 生成重置密码验证码
var phoneVerifyToken = await UserManager.GeneratePasswordResetTokenAsync(user);
// 发送短信验证码
await SendPhoneVerifyMessageAsync(templateCode, user.PhoneNumber, phoneVerifyCode);
return(phoneVerifyToken);
}
public override bool ValidateUser(string username, string password)
{
Member member = _context.Members.FirstOrDefault(m => m.UserName == username);
SettingProvider settings = new SettingProvider();
if (member != null)
{
var principalCtx = new PrincipalContext(
ContextType.ApplicationDirectory,
settings.GetSetting<string>("Auth_AdamLdapAddress"),
settings.GetSetting<string>("Auth_AdamAuthContainer"),
settings.GetSetting<string>("Auth_AdamLdapUserName"),
settings.GetSetting<string>("Auth_AdamLdapPassword")
);
return principalCtx.ValidateCredentials(username, password);
}
return false;
}
public FolderExplorerConfiguration(SettingProvider settingXml)
{
_settingXml = settingXml;
}
public FolderExplorerUserConfiguration(SettingProvider settingXml, Action<string> updateSetting)
: base(settingXml)
{
_updateSetting = updateSetting;
}
