//Creation
public Token CreateToken(string tokenUnique, object data)
{
TokenLookup lookup = new TokenLookup()
{
AccessToken = GenerateCryptoKey(),
RefreshToken = GenerateCryptoKey(),
Expires = DateTime.Now.Add(TimeSpan.FromSeconds(Duration)),
Data = data,
TokenUnique = tokenUnique
};
lookupTable.AddOrUpdate(lookup.AccessToken, lookup, (key, val) => lookup);
return(lookup.ToToken());
}
//Verification
public bool VerifyToken(string tokenUnique, string token)
{
token = token.UrlDecode();
if (!lookupTable.ContainsKey(token))
{
return(false);
}
TokenLookup lookup = lookupTable[token];
if (lookup.TokenUnique != tokenUnique)
{
return(false);
}
if (lookup.Expires < DateTime.Now)
{
return(false);
}
return(true);
}
public SchemaDocument(XElement element)
{
SchemaVersion = NIFVersion.Parse(element.Attribute("version").Value);
var elementsByName = element.Elements()
.ToLookup(e => e.Name);
Tokens = elementsByName["token"]
.Select(e => new TokenSchema(e))
.ToList();
Versions = elementsByName["version"]
.Select(e => new VersionSchema(e))
.ToList();
NiObjects = elementsByName["niobject"]
.Select(e => new NiObjectSchema(e))
.ToDictionary(s => s.Name);
Compounds = elementsByName["compound"]
.Select(e => new CompoundSchema(e))
.ToDictionary(s => s.Name);
Basics = elementsByName["basic"]
.Select(e => new BasicSchema(e))
.ToDictionary(s => s.Name);
Enums = elementsByName["enum"]
.Select(e => new EnumSchema(e))
.ToDictionary(s => s.Name);
Bitfields = elementsByName["bitfield"]
.Select(e => new BitFieldSchema(e))
.ToDictionary(s => s.Name);
Bitflags = elementsByName["bitflags"]
.Select(e => new BitflagsSchema(e))
.ToDictionary(s => s.Name);
TokenLookup = new TokenLookup(Tokens.Concat(StaticTokens));
InheritanceLookup = new InheritanceLookup(NiObjects);
ExpressionLookup = new ExpressionLookup(NiObjects.Values, Compounds.Values, TokenLookup);
ParameterLookup = new ParameterLookup(Compounds.Values, ExpressionLookup);
TypeLookup = new TypeLookup(Compounds.Values, NiObjects.Values);
}
public Token UseRefreshToken(string tokenUnique, string accessToken, string refreshToken)
{
accessToken = accessToken.UrlDecode();
refreshToken = refreshToken.UrlDecode();
if (!lookupTable.ContainsKey(accessToken))
{
return(null);
}
TokenLookup lookup = lookupTable[accessToken];
if (lookup.RefreshToken != refreshToken)
{
return(null);
}
lookupTable.TryRemove(accessToken, out lookup);
lookup.AccessToken = GenerateCryptoKey().UrlEncode();
lookup.RefreshToken = GenerateCryptoKey().UrlEncode();
lookupTable.AddOrUpdate(lookup.AccessToken, lookup, (key, val) => lookup);
return(lookup.ToToken());
}
//Publics
public Token GetToken(string token)
{
TokenLookup lookup = lookupTable[token];
return(lookup.ToToken());
}
