public void Set(string key, object value) { IDictionary <string, object> temp = new Dictionary <string, object>(); if (SessionStorage.ContainsKey(SessionId)) {//当前session中已经存在 temp = SessionStorage[SessionId]; if (temp.ContainsKey(key)) { temp[key] = value; } else { temp.Add(key, value); } } else {//session中 没有当前盒子 temp.Add(key, value); SessionStorage.Add(SessionId, temp); } }
public async Task EnsureAuthenticatedAsync() { var sessionStorageContainsToken = await SessionStorage.ContainKeyAsync(TokenSessionItem); string authorizationCode = GetQueryParam("code"); var isAuthorizationCodeAvailable = authorizationCode != string.Empty; if (!sessionStorageContainsToken && !isAuthorizationCodeAvailable) { var authorizationQueryParameters = new Dictionary <string, string> { { "client_id", AuthConfig.ClientId }, { "response_type", "code" }, { "redirect_uri", NavigationManager.Uri }, { "scope", AuthConfig.Scope }, }; NavigationManager.NavigateTo($"{AuthConfig.AuthorizationEndpoint}{await authorizationQueryParameters.ToQueryStringAsync()}"); } else if (!sessionStorageContainsToken && isAuthorizationCodeAvailable) { var tokenParameters = new Dictionary <string, string> { { "grant_type", "authorization_code" }, { "code", authorizationCode }, { "client_id", AuthConfig.ClientId }, { "client_secret", AuthConfig.ClientSecret } }; HttpClient.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); HttpResponseMessage response = await HttpClient.PostAsync(AuthConfig.TokenEndpoint, new FormUrlEncodedContent(tokenParameters)); var token = await JsonSerializer.DeserializeAsync <Token>(await response.Content.ReadAsStreamAsync()); await SessionStorage.SetItemAsync(TokenSessionItem, token.AccessToken); } // TODO: here we could check if token is still valid (when sessionStorageContainsToken) and get new one otherwise }
private void RetrieveSessionStorage() { string sessionString = null; #if PCL lock (_lock) { IFolder rootFolder = FileSystem.Current.LocalStorage; if (ExistenceCheckResult.FileExists == rootFolder.CheckExistsAsync(_sessionStorageFileFullPath).Result) { IFile file = rootFolder.GetFileAsync(_sessionStorageFileFullPath).Result; sessionString = file.ReadAllTextAsync().Result; } } #elif BCL lock (_lock) { if (File.Exists(_sessionStorageFileFullPath)) { using (var sessionFile = new System.IO.StreamReader(_sessionStorageFileFullPath)) { sessionString = sessionFile.ReadToEnd(); sessionFile.Close(); } _logger.DebugFormat("Mobile Analytics retrieves session info: {0}", sessionString); } else { _logger.DebugFormat("Mobile Analytics session file does not exist."); } } #endif if (!string.IsNullOrEmpty(sessionString)) { _sessionStorage = JsonMapper.ToObject <SessionStorage>(sessionString); } }
public void NoSession() { SimpleSecurityWebServiceClient webServiceClient = new SimpleSecurityWebServiceClient("User"); const string session = "invalid"; const string url = "http://localhost/?amplaSession=" + session; context = SimpleHttpContext.Create(url); IAmplaUserService amplaUserService = new AmplaUserService(webServiceClient, new AmplaUserStore()); LoginAmplaSessionUsingQueryString loginAmplaSession = new LoginAmplaSessionUsingQueryString(context.Request, context.Response, amplaUserService, FormsAuthenticationService, SessionStorage); loginAmplaSession.Execute(); Assert.That(context.Request.Cookies, Is.Empty); Assert.That(context.Request.Url, Is.EqualTo(new Uri(url))); var ticket = FormsAuthenticationService.GetUserTicket(); Assert.That(ticket, Is.Null); Assert.That(SessionStorage.GetAmplaSession(), Is.Empty); }
public object BindModel(ControllerContext controllerContext, ModelBindingContext bindingContext) { SessionStorage storage = null; //get Storage from session if (controllerContext.HttpContext.Session != null) { storage = (SessionStorage)controllerContext.HttpContext.Session[SessionKey]; } //create the Storage if there wasn't one in the session data if (storage == null) { storage = new SessionStorage(); //save in session if (controllerContext.HttpContext.Session != null) { controllerContext.HttpContext.Session[SessionKey] = storage; } } return(storage); }
public override void OnExit(PostSharp.Aspects.MethodExecutionArgs args) { base.OnExit(args); bool isAuthenticated = HttpContext.Current.User.Identity.IsAuthenticated; if (!(args.ReturnValue is IQueryable) || !isAuthenticated) { return; } SessionStorage sessionStorage = new SessionStorage(HttpContext.Current.User.Identity.Name); string serviceName = args.Instance.GetType().FullName + "." + args.Method.Name; if (sessionStorage.DataPermission==null) return; if (sessionStorage.DataPermission.ContainsKey(serviceName)) { IQueryable query = (IQueryable)args.ReturnValue; string queryTxt = sessionStorage.DataPermission[serviceName]; foreach (string token in sessionStorage.UserSpecificValues.Keys) if (queryTxt.Contains(token)) queryTxt.Replace(token, sessionStorage.UserSpecificValues[token]); args.ReturnValue = query.Where(queryTxt); } }
public void Dont_Auth_Correct_User_With_Invalid_Captcha_3() { // Arrange LoginViewModel userData = new LoginViewModel { Login = "******", Password = "******" }; string storedPasswordHash = Convert.ToBase64String(HashPassword.HashPass(userData.Password.ToCharArray(), new byte[0])); IAuthProvider authProv = new FormsAuthProvider(userData.Login, storedPasswordHash, ""); AccountController target = new AccountController(authProv); SessionStorage storage = SessionStorage.Current; string captcha = "54asd#213_54WQExz"; storage.CaptchaCode = captcha; // Act ActionResult result = target.Login(userData, "#true", storage); // Assert Assert.IsInstanceOfType(result, typeof(ViewResult)); Assert.IsFalse(((ViewResult)result).ViewData.ModelState.IsValid); Assert.IsTrue(storage.UnsucLoginAttempts == 1); }
public BlazorContext(SessionStorage sessionStorage) { _sessionStorage = sessionStorage; }
public AccountController(SessionStorage sessionStorage) { _sessionStorage = sessionStorage; }
public Session(string appID, MobileAnalyticsManagerConfig maConfig) { _maConfig = maConfig; _appID = appID; #if BCL _sessionStorageFileFullPath = InternalSDKUtils.DetermineAppLocalStoragePath(appID + _sessionStorageFileName); #elif PCL _sessionStorageFileFullPath = System.IO.Path.Combine(PCLStorage.FileSystem.Current.LocalStorage.Path, appID + _sessionStorageFileName); #elif UNITY _sessionStorageFileFullPath = System.IO.Path.Combine(AmazonHookedPlatformInfo.Instance.PersistentDataPath, appID + _sessionStorageFileName); #endif _logger.InfoFormat("Initialize a new session. The session storage file is {0}.", _sessionStorageFileFullPath); _sessionStorage = new SessionStorage(); }
public SetSecretModel(SessionStorage ss) { _ss = ss; }
/// <inheritdoc /> public IOperationManager <TSessionState, TOperationState>?GetOperationManager(string sessionId) { return(SessionStorage.Get(sessionId)); }
protected Session() { This_ = this; State = SessionState.STARTING; Log.Main.Inform("Loading configuration from " + Config.DefaultStorageDir); Config.Reload(Config.DefaultStorageDir); ConfigurationDir = Dir + "\\" + Config.CONFIG_FOLDER_NAME; Restored = false; Storage = new SessionStorage(); DateTime old_start_time; string old_time_mark; SessionState old_state = Storage.ReadLastState(out old_start_time, out old_time_mark); switch (old_state) { case SessionState.NULL: break; case SessionState.STARTING: case SessionState.COMPLETED: case SessionState.FatalError: break; case SessionState.RESTORING: case SessionState.RUNNING: case SessionState.CLOSING: case SessionState.UNCOMPLETED: case SessionState.BROKEN: if (Settings.Engine.RestoreBrokenSession && !ProgramRoutines.IsParameterSet(CommandLineParameters.NOT_RESTORE_SESSION)) { if (LogMessage.AskYesNo("Previous session " + old_time_mark + " is not completed. Restore it?", true)) { StartTime = old_start_time; TimeMark = old_time_mark; Storage.WriteState(SessionState.RESTORING, new { restoring_time = RestoreTime, restoring_session_time_mark = get_time_mark(RestoreTime) }); Log.Main.Inform("Loading configuration from " + ConfigurationDir); Config.Reload(ConfigurationDir); Storage.RestoreSession(); Restored = true; } } break; default: throw new Exception("Unknown option: " + old_state); } if (!Restored) { if (old_state != SessionState.NULL) { string old_dir_new_path = Log.WorkDir + "\\Data" + "_" + old_time_mark + "_" + old_state; Log.Main.Write("The old session folder moved to " + old_dir_new_path); Storage.Close(); if(Directory.Exists(Dir)) Directory.Move(Dir, old_dir_new_path); PathRoutines.CreateDirectory(Dir); Storage = new SessionStorage(); } StartTime = Log.MainSession.CreatedTime;// DateTime.Now; TimeMark = get_time_mark(StartTime); Storage.WriteState(SessionState.STARTING, new { session_start_time = StartTime, session_time_mark = TimeMark }); read_input_file(); Config.CopyFiles(Dir); } Creating?.Invoke(); __Creating(); }
private void RetrieveSessionStorage() { string sessionString = null; Action action = () => { if (File.Exists(_sessionStorageFilePath)) { System.IO.StreamReader sessionFile = new System.IO.StreamReader(_sessionStorageFilePath); sessionString = sessionFile.ReadToEnd(); sessionFile.Close(); _logger.DebugFormat("Mobile Analytics retrieves session info: {0}", sessionString); } else { _logger.DebugFormat("Mobile Analytics session file does not exist."); } }; if (UnityInitializer.IsMainThread()) { action(); } else { ManualResetEvent e = new ManualResetEvent(false); UnityRequestQueue.Instance.ExecuteOnMainThread(() => { action(); e.Set(); }); e.WaitOne(); } if (!string.IsNullOrEmpty(sessionString)) _sessionStorage = JsonMapper.ToObject<SessionStorage>(sessionString); }
public AuthService(HttpClient httpClient, SessionStorage storage) { _storage = storage; }
public UserController(UserService userService, SessionStorage sessionStorage) { _userService = userService; _sessionStorage = sessionStorage; }
public CatChooseModel(SessionStorage ss, CategoriesContainer cc) { _ss = ss; _cc = cc; Categories = _cc.Categories; }
protected Session() { This_ = this; State = SessionState.STARTING; Config.Reload(); Dir = FileSystemRoutines.CreateDirectory(Log.RootDir + "\\Data"); Directory.SetLastWriteTime(Dir, DateTime.Now);//to avoid cleaning up ConfigFile = Dir + "\\" + ConfigFileName; Restored = false; Storage = new SessionStorage(); DateTime old_start_time; string old_time_mark; SessionState old_state = Storage.ReadLastState(out old_start_time, out old_time_mark); switch (old_state) { case SessionState.NULL: break; case SessionState.STARTING: case SessionState.COMPLETED: case SessionState.FATAL_ERROR: break; case SessionState.RESTORING: case SessionState.RUNNING: case SessionState.CLOSING: case SessionState.UNCOMPLETED: case SessionState.BROKEN: case SessionState.NONFATAL_ERROR: if (Settings.Engine.RestoreBrokenSession && !CommandLine.IsParameterSet(CommandLineParameters.NOT_RESTORE_SESSION)) { if (LogMessage.AskYesNo("Previous session " + old_time_mark + " is not completed. Restore it?", true)) { StartTime = old_start_time; TimeMark = old_time_mark; Storage.WriteState(SessionState.RESTORING, new { restoring_time = RestoreTime, restoring_session_time_mark = get_time_mark(RestoreTime) }); Log.Main.Inform("Loading configuration from " + ConfigFile); Config.Reload(ConfigFile); Storage.RestoreSession(); Restored = true; } } break; default: throw new Exception("Unknown option: " + old_state); } if (!Restored) { if (old_state != SessionState.NULL) { string old_dir_new_path = Log.RootDir + "\\Data" + "_" + old_time_mark + "_" + old_state; Log.Main.Write("The old session folder moved to " + old_dir_new_path); Storage.Close(); if (Directory.Exists(Dir)) { Directory.Move(Dir, old_dir_new_path); } FileSystemRoutines.CreateDirectory(Dir); Storage = new SessionStorage(); } StartTime = Log.Head.CreatedTime;// DateTime.Now; TimeMark = get_time_mark(StartTime); Storage.WriteState(SessionState.STARTING, new { session_start_time = StartTime, session_time_mark = TimeMark }); read_input_file(); Config.Save(ConfigFile); } Creating?.Invoke(); __Creating(); }
public E1Service(IConfiguration configuration, ILogger <E1Service> logger, IHttpClientFactory httpClientFactory, SessionStorage sessionStorage) : base(configuration["baseUrl"], logger, httpClientFactory.CreateClient()) { SessionStorage = sessionStorage; }
public JsonResult GetResults(string postId) { var db = new SessionStorage(HttpContext.Session); return(Json(db.GetResults(postId))); }
private void RetrieveSessionStorage() { string sessionString = null; #if PCL IFolder rootFolder = FileSystem.Current.LocalStorage; if (ExistenceCheckResult.FileExists == rootFolder.CheckExistsAsync(_sessionStorageFileFullPath).Result) { IFile file = rootFolder.GetFileAsync(_sessionStorageFileFullPath).Result; sessionString = file.ReadAllTextAsync().Result; } #elif BCL if (File.Exists(_sessionStorageFileFullPath)) { using (var sessionFile = new System.IO.StreamReader(_sessionStorageFileFullPath)) { sessionString = sessionFile.ReadToEnd(); sessionFile.Close(); } _logger.DebugFormat("Mobile Analytics retrieves session info: {0}", sessionString); } else { _logger.DebugFormat("Mobile Analytics session file does not exist."); } #endif if (!string.IsNullOrEmpty(sessionString)) { _sessionStorage = JsonMapper.ToObject<SessionStorage>(sessionString); } }
public Game(GameLogic gamelogic, SessionStorage session) { _gamelogic = gamelogic; _session = session; }
public achievementsModel(ILogger <achievementsModel> logger, SessionStorage <User> ss) { _logger = logger; _ss = ss; }
private async void UserLoggedIn(object sender, EventArgs e) { CurrentUser = await SessionStorage.GetItem <User>("currentUser"); StateHasChanged(); }
public BlazorStateMachineResolver(SessionStorage sessionStorage, IJSRuntime jsRuntime) : this(sessionStorage) { _jsRuntime = jsRuntime ?? throw new ArgumentException("The value cannot be null", nameof(jsRuntime)); }
public LoggedModel(SessionStorage <User> log) { _log = log; }
public IndexModel(SessionStorage ss) { _ss = ss; }
public TimeOutConsoleChatSession() { SessionStorage = new SessionStorage(); }
public IndexModel(ILogger <IndexModel> logger, SessionStorage <User> ss) { _logger = logger; _ss = ss; }
public async Task <PageResult <List <JobTraceEntity> > > Pager(int pageIndex = 1, int pageSize = 10) { Info ??= "0|"; Id = Info.Split('|')[0]; Name = Info.Split('|')[1]; var pager = new PageInput { PageSize = pageSize, PageIndex = pageIndex, Extens = new Dictionary <string, string> { { "TaskId", Id } } }; return(await Http.PostHttpAsync <PageResult <List <JobTraceEntity> >, PageInput>($"job/task/trace", pager, nodeName : await SessionStorage.GetItemAsync <string>("nodename"))); }
private void RetrieveSessionStorage() { string sessionString = null; #if PCL IFolder rootFolder = FileSystem.Current.LocalStorage; if (ExistenceCheckResult.FileExists == rootFolder.CheckExistsAsync(_sessionStorageFileFullPath).Result) { IFile file = rootFolder.GetFileAsync(_sessionStorageFileFullPath).Result; sessionString = file.ReadAllTextAsync().Result; } #elif BCL if (File.Exists(_sessionStorageFileFullPath)) { using (var sessionFile = new System.IO.StreamReader(_sessionStorageFileFullPath)) { sessionString = sessionFile.ReadToEnd(); sessionFile.Close(); } _logger.DebugFormat("Mobile Analytics retrieves session info: {0}", sessionString); } else { _logger.DebugFormat("Mobile Analytics session file does not exist."); } #elif UNITY Action action = () => { if (File.Exists(_sessionStorageFileFullPath)) { System.IO.StreamReader sessionFile = new System.IO.StreamReader(_sessionStorageFileFullPath); sessionString = sessionFile.ReadToEnd(); sessionFile.Close(); _logger.DebugFormat("Mobile Analytics retrieves session info: {0}", sessionString); } else { _logger.DebugFormat("Mobile Analytics session file does not exist."); } }; if (UnityInitializer.IsMainThread()) { action(); } else { ManualResetEvent e = new ManualResetEvent(false); UnityRequestQueue.Instance.ExecuteOnMainThread(() => { action(); e.Set(); }); e.WaitOne(); } #endif if (!string.IsNullOrEmpty(sessionString)) { _sessionStorage = JsonMapper.ToObject<SessionStorage>(sessionString); } }
public BlazorStateMachineResolver(SessionStorage sessionStorage) { _sessionStorage = sessionStorage ?? throw new ArgumentException("The value cannot be null", nameof(sessionStorage)); }
private void RetrieveSessionStorage() { string sessionString = null; #if PCL IFolder rootFolder = FileSystem.Current.LocalStorage; if (ExistenceCheckResult.FileExists == rootFolder.CheckExistsAsync(_sessionStorageFileFullPath).Result) { IFile file = rootFolder.GetFileAsync(_sessionStorageFileFullPath).Result; sessionString = file.ReadAllTextAsync().Result; } #elif BCL if (File.Exists(_sessionStorageFileFullPath)) { using (var sessionFile = new System.IO.StreamReader(_sessionStorageFileFullPath)) { sessionString = sessionFile.ReadToEnd(); sessionFile.Close(); } _logger.DebugFormat("Mobile Analytics retrieves session info: {0}", sessionString); } else { _logger.DebugFormat("Mobile Analytics session file does not exist."); } #elif UNITY Action action = () => { if (File.Exists(_sessionStorageFileFullPath)) { System.IO.StreamReader sessionFile = new System.IO.StreamReader(_sessionStorageFileFullPath); sessionString = sessionFile.ReadToEnd(); sessionFile.Close(); _logger.DebugFormat("Mobile Analytics retrieves session info: {0}", sessionString); } else { _logger.DebugFormat("Mobile Analytics session file does not exist."); } }; if (UnityInitializer.IsMainThread()) { action(); } else { ManualResetEvent e = new ManualResetEvent(false); UnityRequestQueue.Instance.ExecuteOnMainThread(() => { action(); e.Set(); }); e.WaitOne(); } #endif if (!string.IsNullOrEmpty(sessionString)) { _sessionStorage = JsonMapper.ToObject <SessionStorage>(sessionString); } }
private bool ValidateSessionExpiration(SessionStorage session) => session.CreatedAt >= DateTime.Now.AddHours(-1 * Constants.SessionExpirationHour);
private async Task SaveCurrentUser(LoginResponse loginResponse) { var itemKey = "currentUser"; var itemValue = loginResponse.User; await SessionStorage.SetItem(itemKey, itemValue); }
public IndexModel(SessionStorage <User> log) { _log = log; }
private async Task SaveLoginToken(LoginResponse loginResponse) { var itemKey = "token"; var itemValue = loginResponse.Token; await SessionStorage.SetItem(itemKey, itemValue); }
public ActionResult PassReminder(PassReminderViewModel model, string returnUrl, SessionStorage storage) { ValidateCaptcha(model.Captcha, storage.CaptchaCode); if (ModelState.IsValid) { if (authProvider.IsEmailExists(model.Email)) { storage.UnsucLoginAttempts = 0; storage.CaptchaCode = null; Task.Factory.StartNew(() => { // Блокируем общий для главного и фонового потока ресурс // deadlock не ожидается, потому как пока это единственный монитор // + выполниться этот процесс должен оч. быстро. lock (BlogSettings.Current) { string url = ""; if (Request != null) // при юнит-тестировании пропускаем этот блок { url = Request.Url.Authority + Url.Action("ConfirmNewPass"); } authProvider.RemindPass(model.Email, url); } }); // Перенаправляем пользователя с сообщением об отправлении письма (almost POST/Redirect/GET pattern) // и продолжим обработку запроса (отправку письма) в отдельном потоке (чуть выше) string redirectUrl = "mock"; if (Url != null) // т.к. объект Url == null при юнит-тестировании { redirectUrl = Url.Action("PassReminder", new { email = model.Email, returnUrl = returnUrl }); } TempData["msgSended"] = true; return(Redirect(redirectUrl)); } else { storage.UnsucLoginAttempts++; ModelState.AddModelError("email", "Указанный email-адрес не зарегистрирован"); return(View(model)); } } else { storage.UnsucLoginAttempts++; return(View(model)); } }
public Session(string appID, MobileAnalyticsManagerConfig maConfig) { _maConfig = maConfig; _appId = appID; #if BCL _sessionStorageFileName = InternalSDKUtils.DetermineAppLocalStoragePath(appID + _sessionStorageFileName); #elif PCL _sessionStorageFileFullPath = System.IO.Path.Combine(PCLStorage.FileSystem.Current.LocalStorage.Path, appID + _sessionStorageFileName); #endif _sessionStorage = new SessionStorage(); }