/// <summary> Loads, displays, saves and returns an alias configuration. </summary> /// <remarks> Any changes to the alias list are saved even if the form is cancelled. </remarks> public static AliasConfiguration Execute() { AliasConfiguration configuration = AliasManager.LoadConfiguration(); Execute(configuration); return(configuration); }
/// <summary> /// Called when the message has been received, /// after it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnReceiving() { var extraData = ((IMessage)this).ExtraData; this.PreferredPolicies.Clear(); string[] preferredPolicies = this.preferredPoliciesString.Split(' '); foreach (string policy in preferredPolicies) { if (policy.Length > 0) { this.PreferredPolicies.Add(policy); } } this.PreferredAuthLevelTypes.Clear(); AliasManager authLevelAliases = PapeUtilities.FindIncomingAliases(extraData); string preferredAuthLevelAliases; if (extraData.TryGetValue(Constants.RequestParameters.PreferredAuthLevelTypes, out preferredAuthLevelAliases)) { foreach (string authLevelAlias in preferredAuthLevelAliases.Split(' ')) { if (authLevelAlias.Length == 0) { continue; } this.PreferredAuthLevelTypes.Add(authLevelAliases.ResolveAlias(authLevelAlias)); } } }
/// <summary> /// Called when the message is about to be transmitted, /// before it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnSending() { var fields = ((IMessage)this).ExtraData; fields.Clear(); List <string> requiredAliases = new List <string>(), optionalAliases = new List <string>(); AliasManager aliasManager = new AliasManager(); foreach (var att in this.attributes) { string alias = aliasManager.GetAlias(att.TypeUri); // define the alias<->typeUri mapping fields.Add("type." + alias, att.TypeUri); // set how many values the relying party wants max fields.Add("count." + alias, att.Count.ToString(CultureInfo.InvariantCulture)); if (att.IsRequired) { requiredAliases.Add(alias); } else { optionalAliases.Add(alias); } } // Set optional/required lists this.OptionalAliases = optionalAliases.Count > 0 ? string.Join(",", optionalAliases.ToArray()) : null; this.RequiredAliases = requiredAliases.Count > 0 ? string.Join(",", requiredAliases.ToArray()) : null; }
/// <summary> /// Serializes a set of attribute values to a dictionary of fields to send in the message. /// </summary> /// <param name="fields">The dictionary to fill with serialized attributes.</param> /// <param name="attributes">The attributes.</param> internal static void SerializeAttributes(IDictionary <string, string> fields, IEnumerable <AttributeValues> attributes) { Contract.Requires <ArgumentNullException>(fields != null); Contract.Requires <ArgumentNullException>(attributes != null); AliasManager aliasManager = new AliasManager(); foreach (var att in attributes) { string alias = aliasManager.GetAlias(att.TypeUri); fields.Add("type." + alias, att.TypeUri); if (att.Values == null) { continue; } if (att.Values.Count != 1) { fields.Add("count." + alias, att.Values.Count.ToString(CultureInfo.InvariantCulture)); for (int i = 0; i < att.Values.Count; i++) { fields.Add(string.Format(CultureInfo.InvariantCulture, "value.{0}.{1}", alias, i + 1), att.Values[i]); } } else { fields.Add("value." + alias, att.Values[0]); } } }
IDictionary <string, string> IExtensionRequest.Serialize(DotNetOpenId.RelyingParty.IAuthenticationRequest authenticationRequest) { var fields = new Dictionary <string, string>(); if (MaximumAuthenticationAge.HasValue) { fields.Add(Constants.RequestParameters.MaxAuthAge, MaximumAuthenticationAge.Value.TotalSeconds.ToString(CultureInfo.InvariantCulture)); } // Even if empty, this parameter is required as part of the request message. fields.Add(Constants.RequestParameters.PreferredAuthPolicies, SerializePolicies(PreferredPolicies)); if (PreferredAuthLevelTypes.Count > 0) { AliasManager authLevelAliases = new AliasManager(); authLevelAliases.AssignAliases(PreferredAuthLevelTypes, Constants.AuthenticationLevels.PreferredTypeUriToAliasMap); // Add a definition for each Auth Level Type alias. foreach (string alias in authLevelAliases.Aliases) { fields.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, authLevelAliases.ResolveAlias(alias)); } // Now use the aliases for those type URIs to list a preferred order. fields.Add(Constants.RequestParameters.PreferredAuthLevelTypes, SerializeAuthLevels(PreferredAuthLevelTypes, authLevelAliases)); } return(fields); }
IDictionary<string, string> IExtensionRequest.Serialize(RelyingParty.IAuthenticationRequest authenticationRequest) { var fields = new Dictionary<string, string> { { "mode", Mode }, }; if (UpdateUrl != null) fields.Add("update_url", UpdateUrl.AbsoluteUri); List<string> requiredAliases = new List<string>(), optionalAliases = new List<string>(); AliasManager aliasManager = new AliasManager(); foreach (var att in attributesRequested) { string alias = aliasManager.GetAlias(att.TypeUri); // define the alias<->typeUri mapping fields.Add("type." + alias, att.TypeUri); // set how many values the relying party wants max fields.Add("count." + alias, att.Count.ToString(CultureInfo.InvariantCulture)); if (att.IsRequired) requiredAliases.Add(alias); else optionalAliases.Add(alias); } // Set optional/required lists if (optionalAliases.Count > 0) fields.Add("if_available", string.Join(",", optionalAliases.ToArray())); if (requiredAliases.Count > 0) fields.Add("required", string.Join(",", requiredAliases.ToArray())); return fields; }
/// <summary> /// Initializes a new instance of the <see cref="SqlSelectStatement" /> class. /// </summary> public SqlSelectStatement( ) { WithClause = new SqlWithClause( ); AliasManager = new AliasManager( ); CurrentCte = new Stack <SqlCte>( ); References = new ReferenceManager(); }
/// <summary> /// Called when the message is about to be transmitted, /// before it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnSending() { var extraData = ((IMessage)this).ExtraData; extraData.Clear(); this.actualPoliciesString = SerializePolicies(this.ActualPolicies); if (this.AssuranceLevels.Count > 0) { AliasManager aliases = new AliasManager(); aliases.AssignAliases(this.AssuranceLevels.Keys, Constants.AssuranceLevels.PreferredTypeUriToAliasMap); // Add a definition for each Auth Level Type alias. foreach (string alias in aliases.Aliases) { extraData.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, aliases.ResolveAlias(alias)); } // Now use the aliases for those type URIs to list the individual values. foreach (var pair in this.AssuranceLevels) { extraData.Add(AuthLevelAliasPrefix + aliases.GetAlias(pair.Key), pair.Value); } } }
IDictionary <string, string> IExtensionResponse.Serialize(DotNetOpenId.Provider.IRequest authenticationRequest) { var fields = new Dictionary <string, string>(); fields.Add(Constants.ResponseParameters.AuthPolicies, SerializePolicies(ActualPolicies)); if (AuthenticationTimeUtc.HasValue) { fields.Add(Constants.ResponseParameters.AuthTime, AuthenticationTimeUtc.Value.ToUniversalTime().ToString(PermissibleDateTimeFormats[0], CultureInfo.InvariantCulture)); } if (AssuranceLevels.Count > 0) { AliasManager aliases = new AliasManager(); aliases.AssignAliases(AssuranceLevels.Keys, Constants.AuthenticationLevels.PreferredTypeUriToAliasMap); // Add a definition for each Auth Level Type alias. foreach (string alias in aliases.Aliases) { fields.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, aliases.ResolveAlias(alias)); } // Now use the aliases for those type URIs to list the individual values. foreach (var pair in AssuranceLevels) { fields.Add(Constants.ResponseParameters.AuthLevelAliasPrefix + aliases.GetAlias(pair.Key), pair.Value); } } return(fields); }
/// <summary> /// Called when the message has been received, /// after it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnReceiving() { var extraData = ((IMessage)this).ExtraData; this.ActualPolicies.Clear(); string[] actualPolicies = this.actualPoliciesString.Split(' '); foreach (string policy in actualPolicies) { if (policy.Length > 0 && policy != AuthenticationPolicies.None) { this.ActualPolicies.Add(policy); } } this.AssuranceLevels.Clear(); AliasManager authLevelAliases = PapeUtilities.FindIncomingAliases(extraData); foreach (string authLevelAlias in authLevelAliases.Aliases) { string authValue; if (extraData.TryGetValue(AuthLevelAliasPrefix + authLevelAlias, out authValue)) { string authLevelType = authLevelAliases.ResolveAlias(authLevelAlias); this.AssuranceLevels[authLevelType] = authValue; } } }
// the other way to do this, is to index addresses per alias when the item is aliased public Address GetAddress_(string text) { if (text.Length == Address.ENCODED_SIZE) { return(new Address(text)); } IAliased item; if (!AliasManager.TryGetByAlias(text, out item)) { return(null); } var declaration = item.GetObject <TxAddressDeclaration>(); if (declaration != null) { return(declaration.Address); } var wallet = item.GetObject <PrivateKeyNotWallet>(); if (wallet != null) { return(wallet.Address); } return(null); }
public Alias() { _aliasManager = new AliasManager() { FileName = Path.Combine(ShellHelper.GetApplicationDataDirectory(Program.APP_NAME), "alias.txt") }; _aliasManager.Load(); }
public Alias() { _aliasManager = new AliasManager { FileName = Path.Combine(ApplicationHelper.GetApplicationDataDirectory("cv4pve-botgram"), "alias.txt") }; _aliasManager.Load(); }
public ActionResult PrepareCheckOut() { OrderVM final = Check.GenerateOrderVM(Order); User user = registry.FindUserByName(System.Web.HttpContext.Current.User.Identity.Name); TempData["aliases"] = AliasManager.FindAliasesForUser(user.UserName); return(RedirectToAction("Index", "Alias")); }
public bool SetActiveKey(string alias) { if (!AliasManager.TryGetByAlias(alias, out Aliased <PrivateKeyNotWallet> wallet)) { return(false); } active = wallet; return(true); }
public SchemaBrowser() { InitializeComponent(); _searchBox = new TextBoxDelayHandler(tbSearch, 300); _searchBox.DelayedTextChanged += tbSearch_TextChanged; _aliasManager = new AliasManager(new Options().Folder); _diagramBuilder = new DbDiagramBuilder(); }
bool IExtensionResponse.Deserialize(IDictionary <string, string> fields, DotNetOpenId.RelyingParty.IAuthenticationResponse response, string typeUri) { if (fields == null) { return(false); } if (!fields.ContainsKey(Constants.ResponseParameters.AuthPolicies)) { return(false); } ActualPolicies.Clear(); string[] actualPolicies = fields[Constants.ResponseParameters.AuthPolicies].Split(' '); foreach (string policy in actualPolicies) { if (policy.Length > 0 && policy != AuthenticationPolicies.None) { ActualPolicies.Add(policy); } } AuthenticationTimeUtc = null; string authTime; if (fields.TryGetValue(Constants.ResponseParameters.AuthTime, out authTime)) { DateTime authDateTime; if (DateTime.TryParse(authTime, CultureInfo.InvariantCulture, DateTimeStyles.AdjustToUniversal, out authDateTime) && authDateTime.Kind == DateTimeKind.Utc) // may be unspecified per our option above { AuthenticationTimeUtc = authDateTime; } else { Logger.ErrorFormat("Invalid format for {0} parameter: {1}", Constants.ResponseParameters.AuthTime, authTime); } } AssuranceLevels.Clear(); AliasManager authLevelAliases = PolicyRequest.FindIncomingAliases(fields); foreach (string authLevelAlias in authLevelAliases.Aliases) { string authValue; if (fields.TryGetValue(Constants.ResponseParameters.AuthLevelAliasPrefix + authLevelAlias, out authValue)) { string authLevelType = authLevelAliases.ResolveAlias(authLevelAlias); AssuranceLevels[authLevelType] = authValue; } } return(true); }
private static void CreateCommandFromAlias(TextWriter output, CommandLineApplication parent, PveClient client, ClassApi classApiRoot, AliasManager aliasManager, bool onlyResult) { foreach (var item in aliasManager.Alias) { parent.Command(item.Names[0], cmd => { foreach (var name in item.Names) { cmd.AddName(name); } cmd.Description = item.Description; cmd.ShowInHelpText = false; cmd.ExtendedHelpText = Environment.NewLine + "Alias command: " + item.Command; //create argument foreach (var arg in StringHelper.GetArgumentTags(item.Command)) { cmd.Argument(arg, arg, false).IsRequired(); } cmd.OnExecute(() => { var title = item.Description; var command = item.Command; //replace value into argument foreach (var arg in cmd.Arguments) { title += $" {arg.Name}: {arg.Value}"; command = command.Replace(StringHelper.CreateArgumentTag(arg.Name), arg.Value); } if (!onlyResult) { output.WriteLine(title); output.WriteLine("Command: " + command); } ParseLine(output, command, client, classApiRoot, aliasManager, onlyResult); }); }); } }
public bool ImportPrivateKey(string label, PrivateKeyNotWallet key) { var aliased = AliasManager.SetAlias(label, key); var address = key.Address.Encoded; if (wallets.ContainsKey(label)) { return(false); } wallets.Add(address, aliased); AddressListener.Listen(key.Address); return(true); }
/// <summary> /// Deserializes attribute values from an incoming set of message data. /// </summary> /// <param name="fields">The data coming in with the message.</param> /// <returns>The attribute values found in the message.</returns> internal static IEnumerable <AttributeValues> DeserializeAttributes(IDictionary <string, string> fields) { AliasManager aliasManager = ParseAliases(fields); foreach (string alias in aliasManager.Aliases) { AttributeValues att = new AttributeValues(aliasManager.ResolveAlias(alias)); int count = 1; bool countSent = false; string countString; if (fields.TryGetValue("count." + alias, out countString)) { if (!int.TryParse(countString, out count) || count < 0) { Logger.OpenId.ErrorFormat("Failed to parse count.{0} value to a non-negative integer.", alias); continue; } countSent = true; } if (countSent) { for (int i = 1; i <= count; i++) { string value; if (fields.TryGetValue(string.Format(CultureInfo.InvariantCulture, "value.{0}.{1}", alias, i), out value)) { att.Values.Add(value); } else { Logger.OpenId.ErrorFormat("Missing value for attribute '{0}'.", att.TypeUri); continue; } } } else { string value; if (fields.TryGetValue("value." + alias, out value)) { att.Values.Add(value); } else { Logger.OpenId.ErrorFormat("Missing value for attribute '{0}'.", att.TypeUri); continue; } } yield return(att); } }
/// <summary> /// Helper method to create a new transient SQL table, not yet attached to anything. /// </summary> /// <param name="name">The physical SQL table name</param> /// <param name="aliasPrefix">A suggested table alias</param> /// <returns>The SQL table</returns> public SqlTable CreateTable(string name, string aliasPrefix) { // Note: name can be empty for aggregate table var table = new SqlTable { Name = name, TableAlias = AliasManager.CreateAlias(aliasPrefix), ParentQuery = this, References = FullStatement.References, AllowAccessToAllResources = FullStatement.AllowAccessToAllResources, DenyAccessToAllResources = FullStatement.DenyAccessToAllResources }; return(table); }
/// <summary> /// Looks at the incoming fields and figures out what the aliases and name spaces for auth level types are. /// </summary> /// <param name="fields">The incoming message data in which to discover TypeURIs and aliases.</param> /// <returns>The <see cref="AliasManager"/> initialized with the given data.</returns> internal static AliasManager FindIncomingAliases(IDictionary<string, string> fields) { AliasManager aliasManager = new AliasManager(); foreach (var pair in fields) { if (!pair.Key.StartsWith(Constants.AuthLevelNamespaceDeclarationPrefix, StringComparison.Ordinal)) { continue; } string alias = pair.Key.Substring(Constants.AuthLevelNamespaceDeclarationPrefix.Length); aliasManager.SetAlias(alias, pair.Value); } aliasManager.SetPreferredAliasesWhereNotSet(Constants.AssuranceLevels.PreferredTypeUriToAliasMap); return aliasManager; }
internal static void SerializeAttributes(Dictionary<string, string> fields, IEnumerable<AttributeValues> attributes) { Debug.Assert(fields != null && attributes != null); AliasManager aliasManager = new AliasManager(); foreach (var att in attributes) { string alias = aliasManager.GetAlias(att.TypeUri); fields.Add("type." + alias, att.TypeUri); if (att.Values == null) continue; if (att.Values.Count != 1) { fields.Add("count." + alias, att.Values.Count.ToString(CultureInfo.InvariantCulture)); for (int i = 0; i < att.Values.Count; i++) { fields.Add(string.Format(CultureInfo.InvariantCulture, "value.{0}.{1}", alias, i + 1), att.Values[i]); } } else { fields.Add("value." + alias, att.Values[0]); } } }
bool IExtensionRequest.Deserialize(IDictionary <string, string> fields, DotNetOpenId.Provider.IRequest request, string typeUri) { if (fields == null) { return(false); } if (!fields.ContainsKey(Constants.RequestParameters.PreferredAuthPolicies)) { return(false); } string maxAuthAge; MaximumAuthenticationAge = fields.TryGetValue(Constants.RequestParameters.MaxAuthAge, out maxAuthAge) ? TimeSpan.FromSeconds(double.Parse(maxAuthAge, CultureInfo.InvariantCulture)) : (TimeSpan?)null; PreferredPolicies.Clear(); string[] preferredPolicies = fields[Constants.RequestParameters.PreferredAuthPolicies].Split(' '); foreach (string policy in preferredPolicies) { if (policy.Length > 0) { PreferredPolicies.Add(policy); } } PreferredAuthLevelTypes.Clear(); AliasManager authLevelAliases = FindIncomingAliases(fields); string preferredAuthLevelAliases; if (fields.TryGetValue(Constants.RequestParameters.PreferredAuthLevelTypes, out preferredAuthLevelAliases)) { foreach (string authLevelAlias in preferredAuthLevelAliases.Split(' ')) { if (authLevelAlias.Length == 0) { continue; } PreferredAuthLevelTypes.Add(authLevelAliases.ResolveAlias(authLevelAlias)); } } return(true); }
public bool VerifyParams(NameValueCollection stringparam) { if (!String.IsNullOrEmpty(stringparam["ALIAS"])) { //HasUserAlias(stringparam["ALIAS"], stringparam["CN"]); if (!AliasManager.CheckifAliasExist(stringparam["ALIAS"])) { AliasManager.Add(AliasManager.Create( stringparam["ALIAS"], stringparam["CN"], stringparam["ED"], stringparam["CARDNO"] )); } } StringBuilder sbuilder = new StringBuilder(); string passphrase = "Thisisa16sha-out"; string shaout = ""; foreach (string key in stringparam.AllKeys.OrderBy(k => k)) { if (key != "SHASIGN") { sbuilder.Append(key.ToUpper() + "=" + stringparam[key] + passphrase); } else { shaout = stringparam[key]; } } if (shaout.Equals(Crypto.GetSHA256(sbuilder.ToString()))) { return(true); } else { return(false); } }
IDictionary <string, string> IExtensionRequest.Serialize(RelyingParty.IAuthenticationRequest authenticationRequest) { var fields = new Dictionary <string, string> { { "mode", Mode }, }; if (UpdateUrl != null) { fields.Add("update_url", UpdateUrl.AbsoluteUri); } List <string> requiredAliases = new List <string>(), optionalAliases = new List <string>(); AliasManager aliasManager = new AliasManager(); foreach (var att in attributesRequested) { string alias = aliasManager.GetAlias(att.TypeUri); // define the alias<->typeUri mapping fields.Add("type." + alias, att.TypeUri); // set how many values the relying party wants max fields.Add("count." + alias, att.Count.ToString(CultureInfo.InvariantCulture)); if (att.IsRequired) { requiredAliases.Add(alias); } else { optionalAliases.Add(alias); } } // Set optional/required lists if (optionalAliases.Count > 0) { fields.Add("if_available", string.Join(",", optionalAliases.ToArray())); } if (requiredAliases.Count > 0) { fields.Add("required", string.Join(",", requiredAliases.ToArray())); } return(fields); }
static AliasManager parseAliases(IDictionary <string, string> fields) { Debug.Assert(fields != null); AliasManager aliasManager = new AliasManager(); foreach (var pair in fields) { if (!pair.Key.StartsWith("type.", StringComparison.Ordinal)) { continue; } string alias = pair.Key.Substring(5); if (alias.IndexOfAny(new[] { '.', ',', ':' }) >= 0) { Logger.ErrorFormat("Illegal characters in alias name '{0}'.", alias); continue; } aliasManager.SetAlias(alias, pair.Value); } return(aliasManager); }
public bool ImportDeclaration(string alias, TxDeclaration declaration) { AliasManager.SetAlias(alias, declaration); if (declarations.ContainsKey(alias)) { return(false); } declarations.Add(alias, declaration); if (declaration is TxAddressDeclaration) { var address = ((TxAddressDeclaration)declaration).Address; AliasManager.SetAlias(address.Encoded, declaration); if (declarations.ContainsKey(address.Encoded)) { return(false); } declarations.Add(address.Encoded, declaration); AddressListener.Listen(address); } return(true); }
public ActionResult UseAlias() { Alias alias = new Alias(); if (String.IsNullOrEmpty(Request.Form["usealias"])) { TempData["selectedalias"] = new Alias() { isnew = true }; } else { if (Request.Form["alias"] == "") { return(View("CreateAlias")); } alias = AliasManager.FindAliasByName(Request.Form["alias"]); alias.isnew = false; TempData["selectedalias"] = alias; } return(RedirectToAction("CheckOut", "Products")); }
/// <summary> /// Reads through the attributes included in the response to discover /// the alias-TypeURI relationships. /// </summary> /// <param name="fields">The data included in the extension message.</param> /// <returns>The alias manager that provides lookup between aliases and type URIs.</returns> private static AliasManager ParseAliases(IDictionary <string, string> fields) { Contract.Requires <ArgumentNullException>(fields != null); AliasManager aliasManager = new AliasManager(); const string TypePrefix = "type."; foreach (var pair in fields) { if (!pair.Key.StartsWith(TypePrefix, StringComparison.Ordinal)) { continue; } string alias = pair.Key.Substring(TypePrefix.Length); if (alias.IndexOfAny(FetchRequest.IllegalAliasCharacters) >= 0) { Logger.OpenId.ErrorFormat("Illegal characters in alias name '{0}'.", alias); continue; } aliasManager.SetAlias(alias, pair.Value); } return(aliasManager); }
/// <summary> /// Called when the message is about to be transmitted, /// before it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnSending() { var extraData = ((IMessage)this).ExtraData; extraData.Clear(); this.preferredPoliciesString = SerializePolicies(this.PreferredPolicies); if (this.PreferredAuthLevelTypes.Count > 0) { AliasManager authLevelAliases = new AliasManager(); authLevelAliases.AssignAliases(this.PreferredAuthLevelTypes, Constants.AssuranceLevels.PreferredTypeUriToAliasMap); // Add a definition for each Auth Level Type alias. foreach (string alias in authLevelAliases.Aliases) { extraData.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, authLevelAliases.ResolveAlias(alias)); } // Now use the aliases for those type URIs to list a preferred order. extraData.Add(Constants.RequestParameters.PreferredAuthLevelTypes, SerializeAuthLevels(this.PreferredAuthLevelTypes, authLevelAliases)); } }
public static void Execute(AliasConfiguration configuration) { using (ServerConnectForm form = new ServerConnectForm()) { form.SetConfiguration(configuration); form.EnsureServerSelected(); DialogResult result = form.ShowDialog(); ServerAlias selected = form.SelectedAlias; if (selected != null) { selected.SessionInfo.UserID = form.UserIDTextBox.Text; } if (selected != null) { form.Configuration.DefaultAliasName = selected.Name; } else { form.Configuration.DefaultAliasName = String.Empty; } AliasManager.SaveConfiguration(form.Configuration); if (result != DialogResult.OK) { throw new AbortException(); } if (selected != null) { selected.SessionInfo.Password = form.PasswordTextBox.Text; } } }
/// <summary> /// Serializes a set of attribute values to a dictionary of fields to send in the message. /// </summary> /// <param name="fields">The dictionary to fill with serialized attributes.</param> /// <param name="attributes">The attributes.</param> internal static void SerializeAttributes(IDictionary<string, string> fields, IEnumerable<AttributeValues> attributes) { ErrorUtilities.VerifyArgumentNotNull(fields, "fields"); ErrorUtilities.VerifyArgumentNotNull(attributes, "attributes"); AliasManager aliasManager = new AliasManager(); foreach (var att in attributes) { string alias = aliasManager.GetAlias(att.TypeUri); fields.Add("type." + alias, att.TypeUri); if (att.Values == null) { continue; } if (att.Values.Count != 1) { fields.Add("count." + alias, att.Values.Count.ToString(CultureInfo.InvariantCulture)); for (int i = 0; i < att.Values.Count; i++) { fields.Add(string.Format(CultureInfo.InvariantCulture, "value.{0}.{1}", alias, i + 1), att.Values[i]); } } else { fields.Add("value." + alias, att.Values[0]); } } }
#region IExtensionResponse Members IDictionary<string, string> IExtensionResponse.Serialize(DotNetOpenId.Provider.IRequest authenticationRequest) { var fields = new Dictionary<string, string>(); fields.Add(Constants.ResponseParameters.AuthPolicies, SerializePolicies(ActualPolicies)); if (AuthenticationTimeUtc.HasValue) { fields.Add(Constants.ResponseParameters.AuthTime, AuthenticationTimeUtc.Value.ToUniversalTime().ToString(PermissibleDateTimeFormats[0], CultureInfo.InvariantCulture)); } if (AssuranceLevels.Count > 0) { AliasManager aliases = new AliasManager(); aliases.AssignAliases(AssuranceLevels.Keys, Constants.AuthenticationLevels.PreferredTypeUriToAliasMap); // Add a definition for each Auth Level Type alias. foreach (string alias in aliases.Aliases) { fields.Add(Constants.AuthLevelNamespaceDeclarationPrefix + alias, aliases.ResolveAlias(alias)); } // Now use the aliases for those type URIs to list the individual values. foreach (var pair in AssuranceLevels) { fields.Add(Constants.ResponseParameters.AuthLevelAliasPrefix + aliases.GetAlias(pair.Key), pair.Value); } }
/// <summary> /// Called when the message is about to be transmitted, /// before it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnSending() { var fields = ((IMessage)this).ExtraData; fields.Clear(); List<string> requiredAliases = new List<string>(), optionalAliases = new List<string>(); AliasManager aliasManager = new AliasManager(); foreach (var att in this.attributes) { string alias = aliasManager.GetAlias(att.TypeUri); // define the alias<->typeUri mapping fields.Add("type." + alias, att.TypeUri); // set how many values the relying party wants max fields.Add("count." + alias, att.Count.ToString(CultureInfo.InvariantCulture)); if (att.IsRequired) { requiredAliases.Add(alias); } else { optionalAliases.Add(alias); } } // Set optional/required lists this.OptionalAliases = optionalAliases.Count > 0 ? string.Join(",", optionalAliases.ToArray()) : null; this.RequiredAliases = requiredAliases.Count > 0 ? string.Join(",", requiredAliases.ToArray()) : null; }
/// <summary> /// Serializes the auth levels to a list of aliases. /// </summary> /// <param name="preferredAuthLevelTypes">The preferred auth level types.</param> /// <param name="aliases">The alias manager.</param> /// <returns>A space-delimited list of aliases.</returns> private static string SerializeAuthLevels(IList<string> preferredAuthLevelTypes, AliasManager aliases) { var aliasList = new List<string>(); foreach (string typeUri in preferredAuthLevelTypes) { aliasList.Add(aliases.GetAlias(typeUri)); } return PapeUtilities.ConcatenateListOfElements(aliasList); }
bool IExtensionRequest.Deserialize(IDictionary<string, string> fields, DotNetOpenId.Provider.IRequest request, string typeUri) { if (fields == null) return false; string mode; fields.TryGetValue("mode", out mode); if (mode != Mode) return false; string updateUrl; fields.TryGetValue("update_url", out updateUrl); Uri updateUri; if (Uri.TryCreate(updateUrl, UriKind.Absolute, out updateUri)) UpdateUrl = updateUri; string requiredAliasString, optionalAliasString; fields.TryGetValue("if_available", out optionalAliasString); fields.TryGetValue("required", out requiredAliasString); var requiredAliases = parseAliasList(requiredAliasString); var optionalAliases = parseAliasList(optionalAliasString); // if an alias shows up in both lists, an exception will result implicitly. var allAliases = new List<string>(requiredAliases.Count + optionalAliases.Count); allAliases.AddRange(requiredAliases); allAliases.AddRange(optionalAliases); if (allAliases.Count == 0) { Logger.Error("Attribute Exchange extension did not provide any aliases in the if_available or required lists."); return false; } AliasManager aliasManager = new AliasManager(); foreach (var alias in allAliases) { string attributeTypeUri; if (fields.TryGetValue("type." + alias, out attributeTypeUri)) { aliasManager.SetAlias(alias, attributeTypeUri); AttributeRequest att = new AttributeRequest { TypeUri = attributeTypeUri, IsRequired = requiredAliases.Contains(alias), }; string countString; if (fields.TryGetValue("count." + alias, out countString)) { if (countString == "unlimited") att.Count = int.MaxValue; else { int count; if (int.TryParse(countString, out count) && count > 0) { att.Count = count; } else { Logger.Error("count." + alias + " could not be parsed into a positive integer."); } } } else { att.Count = 1; } AddAttribute(att); } else { Logger.Error("Type URI definition of alias " + alias + " is missing."); } } return true; }
/// <summary> /// Called when the message has been received, /// after it passes through the channel binding elements. /// </summary> void IMessageWithEvents.OnReceiving() { var extraData = ((IMessage)this).ExtraData; var requiredAliases = ParseAliasList(this.RequiredAliases); var optionalAliases = ParseAliasList(this.OptionalAliases); // if an alias shows up in both lists, an exception will result implicitly. var allAliases = new List<string>(requiredAliases.Count + optionalAliases.Count); allAliases.AddRange(requiredAliases); allAliases.AddRange(optionalAliases); if (allAliases.Count == 0) { Logger.OpenId.Error("Attribute Exchange extension did not provide any aliases in the if_available or required lists."); return; } AliasManager aliasManager = new AliasManager(); foreach (var alias in allAliases) { string attributeTypeUri; if (extraData.TryGetValue("type." + alias, out attributeTypeUri)) { aliasManager.SetAlias(alias, attributeTypeUri); AttributeRequest att = new AttributeRequest { TypeUri = attributeTypeUri, IsRequired = requiredAliases.Contains(alias), }; string countString; if (extraData.TryGetValue("count." + alias, out countString)) { if (countString == "unlimited") { att.Count = int.MaxValue; } else { int count; if (int.TryParse(countString, out count) && count > 0) { att.Count = count; } else { Logger.OpenId.Error("count." + alias + " could not be parsed into a positive integer."); } } } else { att.Count = 1; } this.Attributes.Add(att); } else { Logger.OpenId.Error("Type URI definition of alias " + alias + " is missing."); } } }
/// <summary> /// Reads through the attributes included in the response to discover /// the alias-TypeURI relationships. /// </summary> /// <param name="fields">The data included in the extension message.</param> /// <returns>The alias manager that provides lookup between aliases and type URIs.</returns> private static AliasManager ParseAliases(IDictionary<string, string> fields) { Contract.Requires<ArgumentNullException>(fields != null); AliasManager aliasManager = new AliasManager(); const string TypePrefix = "type."; foreach (var pair in fields) { if (!pair.Key.StartsWith(TypePrefix, StringComparison.Ordinal)) { continue; } string alias = pair.Key.Substring(TypePrefix.Length); if (alias.IndexOfAny(FetchRequest.IllegalAliasCharacters) >= 0) { Logger.OpenId.ErrorFormat("Illegal characters in alias name '{0}'.", alias); continue; } aliasManager.SetAlias(alias, pair.Value); } return aliasManager; }
static AliasManager parseAliases(IDictionary<string, string> fields) { Debug.Assert(fields != null); AliasManager aliasManager = new AliasManager(); foreach (var pair in fields) { if (!pair.Key.StartsWith("type.", StringComparison.Ordinal)) continue; string alias = pair.Key.Substring(5); if (alias.IndexOfAny(new[] { '.', ',', ':' }) >= 0) { Logger.ErrorFormat("Illegal characters in alias name '{0}'.", alias); continue; } aliasManager.SetAlias(alias, pair.Value); } return aliasManager; }