public async Task StoreAsync(string key, RefreshToken value)
{
await Repository.Store(new RefreshTokenDocument()
{
ClientId = value.ClientId,
Id = key,
SubjectId = value.SubjectId,
AccessTokenJson = await _propertySerializer.Serialize(value.AccessToken),
CreationTimeSecondsSinceEpoch = value.CreationTime.ToEpoch(),
LifeTime = value.LifeTime,
Version = value.Version,
SubjectJson = await _propertySerializer.Serialize(value.Subject),
Expiry = value.CreationTime.AddSeconds(value.LifeTime),
});
}
public XElement Serialize(PropertyDefinition propertyDefinition, IRdbmsPersistenceModelProvider persistenceModelProvider)
{
ArgumentUtility.CheckNotNull("propertyDefinition", propertyDefinition);
ArgumentUtility.CheckNotNull("persistenceModelProvider", persistenceModelProvider);
_enumSerializer.CollectPropertyType(propertyDefinition);
return(_propertySerializer.Serialize(propertyDefinition, persistenceModelProvider));
}
public void CreateItem(ICoreData ItemData)
{
string _strDBName = GetDBPath();
IDbConnection _connection = new SqliteConnection(_strDBName);
IDbCommand _command = _connection.CreateCommand();
string tableName = "items";
string sql = "";
_connection.Open();
if (ItemData != null)
{
if (ItemData.BaseData is ISerializeData)
{
ISerializeData itemSerializeDataInterface = ItemData.BaseData as ISerializeData;
if (itemSerializeDataInterface == null)
{
Debug.LogError("The external DB item data does not implement the interface ISerializeData");
return;
}
IPropertySerializer propertiesInterface = ItemData.BaseData.Properties as IPropertySerializer;
string serializedProperties = string.Empty;
if (propertiesInterface != null)
{
serializedProperties = propertiesInterface.Serialize();
}
sql = string.Format("INSERT INTO " + tableName + " (item_uuid, type, data, properties)" +
" VALUES ( \"{0}\", \"{1}\", \"{2}\", \"{3}\");",
ItemData.BaseData.UniqueUUID,
ItemData.BaseData.Type,
itemSerializeDataInterface.SerializeItemData(),
serializedProperties
);
_command.CommandText = sql;
_command.ExecuteNonQuery();
}
else
{
Debug.LogError("External DB item [" + ItemData.BaseData.Name + "] does not implement ISerializeData interface.");
}
}
else
{
Debug.Log("The external DB item is null.");
}
_command.Dispose();
_command = null;
_connection.Close();
_connection = null;
}
public async Task StoreAsync(string key, AuthorizationCode value)
{
if (value == null)
{
return;
}
await Repository.Store(new AuthorizationCodeTokenDocument()
{
ClientId = value.ClientId,
CreationTimeSecondsSinceEpoch = value.CreationTime.ToEpoch(),
Id = key,
SubjectId = value.SubjectId,
Nonce = value.Nonce,
RedirectUri = value.RedirectUri,
IsOpenId = value.IsOpenId,
SubjectJson = await _propertySerializer.Serialize(value.Subject),
WasConsentShown = value.WasConsentShown,
SessionId = value.SessionId,
RequestScopesJson = await _propertySerializer.Serialize(value.RequestedScopes),
Expiry = DateTimeOffset.UtcNow.AddSeconds(value.Client.AuthorizationCodeLifetime),
});
}
public async Task StoreAsync(string key, Token value)
{
await Repository.Store(new TokenHandleDocument()
{
CreationTimeSecondsSinceEpoch = value.CreationTime.ToEpoch(),
Lifetime = value.Lifetime,
Type = value.Type,
ClientId = value.ClientId,
Version = value.Version,
Audience = value.Audience,
Issuer = value.Issuer,
ClaimsListJson = await _propertySerializer.Serialize(value.Claims),
Id = key,
ExpirySecondsSinceEpoch = value.CreationTime.AddSeconds(value.Lifetime).ToEpoch(),
});
}
public void Serialize(object data, Stream stream)
{
if (data == null)
{
throw new ArgumentNullException("data");
}
var factory = new PropertyFactory(PropertyProvider);
Property property = factory.CreateProperty(RootName, data);
try
{
_serializer.Open(stream);
_serializer.Serialize(property);
}
finally
{
_serializer.Close();
}
}
public IEnumerable <XElement> Serialize(ClassDefinition classDefinition)
{
ArgumentUtility.CheckNotNull("classDefinition", classDefinition);
var tableDefinition = GetTableDefinition(classDefinition);
if (tableDefinition == null)
{
yield break;
}
var storageProviderDefinition = (RdbmsProviderDefinition)classDefinition.StorageEntityDefinition.StorageProviderDefinition;
var persistenceModelProvider = storageProviderDefinition.Factory.CreateRdbmsPersistenceModelProvider(storageProviderDefinition);
yield return(new XElement(
Constants.Namespace + "table",
new XAttribute("name", tableDefinition.TableName.EntityName),
GetPersistentPropertyDefinitions(classDefinition)
.Select(p => _propertySerializer.Serialize(p, persistenceModelProvider))
));
}
protected void AddProperty <T>(XElement xParent, string name, T value)
{
var xProperty = _propertySerializer.Serialize(name, value);
xParent.Add(xProperty);
}
