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