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 XmlDataTypeStore(DataTypeDescriptor dataTypeDescriptor, Type dataProviderHelperType, Type dataIdClassType, IEnumerable <XmlDataTypeStoreDataScope> xmlDateTypeStoreDataScopes, bool isGeneratedDataType)
{
DataTypeDescriptor = dataTypeDescriptor ?? throw new ArgumentNullException(nameof(dataTypeDescriptor));
DataProviderHelperType = dataProviderHelperType ?? throw new ArgumentNullException(nameof(dataProviderHelperType));
DataIdClassType = dataIdClassType ?? throw new ArgumentNullException(nameof(dataIdClassType));
IsGeneratedDataType = isGeneratedDataType;
_xmlDateTypeStoreDataScopes = xmlDateTypeStoreDataScopes.Evaluate();
var ordering = new List <Func <XElement, IComparable> >();
foreach (string key in dataTypeDescriptor.KeyPropertyNames)
{
XName localKey = key;
ordering.Add(f => (string)f.Attribute(localKey) ?? "");
}
Func <IEnumerable <XElement>, IOrderedEnumerable <XElement> > orderer = f => ordering.Skip(1).Aggregate(f.OrderBy(ordering.First()), Enumerable.ThenBy);
foreach (XmlDataTypeStoreDataScope xmlDataTypeStoreDataScope in _xmlDateTypeStoreDataScopes)
{
DataScopeIdentifier dataScopeIdentifier = DataScopeIdentifier.Deserialize(xmlDataTypeStoreDataScope.DataScopeName);
CultureInfo culture = CultureInfo.CreateSpecificCulture(xmlDataTypeStoreDataScope.CultureName);
Type dataType = dataTypeDescriptor.GetInterfaceType();
Action cacheFlush = () => DataEventSystemFacade.FireExternalStoreChangedEvent(dataType, dataScopeIdentifier.ToPublicationScope(), culture);
XmlDataProviderDocumentCache.RegisterExternalFileChangeAction(xmlDataTypeStoreDataScope.Filename, cacheFlush);
XmlDataProviderDocumentWriter.RegisterFileOrderer(xmlDataTypeStoreDataScope.Filename, orderer);
}
}
public void DropStore(DataTypeDescriptor typeDescriptor)
{
XmlDataProviderDocumentCache.ClearCache();
InterfaceConfigurationManipulator.Remove(_dataProviderContext.ProviderName, typeDescriptor);
_dataTypeConfigurationElements = _dataTypeConfigurationElements.Where(s => s.DataTypeId != typeDescriptor.DataTypeId).Evaluate();
}
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();
}
}
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);
}
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 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));
}
public void RemoveLocale(CultureInfo cultureInfo)
{
XmlDataProviderDocumentCache.ClearCache();
InterfaceConfigurationManipulator.RemoveLocale(_dataProviderContext.ProviderName, this.GetSupportedInterfaces(), cultureInfo);
}
