public void StoreAssociation(AssociationRelyingPartyType distinguishingFactor, Association assoc) {
var assocRow = dataSet.Association.NewAssociationRow();
assocRow.DistinguishingFactor = distinguishingFactor.ToString();
assocRow.Handle = assoc.Handle;
assocRow.Expires = assoc.Expires.ToLocalTime();
assocRow.PrivateData = assoc.SerializePrivateData();
dataSet.Association.AddAssociationRow(assocRow);
}
public void StoreAssociation(Uri distinguishingFactor, Association assoc) {
var assocRow = dataSet.Association.NewAssociationRow();
assocRow.DistinguishingFactor = distinguishingFactor.AbsoluteUri;
assocRow.Handle = assoc.Handle;
assocRow.Expires = assoc.Expires.ToLocalTime();
assocRow.PrivateData = assoc.SerializePrivateData();
dataSet.Association.AddAssociationRow(assocRow);
}
/// <summary>
/// Stores an <see cref="Association"/> in the collection.
/// </summary>
/// <param name="association">The association to add to the collection.</param>
public void Set(Association association) {
Contract.Requires<ArgumentNullException>(association != null);
Contract.Ensures(this.Get(association.Handle) == association);
lock (this.associations) {
this.associations.Remove(association.Handle); // just in case one already exists.
this.associations.Add(association);
}
Contract.Assume(this.Get(association.Handle) == association);
}
public void StoreAssociation(AssociationRelyingPartyType distinguishingFactor, Association association)
{
var keyWithoutHandle = "assoc-" + distinguishingFactor.ToString();
var keyWithHandle = keyWithoutHandle + "-" + association.Handle;
var expireIn = association.Expires - Current.Now;
var @private = association.SerializePrivateData();
var newRecord = new Wrapper
{
Expires = association.Expires,
PrivateData = @private,
Handle = association.Handle
};
Current.AddToCache(keyWithoutHandle, newRecord, expireIn);
Current.AddToCache(keyWithHandle, newRecord, expireIn);
}
/// <summary>
/// Forces storage of an association in an RP's association store.
/// </summary>
/// <param name="relyingParty">The relying party.</param>
/// <param name="providerEndpoint">The provider endpoint.</param>
/// <param name="association">The association.</param>
internal static void StoreAssociation(OpenIdRelyingParty relyingParty, Uri providerEndpoint, Association association) {
// Only store the association if the RP is not in stateless mode.
if (relyingParty.AssociationManager.AssociationStoreTestHook != null) {
relyingParty.AssociationManager.AssociationStoreTestHook.StoreAssociation(providerEndpoint, association);
}
}
/// <summary>
/// Forces storage of an association in an RP's association store.
/// </summary>
/// <param name="relyingParty">The relying party.</param>
/// <param name="providerEndpoint">The provider endpoint.</param>
/// <param name="association">The association.</param>
internal static void StoreAssociation(OpenIdRelyingParty relyingParty, Uri providerEndpoint, Association association) {
var associationManagerAccessor = AssociationManager_Accessor.AttachShadow(relyingParty.AssociationManager);
// Only store the association if the RP is not in stateless mode.
if (associationManagerAccessor.associationStore != null) {
associationManagerAccessor.associationStore.StoreAssociation(providerEndpoint, association);
}
}
/// <summary>
/// Saves an <see cref="Association"/> for later recall.
/// </summary>
/// <param name="distinguishingFactor">The Uri (for relying parties) or Smart/Dumb (for providers).</param>
/// <param name="association">The association to store.</param>
/// <remarks>
/// TODO: what should implementations do on association handle conflict?
/// </remarks>
public void StoreAssociation(Uri distinguishingFactor, Association association)
{
using (var dataContext = new TransactedDatabaseEntities(System.Data.IsolationLevel.ReadCommitted))
{
var sharedAssociation = new OpenIdAssociation
{
DistinguishingFactor = distinguishingFactor.AbsoluteUri,
AssociationHandle = association.Handle,
ExpirationUtc = association.Expires,
PrivateData = association.SerializePrivateData(),
};
dataContext.AddToOpenIdAssociations(sharedAssociation);
}
}
/// <summary>
/// Determines whether a given association fits the security requirements.
/// </summary>
/// <param name="association">The association to check.</param>
/// <returns>
/// <c>true</c> if the association is permitted given the security requirements; otherwise, <c>false</c>.
/// </returns>
internal bool IsAssociationInPermittedRange(Association association)
{
ErrorUtilities.VerifyArgumentNotNull(association, "association");
return association.HashBitLength >= this.MinimumHashBitLength && association.HashBitLength <= this.MaximumHashBitLength;
}
/// <summary>
/// Determines whether a given association fits the security requirements.
/// </summary>
/// <param name="association">The association to check.</param>
/// <returns>
/// <c>true</c> if the association is permitted given the security requirements; otherwise, <c>false</c>.
/// </returns>
internal bool IsAssociationInPermittedRange(Association association) {
Requires.NotNull(association, "association");
return association.HashBitLength >= this.MinimumHashBitLength && association.HashBitLength <= this.MaximumHashBitLength;
}
/// <summary>
/// Stores an <see cref="Association"/> in the collection.
/// </summary>
/// <param name="association">The association to add to the collection.</param>
public void Set(Association association)
{
ErrorUtilities.VerifyArgumentNotNull(association, "association");
lock (this.associations) {
this.associations.Remove(association.Handle); // just in case one already exists.
this.associations.Add(association);
}
}
/// <summary>
/// Determines whether a given association fits the security requirements.
/// </summary>
/// <param name="association">The association to check.</param>
/// <returns>
/// <c>true</c> if the association is permitted given the security requirements; otherwise, <c>false</c>.
/// </returns>
internal bool IsAssociationInPermittedRange(Association association)
{
Contract.Requires <ArgumentNullException>(association != null);
return(association.HashBitLength >= this.MinimumHashBitLength && association.HashBitLength <= this.MaximumHashBitLength);
}
