/// <summary>
/// Stores a given nonce and timestamp.
/// </summary>
/// <param name="context">The context, or namespace, within which the
/// <paramref name="nonce"/> must be unique.
/// The context SHOULD be treated as case-sensitive.
/// The value will never be <c>null</c> but may be the empty string.</param>
/// <param name="nonce">A series of random characters.</param>
/// <param name="timestampUtc">The UTC timestamp that together with the nonce string make it unique
/// within the given <paramref name="context"/>.
/// The timestamp may also be used by the data store to clear out old nonces.</param>
/// <returns>
/// True if the context+nonce+timestamp (combination) was not previously in the database.
/// False if the nonce was stored previously with the same timestamp and context.
/// </returns>
/// <remarks>
/// The nonce must be stored for no less than the maximum time window a message may
/// be processed within before being discarded as an expired message.
/// This maximum message age can be looked up via the
/// <see cref="DotNetOpenAuth.Configuration.MessagingElement.MaximumMessageLifetime"/>
/// property, accessible via the <see cref="Configuration"/>
/// property.
/// </remarks>
public bool StoreNonce(string context, string nonce, DateTime timestampUtc)
{
var db = new OAuthEntities();
db.oauth_nonce.AddObject(new oauth_nonce() { Context = context, Code = nonce, Timestamp = timestampUtc });
try
{
db.SaveChanges();
return true;
}
catch (SqlException)
{
return false;
}
}
public void StoreKey(string bucket, string handle, CryptoKey key)
{
var keyRow = new oauth_symmetriccryptokey()
{
Bucket = bucket,
Handle = handle,
Secret = key.Key,
ExpiresUtc = key.ExpiresUtc,
};
var db = new OAuthEntities();
db.oauth_symmetriccryptokey.AddObject(keyRow);
db.SaveChanges();
}
public ActionResult AuthorizeResponse(bool isApproved)
{
var pendingRequest = this.authorizationServer.ReadAuthorizationRequest();
if (pendingRequest == null)
{
throw new HttpException((int)HttpStatusCode.BadRequest, "Missing authorization request.");
}
IDirectedProtocolMessage response;
if (isApproved)
{
// The authorization we file in our database lasts until the user explicitly revokes it.
// You can cause the authorization to expire by setting the ExpirationDateUTC
// property in the below created ClientAuthorization.
var db = new OAuthEntities();
var client = db.oauth_client.First(c => c.ClientIdentifier == pendingRequest.ClientIdentifier);
var username = "******";//HttpContext.User.Identity.Name;
var user = db.sys_user.FirstOrDefault(c => c.Username == username);
db.oauth_clientauthorization.AddObject(new oauth_clientauthorization
{
UserId = user.ID,
ClientId = client.ClientId,
CreatedOnUtc = DateTime.UtcNow,
Scope = OAuthUtilities.JoinScopes(pendingRequest.Scope),
ExpirationDateUtc = DateTime.UtcNow.AddMinutes(1)
});
db.SaveChanges(); // submit now so that this new row can be retrieved later in this same HTTP request
// In this simple sample, the user either agrees to the entire scope requested by the client or none of it.
// But in a real app, you could grant a reduced scope of access to the client by passing a scope parameter to this method.
response = this.authorizationServer.PrepareApproveAuthorizationRequest(pendingRequest, username);
}
else
{
response = this.authorizationServer.PrepareRejectAuthorizationRequest(pendingRequest);
}
var a = this.authorizationServer.Channel.PrepareResponse(response);
return a.AsActionResult();
}