private Message <TModel> Unprotect(string data) { var json = _protector.Unprotect(data); var message = ObjectSerializer.FromString <Message <TModel> >(json); return(message); }
public static async Task <T> ReadJsonAsync <T>( this HttpRequest request) { var body = await ReadAsync(request); return(ObjectSerializer.FromString <T>(body) !); }
public AuthenticationProperties Unprotect(string protectedText, string purpose) { // Decrypt the key and retrieve the data from the cache. var key = Protector.Unprotect(protectedText); var cacheKey = $"{CacheKeyPrefix}-{purpose}-{key}"; var json = Cache.GetString(cacheKey); return(ObjectSerializer.FromString <AuthenticationProperties>(json)); }
public void FromString_Returns_Default_When_Value_Is_NullOrEmpty( string value) { Assert.Null(ObjectSerializer.FromString <string>(value)); Assert.Null(ObjectSerializer.FromString <TestObject>(value)); Assert.Equal( 0, ObjectSerializer.FromString <int>(value)); }
private IEnumerable <string> DecodeList(string value) { if (value.IsPresent()) { var bytes = Base64Url.Decode(value); value = Encoding.UTF8.GetString(bytes); return(ObjectSerializer.FromString <string[]>(value)); } return(Enumerable.Empty <string>()); }
private string DecodeAnonumousId(string encodedId) { if (encodedId.IsPresent()) { var bytes = Base64Url.Decode(encodedId); encodedId = Encoding.UTF8.GetString(bytes); return(ObjectSerializer.FromString <string>(encodedId)); } return(null); }
/// <inheritdoc/> public async Task <Message <IDictionary <string, string[]> > > ReadAsync(string id) { var cacheKey = $"{CacheKeyPrefix}-{id}"; var json = await _distributedCache.GetStringAsync(cacheKey); if (json == null) { return(new Message <IDictionary <string, string[]> >(new Dictionary <string, string[]>())); } return(ObjectSerializer.FromString <Message <IDictionary <string, string[]> > >(json)); }
/// <inheritdoc/> public async Task <Message <NameValueCollection> > ReadAsync(string id) { var cacheKey = $"{CacheKeyPrefix}-{id}"; var json = await _distributedCache.GetStringAsync(cacheKey); if (json == null) { return(new Message <NameValueCollection>(new NameValueCollection())); } return(ObjectSerializer.FromString <Message <NameValueCollection> >(json)); }
/// <inheritdoc/> public virtual async Task <Message <IDictionary <string, string[]> > > ReadAsync(string id) { using var activity = Tracing.StoreActivitySource.StartActivity("DistributedCacheAuthorizationParametersMessageStore.Read"); var cacheKey = $"{CacheKeyPrefix}-{id}"; var json = await _distributedCache.GetStringAsync(cacheKey); if (json == null) { return(new Message <IDictionary <string, string[]> >(new Dictionary <string, string[]>())); } return(ObjectSerializer.FromString <Message <IDictionary <string, string[]> > >(json)); }
public async Task <PolicyResult> GetPolicyAsync(HttpContext context) { String accessToken = await context.GetTokenAsync("access_token"); if (accessToken.IsMissing()) { throw new ArgumentNullException(nameof(accessToken)); } HttpClient client = new HttpClient(); client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken); String content = await client.GetStringAsync($"{_options.Authority}/{Constants.ProtocolRoutePaths.Permission}?clientId={_options.ClientId}"); PolicyResult result = ObjectSerializer.FromString <PolicyResult>(content); return(result); }
public Task <Message <TModel> > ReadAsync(string value) { Message <TModel> result = null; if (!String.IsNullOrWhiteSpace(value)) { try { var bytes = Base64Url.Decode(value); bytes = _protector.Unprotect(bytes); var json = Encoding.UTF8.GetString(bytes); result = ObjectSerializer.FromString <Message <TModel> >(json); } catch (Exception ex) { _logger.LogError(ex, "Exception reading protected message"); } } return(Task.FromResult(result)); }
/// <summary> /// Unprotects the specified protected text. /// </summary> /// <param name="protectedText">The protected text.</param> /// <param name="purpose">The purpose.</param> /// <returns></returns> public AuthenticationProperties Unprotect(string protectedText, string purpose) { if (String.IsNullOrWhiteSpace(protectedText)) { return(null); } // Decrypt the key and retrieve the data from the cache. var key = Protector.Unprotect(protectedText); var cacheKey = $"{CacheKeyPrefix}-{_name}-{purpose}-{key}"; var json = Cache.GetString(cacheKey); if (json == null) { return(null); } var props = ObjectSerializer.FromString <AuthenticationProperties>(json); return(props); }
public void FromString_Returns_Expected_Object() { var expected = new TestObject { Property1 = "value", Property2 = "value", Property3 = 0, }; var actual = ObjectSerializer.FromString <TestObject>( "{\"property1\":\"value\",\"property2\":\"value\"}"); Assert.Equal( expected.Property1, actual.Property1); Assert.Equal( expected.Property2, actual.Property2); Assert.Equal( expected.Property3, actual.Property3); }
/// <inheritdoc /> public virtual Task <Message <TModel> > ReadAsync(string value) { using var activity = Tracing.StoreActivitySource.StartActivity("ProtectedDataMessageStore.Read"); Message <TModel> result = null; if (!String.IsNullOrWhiteSpace(value)) { try { var bytes = Base64Url.Decode(value); bytes = Protector.Unprotect(bytes); var json = Encoding.UTF8.GetString(bytes); result = ObjectSerializer.FromString <Message <TModel> >(json); } catch (Exception ex) { Logger.LogError(ex, "Exception reading protected message"); } } return(Task.FromResult(result)); }
private void loadText(string path) { var targetDirectory = Path.Combine(Path.GetDirectoryName(path), DataFolder); using (var directoryReader = new SafeDirectoryReader(targetDirectory)) { var indexPath = directoryReader.GetPath("index.yaml"); var indexRoot = TinyToken.Read(indexPath); var indexVersion = indexRoot.Value <int>("FormatVersion"); if (indexVersion > Version) { throw new InvalidOperationException("This project was saved with a more recent version, you need to update to open it"); } var userPath = directoryReader.GetPath("user.yaml"); if (File.Exists(userPath)) { var userRoot = TinyToken.Read(userPath); var userVersion = userRoot.Value <int>("FormatVersion"); if (userVersion > Version) { throw new InvalidOperationException("This project's user settings were saved with a more recent version, you need to update to open it"); } var savedBy = userRoot.Value <string>("Editor"); Debug.Print($"Project saved by {savedBy}"); OwnsOsb = userRoot.Value <bool>("OwnsOsb"); } MapsetPath = indexRoot.Value <string>("MapsetPath"); SelectBeatmap(indexRoot.Value <long>("BeatmapId"), indexRoot.Value <string>("BeatmapName")); ImportedAssemblies = indexRoot.Values <string>("Assemblies"); // Load effects var layerInserters = new Dictionary <string, Action>(); foreach (var effectPath in Directory.EnumerateFiles(directoryReader.Path, "effect.*.yaml", SearchOption.TopDirectoryOnly)) { var guidMatch = effectGuidRegex.Match(effectPath); if (!guidMatch.Success || guidMatch.Groups.Count < 2) { throw new InvalidDataException($"Could not parse effect Guid from '{effectPath}'"); } var effectRoot = TinyToken.Read(effectPath); var effectVersion = effectRoot.Value <int>("FormatVersion"); if (effectVersion > Version) { throw new InvalidOperationException("This project contains an effect that was saved with a more recent version, you need to update to open it"); } var effect = AddEffect(effectRoot.Value <string>("Script")); effect.Guid = Guid.Parse(guidMatch.Groups[1].Value); effect.Name = effectRoot.Value <string>("Name"); var configRoot = effectRoot.Value <TinyObject>("Config"); var fieldIndex = 0; foreach (var fieldProperty in configRoot) { var fieldRoot = fieldProperty.Value; var fieldTypeName = fieldRoot.Value <string>("Type"); var fieldContent = fieldRoot.Value <string>("Value"); var fieldValue = ObjectSerializer.FromString(fieldTypeName, fieldContent); var allowedValues = fieldRoot .Value <TinyObject>("AllowedValues")? .Select(p => new NamedValue { Name = p.Key, Value = ObjectSerializer.FromString(fieldTypeName, p.Value.Value <string>()), }) .ToArray(); effect.Config.UpdateField(fieldProperty.Key, fieldRoot.Value <string>("DisplayName") ?? fieldProperty.Key, fieldIndex++, fieldValue?.GetType(), fieldValue, allowedValues); } var layersRoot = effectRoot.Value <TinyObject>("Layers"); foreach (var layerProperty in layersRoot) { var layerEffect = effect; var layerGuid = layerProperty.Key; var layerRoot = layerProperty.Value; layerInserters.Add(layerGuid, () => layerEffect.AddPlaceholder(new EditorStoryboardLayer(layerRoot.Value <string>("Name"), layerEffect) { Guid = Guid.Parse(layerGuid), OsbLayer = layerRoot.Value <OsbLayer>("OsbLayer"), DiffSpecific = layerRoot.Value <bool>("DiffSpecific"), Visible = layerRoot.Value <bool>("Visible"), })); } } // Insert layers defined in the index var layersOrder = indexRoot.Values <string>("Layers"); if (layersOrder != null) { foreach (var layerGuid in layersOrder.Distinct()) { if (layerInserters.TryGetValue(layerGuid, out var insertLayer)) { insertLayer(); } } } // Insert all remaining layers foreach (var key in layersOrder == null ? layerInserters.Keys : layerInserters.Keys.Except(layersOrder)) { var insertLayer = layerInserters[key]; insertLayer(); } } }