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)); }