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();
}
