public IQueryable <T> GetData <T>()
where T : class, IData
{
CheckTransactionNotInAbortedState();
XmlDataTypeStore dataTypeStore = _xmlDataTypeStoresContainer.GetDataTypeStore(typeof(T));
var currentDataScope = DataScopeManager.MapByType(typeof(T));
if (!dataTypeStore.HasDataScopeName(currentDataScope))
{
return(Enumerable.Empty <T>().AsQueryable());
}
var dataTypeStoreScope = dataTypeStore.GetDataScopeForType(typeof(T));
var fileRecord = XmlDataProviderDocumentCache.GetFileRecord(
dataTypeStoreScope.Filename,
dataTypeStoreScope.ElementName,
dataTypeStore.Helper.CreateDataId);
if (fileRecord.CachedTable == null)
{
ICollection <XElement> elements = fileRecord.ReadOnlyElementsList;
Func <XElement, T> fun = dataTypeStore.Helper.CreateSelectFunction <T>(_dataProviderContext.ProviderName);
var list = new List <T>(elements.Count);
list.AddRange(elements.Select(fun));
fileRecord.CachedTable = new CachedTable <T>(list);
}
return(new CachingQueryable <T>(fileRecord.CachedTable, () => fileRecord.CachedTable.Queryable));
}
public void CreateStores(IReadOnlyCollection <DataTypeDescriptor> dataTypeDescriptors)
{
var dataTypes = DataTypeTypesManager.GetDataTypes(dataTypeDescriptors);
var storesToCreate = new List <GeneratedTypesInfo>();
foreach (var dataTypeDescriptor in dataTypeDescriptors)
{
Type interfaceType = dataTypes[dataTypeDescriptor.DataTypeId];
storesToCreate.Add(BuildGeneratedTypesInfo(dataTypeDescriptor, interfaceType));
}
CompileMissingTypes(storesToCreate);
foreach (var storeToCreate in storesToCreate)
{
var dataTypeDescriptor = storeToCreate.DataTypeDescriptor;
InterfaceConfigurationManipulator.AddNew(_dataProviderContext.ProviderName, dataTypeDescriptor);
var xmlDataTypeStoreCreator = new XmlDataTypeStoreCreator(_fileStoreDirectory);
XmlDataTypeStore xmlDateTypeStore = xmlDataTypeStoreCreator.CreateStoreResult(
dataTypeDescriptor,
storeToCreate.DataProviderHelperClass,
storeToCreate.DataIdClass, null);
Type interfaceType = storeToCreate.InterfaceType;
AddDataTypeStore(dataTypeDescriptor, interfaceType, xmlDateTypeStore);
}
}
public void Delete(IEnumerable <DataSourceId> dataSourceIds)
{
Verify.ArgumentNotNull(dataSourceIds, "dataSourceIds");
CheckTransactionNotInAbortedState();
using (XmlDataProviderDocumentCache.CreateEditingContext())
{
var validated = new Dictionary <DataSourceId, FileRecord>();
// verify phase
foreach (DataSourceId dataSourceId in dataSourceIds)
{
Verify.ArgumentCondition(dataSourceId != null, nameof(dataSourceIds), "The enumeration may not contain null values");
XmlDataTypeStore dataTypeStore = _xmlDataTypeStoresContainer.GetDataTypeStore(dataSourceId.InterfaceType);
var dataScope = dataSourceId.DataScopeIdentifier;
var culture = dataSourceId.LocaleScope;
var type = dataSourceId.InterfaceType;
var dataId = dataSourceId.DataId;
var dataTypeStoreScope = dataTypeStore.GetDataScope(dataScope, culture, type);
if (dataTypeStore.Helper._DataIdType != dataId.GetType())
{
throw new ArgumentException("Only data ids from this provider is allowed to be deleted on on the provider");
}
var fileRecord = GetFileRecord(dataTypeStore, dataTypeStoreScope);
var index = fileRecord.RecordSet.Index;
if (!index.ContainsKey(dataId))
{
throw new ArgumentException($"Cannot delete a data item, no data element corresponds to the given data id: '{dataId.Serialize(null)}'; Type: '{type}'; DataScope: '{dataScope}'; Culture: '{culture}'", nameof(dataSourceIds));
}
validated.Add(dataSourceId, fileRecord);
}
// commit phase
foreach (var dataSourceId in validated.Keys)
{
FileRecord fileRecord = validated[dataSourceId];
fileRecord.RecordSet.Index.Remove(dataSourceId.DataId);
fileRecord.Dirty = true;
}
XmlDataProviderDocumentCache.SaveChanges();
SubscribeToTransactionRollbackEvent();
}
}
/// <summary>
/// This method adds the support of the given data interface type to the xml data provider.
/// </summary>
/// <param name="interfaceType"></param>
/// <param name="xmlDataTypeStore"></param>
internal void AddSupportedDataTypeStore(Type interfaceType, XmlDataTypeStore xmlDataTypeStore)
{
_dataTypeStores.Add(interfaceType, xmlDataTypeStore);
_supportedInterface.Add(interfaceType);
AddKnownInterface(interfaceType);
if (xmlDataTypeStore.IsGeneratedDataType)
{
_generatedInterface.Add(interfaceType);
}
}
internal void UpdateSupportedDataTypeStore(Type interfaceType, XmlDataTypeStore xmlDataTypeStore)
{
Type type = _dataTypeStores.Where(f => f.Value.DataTypeDescriptor.DataTypeId == interfaceType.GetImmutableTypeId()).Select(f => f.Key).Single();
_dataTypeStores.Remove(type);
_dataTypeStores.Add(interfaceType, xmlDataTypeStore);
_supportedInterface.Remove(type);
_supportedInterface.Add(interfaceType);
_knownInterface.Remove(type);
_knownInterface.Add(interfaceType);
}
/// <summary>
/// This method adds the support of the given data interface type to the xml data provider.
/// </summary>
/// <param name="interfaceType"></param>
/// <param name="xmlDataTypeStore"></param>
internal void AddSupportedDataTypeStore(Type interfaceType, XmlDataTypeStore xmlDataTypeStore)
{
_dataTypeStores.Add(interfaceType, xmlDataTypeStore);
_supportedInterface.Add(interfaceType);
AddKnownInterface(interfaceType);
if (xmlDataTypeStore.IsGeneratedDataType)
{
_generatedInterface.Add(interfaceType);
}
}
public List <T> AddNew <T>(IEnumerable <T> dataset) where T : class, IData
{
Verify.ArgumentNotNull(dataset, "dataset");
CheckTransactionNotInAbortedState();
var resultList = new List <T>();
using (XmlDataProviderDocumentCache.CreateEditingContext())
{
XmlDataTypeStore dataTypeStore = _xmlDataTypeStoresContainer.GetDataTypeStore(typeof(T));
var dataTypeStoreScope = dataTypeStore.GetDataScopeForType(typeof(T));
var fileRecord = GetFileRecord(dataTypeStore, dataTypeStoreScope);
var validatedElements = new Dictionary <DataSourceId, XElement>();
// validating phase
foreach (IData data in dataset)
{
Verify.ArgumentCondition(data != null, nameof(dataset), "The enumeration dataset may not contain nulls");
ValidationHelper.Validate(data);
XElement newElement;
T newData = dataTypeStore.Helper.CreateNewElement <T>(data, out newElement, dataTypeStoreScope.ElementName, _dataProviderContext.ProviderName);
IDataId dataId = dataTypeStore.Helper.CreateDataId(newElement);
XElement violatingElement = fileRecord.RecordSet.Index[dataId];
if (violatingElement != null)
{
throw new ArgumentException(nameof(dataset), "Key violation error. A data element with the same dataId is already added. Type: " + typeof(T).FullName);
}
validatedElements.Add(newData.DataSourceId, newElement);
resultList.Add(newData);
}
// commit validated elements
foreach (var key in validatedElements.Keys)
{
fileRecord.RecordSet.Index.Add(key.DataId, validatedElements[key]);
fileRecord.Dirty = true;
}
XmlDataProviderDocumentCache.SaveChanges();
SubscribeToTransactionRollbackEvent();
}
return(resultList);
}
internal void UpdateSupportedDataTypeStore(Type interfaceType, XmlDataTypeStore xmlDataTypeStore)
{
Type type = _dataTypeStores.Where(f => f.Value.DataTypeDescriptor.DataTypeId == interfaceType.GetImmutableTypeId()).Select(f => f.Key).Single();
_dataTypeStores.Remove(type);
_dataTypeStores.Add(interfaceType, xmlDataTypeStore);
_supportedInterface.Remove(type);
_supportedInterface.Add(interfaceType);
_knownInterface.Remove(type);
_knownInterface.Add(interfaceType);
}
/// <summary>
/// This method adds the support of the given data interface type to the xml data provider.
/// </summary>
/// <param name="interfaceType"></param>
/// <param name="xmlDataTypeStore"></param>
internal void AddSupportedDataTypeStore(Type interfaceType, XmlDataTypeStore xmlDataTypeStore)
{
Verify.That(!_dataTypeStores.ContainsKey(interfaceType), $"Interface type {interfaceType.FullName} has already been registered");
_dataTypeStores.Add(interfaceType, xmlDataTypeStore);
_supportedInterfaces.Add(interfaceType);
AddKnownInterface(interfaceType);
if (xmlDataTypeStore.IsGeneratedDataType)
{
_generatedInterfaces.Add(interfaceType);
}
}
/// <summary>
/// This method adds the support of the given data interface type to the xml data provider.
/// </summary>
/// <param name="interfaceType"></param>
/// <param name="xmlDataTypeStore"></param>
internal void AddSupportedDataTypeStore(Type interfaceType, XmlDataTypeStore xmlDataTypeStore)
{
Verify.That(!_dataTypeStores.ContainsKey(interfaceType), $"Interface type {interfaceType.FullName} has already been registered");
_dataTypeStores.Add(interfaceType, xmlDataTypeStore);
_supportedInterfaces.Add(interfaceType);
AddKnownInterface(interfaceType);
if (xmlDataTypeStore.IsGeneratedDataType)
{
_generatedInterfaces.Add(interfaceType);
}
}
public void AlterStore(UpdateDataTypeDescriptor updateDataTypeDescriptor, bool forceCompile)
{
XmlDataProviderDocumentCache.ClearCache();
XmlProviderInterfaceConfigurationElement element = InterfaceConfigurationManipulator.Change(updateDataTypeDescriptor);
if (forceCompile)
{
DataTypeDescriptor dataTypeDescriptor = updateDataTypeDescriptor.NewDataTypeDescriptor;
Type dataProviderHelperType;
Type dataIdClassType;
bool typesExists = EnsureNeededTypes(dataTypeDescriptor, out dataProviderHelperType, out dataIdClassType, true);
Verify.That(typesExists, "Could not find or code generated the type '{0}' or one of the needed helper types", dataTypeDescriptor.GetFullInterfaceName());
var xmlDataTypeStoreDataScopes = new List <XmlDataTypeStoreDataScope>();
foreach (DataScopeConfigurationElement dataScopeConfigurationElement in element.ConfigurationStores)
{
var xmlDataTypeStoreDataScope = new XmlDataTypeStoreDataScope
{
DataScopeName = dataScopeConfigurationElement.DataScope,
CultureName = dataScopeConfigurationElement.CultureName,
ElementName = dataScopeConfigurationElement.ElementName,
Filename = Path.Combine(_fileStoreDirectory, dataScopeConfigurationElement.Filename)
};
xmlDataTypeStoreDataScopes.Add(xmlDataTypeStoreDataScope);
}
var xmlDataTypeStoreCreator = new XmlDataTypeStoreCreator(_fileStoreDirectory);
XmlDataTypeStore xmlDateTypeStore = xmlDataTypeStoreCreator.CreateStoreResult(dataTypeDescriptor, dataProviderHelperType, dataIdClassType, xmlDataTypeStoreDataScopes);
Type interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor);
UpdateDataTypeStore(dataTypeDescriptor, interfaceType, xmlDateTypeStore);
}
}
public T GetData <T>(IDataId dataId)
where T : class, IData
{
if (dataId == null)
{
throw new ArgumentNullException("dataId");
}
XmlDataTypeStore dataTypeStore = _xmlDataTypeStoresContainer.GetDataTypeStore(typeof(T));
var dataTypeStoreScope = dataTypeStore.GetDataScopeForType(typeof(T));
var fileRecord = GetFileRecord(dataTypeStore, dataTypeStoreScope);
XElement element = fileRecord.RecordSet.Index[dataId];
if (element == null)
{
return(null);
}
Func <XElement, T> selectFun = dataTypeStore.Helper.CreateSelectFunction <T>(_dataProviderContext.ProviderName);
return(selectFun(element));
}
private void UpdateDataTypeStore(DataTypeDescriptor dataTypeDescriptor, Type interfaceType, XmlDataTypeStore xmlDateTypeStore)
{
_xmlDataTypeStoresContainer.UpdateSupportedDataTypeStore(interfaceType, xmlDateTypeStore);
}
private void AddDataTypeStore(DataTypeDescriptor dataTypeDescriptor, Type interfaceType, XmlDataTypeStore xmlDateTypeStore)
{
bool interfaceValidated = DataTypeValidationRegistry.Validate(interfaceType, dataTypeDescriptor);
if (xmlDateTypeStore != null && interfaceValidated)
{
_xmlDataTypeStoresContainer.AddSupportedDataTypeStore(interfaceType, xmlDateTypeStore);
DataProviderRegistry.AddNewDataType(interfaceType, _dataProviderContext.ProviderName);
}
else
{
_xmlDataTypeStoresContainer.AddKnownInterface(interfaceType);
}
}
private void InitializeExistingStores()
{
var xmlDataTypeStoreCreator = new XmlDataTypeStoreCreator(_fileStoreDirectory);
_xmlDataTypeStoresContainer = new XmlDataTypeStoresContainer(_dataProviderContext.ProviderName);
var dataTypes = LoadDataTypes(_dataTypeConfigurationElements);
var storesToLoad = new List <GeneratedTypesInfo>();
foreach (XmlProviderInterfaceConfigurationElement element in _dataTypeConfigurationElements)
{
var dataTypeDescriptor = GetDataTypeDescriptorNotNull(element);
Type interfaceType = null;
try
{
if (!dataTypes.TryGetValue(dataTypeDescriptor.DataTypeId, out interfaceType) || interfaceType == null)
{
Log.LogWarning(LogTitle, "The data interface type '{0}' does not exist and is not code generated. It will not be usable", dataTypeDescriptor.TypeManagerTypeName);
continue;
}
storesToLoad.Add(BuildGeneratedTypesInfo(dataTypeDescriptor, interfaceType, element));
}
catch (Exception ex)
{
if (interfaceType != null)
{
DataProviderRegistry.AddKnownDataType(interfaceType, _dataProviderContext.ProviderName);
}
Log.LogError(LogTitle, "Failed initialization for the datatype {{{0}}}, {1}", dataTypeDescriptor.DataTypeId, dataTypeDescriptor.TypeManagerTypeName);
Log.LogError(LogTitle, ex);
}
}
CompileMissingTypes(storesToLoad);
foreach (var storeToLoad in storesToLoad)
{
try
{
var xmlDataTypeStoreDataScopes = new List <XmlDataTypeStoreDataScope>();
foreach (DataScopeConfigurationElement dataScopeConfigurationElement in storeToLoad.Element.ConfigurationStores)
{
var xmlDataTypeStoreDataScope = new XmlDataTypeStoreDataScope
{
DataScopeName = dataScopeConfigurationElement.DataScope,
CultureName = dataScopeConfigurationElement.CultureName,
ElementName = dataScopeConfigurationElement.ElementName,
Filename = Path.Combine(_fileStoreDirectory, dataScopeConfigurationElement.Filename)
};
xmlDataTypeStoreDataScopes.Add(xmlDataTypeStoreDataScope);
}
XmlDataTypeStore xmlDateTypeStore = xmlDataTypeStoreCreator.CreateStoreResult(storeToLoad.DataTypeDescriptor,
storeToLoad.DataProviderHelperClass, storeToLoad.DataIdClass, xmlDataTypeStoreDataScopes);
AddDataTypeStore(storeToLoad.DataTypeDescriptor, storeToLoad.InterfaceType, xmlDateTypeStore);
}
catch (Exception ex)
{
DataProviderRegistry.AddKnownDataType(storeToLoad.InterfaceType, _dataProviderContext.ProviderName);
Log.LogError(LogTitle, "Failed initialization for the datatype {{{0}}}, {1}", storeToLoad.DataTypeDescriptor.DataTypeId, storeToLoad.DataTypeDescriptor.TypeManagerTypeName);
Log.LogError(LogTitle, ex);
}
}
}
private void AddDataTypeStore(DataTypeDescriptor dataTypeDescriptor, Type interfaceType, XmlDataTypeStore xmlDateTypeStore)
{
bool interfaceValidated = DataTypeValidationRegistry.Validate(interfaceType, dataTypeDescriptor);
if (xmlDateTypeStore != null && interfaceValidated)
{
_xmlDataTypeStoresContainer.AddSupportedDataTypeStore(interfaceType, xmlDateTypeStore);
DataProviderRegistry.AddNewDataType(interfaceType, _dataProviderContext.ProviderName);
}
else
{
_xmlDataTypeStoresContainer.AddKnownInterface(interfaceType);
}
}
private void UpdateDataTypeStore(DataTypeDescriptor dataTypeDescriptor, Type interfaceType, XmlDataTypeStore xmlDateTypeStore)
{
_xmlDataTypeStoresContainer.UpdateSupportedDataTypeStore(interfaceType, xmlDateTypeStore);
}
public void Update(IEnumerable <IData> dataset)
{
Verify.ArgumentNotNull(dataset, "dataset");
CheckTransactionNotInAbortedState();
using (XmlDataProviderDocumentCache.CreateEditingContext())
{
var validatedFileRecords = new Dictionary <DataSourceId, FileRecord>();
var validatedElements = new Dictionary <DataSourceId, XElement>();
// verify phase
foreach (IData wrappedData in dataset)
{
var data = DataWrappingFacade.UnWrap(wrappedData);
Verify.ArgumentCondition(data != null, "dataset", "Collection contains a null element.");
Verify.ArgumentCondition(data.DataSourceId != null, "dataset", "Collection contains a data item with DataSourceId null property.");
ValidationHelper.Validate(data);
XmlDataTypeStore dataTypeStore = _xmlDataTypeStoresContainer.GetDataTypeStore(data.DataSourceId.InterfaceType);
var dataScope = data.DataSourceId.DataScopeIdentifier;
var culture = data.DataSourceId.LocaleScope;
var type = data.DataSourceId.InterfaceType;
var dataTypeStoreScope = dataTypeStore.GetDataScope(dataScope, culture, type);
dataTypeStore.Helper.ValidateDataType(data);
if (null == data.DataSourceId)
{
throw new ArgumentException("The DataSourceId property of the data argument must not be null", "data");
}
if (data.DataSourceId.ProviderName != _dataProviderContext.ProviderName)
{
throw new ArgumentException("The data element does not belong to this provider", "data");
}
var fileRecord = GetFileRecord(dataTypeStore, dataTypeStoreScope);
var index = fileRecord.RecordSet.Index;
IDataId dataId = data.DataSourceId.DataId;
XElement element = index[dataId];
Verify.ArgumentCondition(element != null, "dataset", "No data element corresponds to the given data id");
IXElementWrapper wrapper = data as IXElementWrapper;
Verify.ArgumentCondition(wrapper != null, "dataset", "The type of data was expected to be of type {0}".FormatWith(typeof(IXElementWrapper)));
XElement updatedElement = CreateUpdatedXElement(wrapper, element);
validatedFileRecords.Add(data.DataSourceId, fileRecord);
validatedElements.Add(data.DataSourceId, updatedElement);
}
foreach (var key in validatedElements.Keys)
{
FileRecord fileRecord = validatedFileRecords[key];
fileRecord.Dirty = true;
fileRecord.RecordSet.Index[key.DataId] = validatedElements[key];
}
XmlDataProviderDocumentCache.SaveChanges();
SubscribeToTransactionRollbackEvent();
}
}
private static FileRecord GetFileRecord(XmlDataTypeStore dataTypeStore, XmlDataTypeStoreDataScope dataTypeStoreDataScope)
{
return(XmlDataProviderDocumentCache.GetFileRecord(dataTypeStoreDataScope.Filename, dataTypeStoreDataScope.ElementName, dataTypeStore.Helper.CreateDataId));
}
