private IQueryable <T> BuildQueryFromProviders <T>(IEnumerable <string> providerNames) where T : class, IData { if (providerNames == null) { providerNames = DataProviderRegistry.GetDataProviderNamesByInterfaceType(typeof(T)); } var queries = new List <IQueryable <T> >(); foreach (string providerName in providerNames) { IQueryable <T> query = DataProviderPluginFacade.GetData <T>(providerName); queries.Add(query); } bool resultIsCached = queries.Count == 1 && queries[0] is ICachedQuery; if (resultIsCached) { return(queries[0]); } return(new DataFacadeQueryable <T>(queries)); }
/// <summary> /// Copies all the data from the source data provider to the target data provider. /// </summary> public void FullCopy() { var allTypes = from type in DataFacade.GetAllInterfaces() where DataProviderRegistry.GetDataProviderNamesByInterfaceType(type).Contains(this.SourceProviderName) select type; Copy(allTypes); }
private static bool DataProvidersSupportDataWrapping(Type T) { var providerNames = DataProviderRegistry.GetDataProviderNamesByInterfaceType(T); Verify.IsNotNull(providerNames, "Failed to get data provider names list"); return(providerNames.All(DataProviderPluginFacade.AllowsResultsWrapping)); }
private List <string> GetWritableDataProviders(Type type) { var dataProviders = DataProviderRegistry.GetWriteableDataProviderNamesByInterfaceType(type); if (dataProviders.Count > 1 && dataProviders.Contains(DataProviderRegistry.DefaultDynamicTypeDataProviderName)) { dataProviders = new List <string> { DataProviderRegistry.DefaultDynamicTypeDataProviderName }; } return(dataProviders); }
/// <summary> /// </summary> /// <param name="oldDataTypeDescriptor"></param> /// <param name="newDataTypeDescriptor"></param> /// <param name="originalTypeHasData"></param> public UpdateDataTypeDescriptor(DataTypeDescriptor oldDataTypeDescriptor, DataTypeDescriptor newDataTypeDescriptor, bool originalTypeHasData = true) { OldDataTypeDescriptor = oldDataTypeDescriptor; NewDataTypeDescriptor = newDataTypeDescriptor; var interfaceType = oldDataTypeDescriptor.GetInterfaceType(); ProviderName = interfaceType != null ? DataProviderRegistry.GetWriteableDataProviderNamesByInterfaceType(interfaceType) .SingleOrException("Failed to get data provider by type '{0}'", "Multiple data providers for type '{0}'", interfaceType.FullName) : DataProviderRegistry.DefaultDynamicTypeDataProviderName; }
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); } }
internal static void DropStore(string providerName, DataTypeDescriptor typeDescriptor, bool makeAFlush) { if (providerName == null) { providerName = DataProviderRegistry.DefaultDynamicTypeDataProviderName; } _dynamicTypeManager.DropStore(providerName, typeDescriptor, makeAFlush); var interfaceType = typeDescriptor.GetInterfaceType(); if (interfaceType != null) { DataProviderRegistry.UnregisterDataType(interfaceType, providerName); } }
public IQueryable <T> GetData <T>(bool useCaching, IEnumerable <string> providerNames) where T : class, IData { IQueryable <T> resultQueryable; if (DataProviderRegistry.AllInterfaces.Contains(typeof(T))) { if (useCaching && providerNames == null && DataCachingFacade.IsDataAccessCacheEnabled(typeof(T))) { resultQueryable = DataCachingFacade.GetDataFromCache <T>( () => BuildQueryFromProviders <T>(null)); } else { resultQueryable = BuildQueryFromProviders <T>(providerNames); } } else { DataProviderRegistry.CheckInitializationErrors(typeof(T)); if (!typeof(T).GetCustomInterfaceAttributes <AutoUpdatebleAttribute>().Any()) { throw new ArgumentException($"The given interface type ({typeof (T)}) is not supported by any data providers"); } resultQueryable = new List <T>().AsQueryable(); } foreach (var dataInterceptor in GetDataInterceptors(typeof(T))) { try { resultQueryable = dataInterceptor.InterceptGetData <T>(resultQueryable); } catch (Exception ex) { Log.LogError(LogTitle, ex); } } return(resultQueryable); }
private void EnsureInterfaces(IEnumerable <Type> allInterfaces) { var dataTypeDescriptors = new List <DataTypeDescriptor>(); foreach (Type interfaceType in allInterfaces) { if (!DataProviderRegistry.GetDataProviderNamesByInterfaceType(interfaceType).Contains(this.TargetProviderName)) { var dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(interfaceType); dataTypeDescriptor.Validate(); dataTypeDescriptors.Add(dataTypeDescriptor); } } DataProviderPluginFacade.CreateStores(this.TargetProviderName, dataTypeDescriptors); }
private void AddDataTypeStore(InitializeStoreResult initializeStoreResult, bool doValidate = true, bool isInitialization = false) { if (initializeStoreResult.InterfaceType == null) { return; } bool isValid = initializeStoreResult.SqlDataTypeStore != null; if (isValid && doValidate) { isValid = ValidateTables(initializeStoreResult, isInitialization); } if (!isValid) { _sqlDataTypeStoresContainer.AddKnownInterface(initializeStoreResult.InterfaceType); return; } _sqlDataTypeStoresContainer.AddSupportedDataTypeStore(initializeStoreResult.InterfaceType, initializeStoreResult.SqlDataTypeStore); DataProviderRegistry.AddNewDataType(initializeStoreResult.InterfaceType, _dataProviderContext.ProviderName); }
private InterfaceGeneratedClassesInfo InitializeStoreTypes(InterfaceConfigurationElement element, Dictionary <DataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> > allSqlDataTypeStoreDataScopes, Type dataContextClass, Dictionary <Guid, Type> dataTypes, bool forceCompile, ref bool dataContextRecompilationNeeded, ref HelperClassesGenerationInfo helperClassesGenerationInfo) { var result = new InterfaceGeneratedClassesInfo(); var dataScopes = new List <SqlDataTypeStoreDataScope>(); foreach (StorageInformation storageInformation in element.Stores) { var sqlDataTypeStoreDataScope = new SqlDataTypeStoreDataScope { DataScopeName = storageInformation.DataScope, CultureName = storageInformation.CultureName, TableName = storageInformation.TableName }; dataScopes.Add(sqlDataTypeStoreDataScope); } result.DataScopes = dataScopes; Guid dataTypeId = element.DataTypeId; var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(dataTypeId, true); if (dataTypeDescriptor == null) { throw NewConfigurationException(element, "Failed to get a DataTypeDescriptor by id '{0}'".FormatWith(dataTypeId)); } result.DataTypeDescriptor = dataTypeDescriptor; Type interfaceType = null; try { if (dataTypes == null || !dataTypes.TryGetValue(dataTypeId, out interfaceType) || interfaceType == null) { interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor); } if (interfaceType == null) { Log.LogWarning(LogTitle, "The data interface type '{0}' does not exists and is not code generated. It will not be unusable", dataTypeDescriptor.TypeManagerTypeName); return(result); } result.InterfaceType = interfaceType; string validationMessage; bool isValid = DataTypeValidationRegistry.Validate(interfaceType, dataTypeDescriptor, out validationMessage); if (!isValid) { Log.LogCritical(LogTitle, validationMessage); throw new InvalidOperationException(validationMessage); } Dictionary <SqlDataTypeStoreTableKey, StoreTypeInfo> fields; helperClassesGenerationInfo = EnsureNeededTypes(dataTypeDescriptor, dataScopes, allSqlDataTypeStoreDataScopes, dataContextClass, out fields, ref dataContextRecompilationNeeded, forceCompile); result.Fields = fields; return(result); } catch (Exception ex) { if (interfaceType != null) { DataProviderRegistry.RegisterDataTypeInitializationError(interfaceType, ex); DataProviderRegistry.AddKnownDataType(interfaceType, _dataProviderContext.ProviderName); Log.LogError(LogTitle, "Failed initialization for the datatype {0}", dataTypeDescriptor.TypeManagerTypeName); } Log.LogError(LogTitle, ex); result.Fields = new Dictionary <SqlDataTypeStoreTableKey, StoreTypeInfo>(); return(result); } }
private static void DoInitialize() { int startTime = Environment.TickCount; Guid installationId = InstallationInformationFacade.InstallationId; Log.LogVerbose(LogTitle, "Initializing the system core - installation id = " + installationId); using (new LogExecutionTime(LogTitle, "Initialization of the static data types")) { DataProviderRegistry.InitializeDataTypes(); } using (new LogExecutionTime(LogTitle, "Auto update of static data types")) { bool typesUpdated = AutoUpdateStaticDataTypes(); if (typesUpdated) { using (new LogExecutionTime(LogTitle, "Reinitialization of the static data types")) { SqlTableInformationStore.Flush(); DataProviderRegistry.Flush(); DataProviderPluginFacade.Flush(); DataProviderRegistry.InitializeDataTypes(); } CodeGenerationManager.GenerateCompositeGeneratedAssembly(true); } } using (new LogExecutionTime(LogTitle, "Ensure data stores")) { bool dataStoresCreated = DataStoreExistenceVerifier.EnsureDataStores(); if (dataStoresCreated) { Log.LogVerbose(LogTitle, "Initialization of the system was halted, performing a flush"); _initializing = false; GlobalEventSystemFacade.FlushTheSystem(); return; } } using (new LogExecutionTime(LogTitle, "Initializing data process controllers")) { ProcessControllerFacade.Initialize_PostDataTypes(); } using (new LogExecutionTime(LogTitle, "Initializing data type references")) { DataReferenceRegistry.Initialize_PostDataTypes(); } using (new LogExecutionTime(LogTitle, "Initializing data type associations")) { DataAssociationRegistry.Initialize_PostDataTypes(); } using (new LogExecutionTime(LogTitle, "Initializing internal urls")) { InternalUrls.Initialize_PostDataTypes(); } using (new LogExecutionTime(LogTitle, "Initializing functions")) { MetaFunctionProviderRegistry.Initialize_PostDataTypes(); } Log.LogVerbose(LogTitle, "Starting initialization of administrative secondaries"); if (SystemSetupFacade.IsSystemFirstTimeInitialized && !SystemSetupFacade.SetupIsRunning) { using (new LogExecutionTime(LogTitle, "Initializing workflow runtime")) { WorkflowFacade.EnsureInitialization(); } } if (!RuntimeInformation.IsUnittest) { using (new LogExecutionTime(LogTitle, "Initializing flow system")) { FlowControllerFacade.Initialize(); } using (new LogExecutionTime(LogTitle, "Initializing console system")) { ConsoleFacade.Initialize(); } } using (new LogExecutionTime(LogTitle, "Auto installing packages")) { DoAutoInstallPackages(); } using (new LogExecutionTime(LogTitle, "Loading element providers")) { ElementProviderLoader.LoadAllProviders(); } int executionTime = Environment.TickCount - startTime; Log.LogVerbose(LogTitle, "Done initializing of the system core. ({0} ms)".FormatWith(executionTime)); }
private static List <T> AddNew_AddingMethod <T>(string providerName, IEnumerable <T> dataset, bool suppressEventing, bool performForeignKeyIntegrityCheck, bool performValidation) where T : class, IData { Verify.ArgumentNotNullOrEmpty(providerName, "providerName"); Verify.ArgumentNotNull(dataset, "dataset"); Verify.ArgumentCondition(!dataset.Contains(null), "dataset", "The enumeration may not contain null values"); List <string> writeableProviders = DataProviderRegistry.GetWriteableDataProviderNamesByInterfaceType(typeof(T)); if (!writeableProviders.Contains(providerName)) { Log.LogVerbose(LogTitle, $"Type data interface '{typeof(T)}' is marked auto updateable and is not supported by the provider '{providerName}', adding it"); DynamicTypeManager.EnsureCreateStore(typeof(T), providerName); } writeableProviders = DataProviderRegistry.GetWriteableDataProviderNamesByInterfaceType(typeof(T)); if (!writeableProviders.Contains(providerName)) { throw new InvalidOperationException($"The writeable data providers '{providerName}' does not support the interface '{typeof(T)}'."); } foreach (T data in dataset) { if (performValidation) { CheckValidationResult(ValidationFacade.Validate <T>(data), typeof(T)); } if (performForeignKeyIntegrityCheck) { data.ValidateForeignKeyIntegrity(); } } if (!suppressEventing) { foreach (T data in dataset) { DataEventSystemFacade.FireDataBeforeAddEvent <T>(data); } } List <T> addedDataset = DataProviderPluginFacade.AddNew <T>(providerName, dataset); DataCachingFacade.ClearCache(typeof(T), DataScopeManager.MapByType(typeof(T)), LocalizationScopeManager.MapByType(typeof(T))); if (!suppressEventing) { foreach (T data in addedDataset) { DataEventSystemFacade.FireDataAfterAddEvent <T>(data); } } return(addedDataset); }
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); } } }
public IQueryable <T> GetData <T>(bool useCaching, IEnumerable <string> providerNames) where T : class, IData { IQueryable <T> resultQueryable; if (DataProviderRegistry.AllInterfaces.Contains(typeof(T))) { if (useCaching && DataCachingFacade.IsDataAccessCacheEnabled(typeof(T))) { resultQueryable = DataCachingFacade.GetDataFromCache <T>(); } else { if (providerNames == null) { providerNames = DataProviderRegistry.GetDataProviderNamesByInterfaceType(typeof(T)); } List <IQueryable <T> > queryables = new List <IQueryable <T> >(); foreach (string providerName in providerNames) { IQueryable <T> queryable = DataProviderPluginFacade.GetData <T>(providerName); queryables.Add(queryable); } bool resultIsCached = queryables.Count == 1 && queryables[0] is ICachedQuery; if (resultIsCached) { resultQueryable = queryables[0]; } else { var multipleSourceQueryable = new DataFacadeQueryable <T>(queryables); resultQueryable = multipleSourceQueryable; } } } else { DataProviderRegistry.CheckInitializationErrors(typeof(T)); if (!typeof(T).GetCustomInterfaceAttributes <AutoUpdatebleAttribute>().Any()) { throw new ArgumentException(string.Format("The given interface type ({0}) is not supported by any data providers", typeof(T))); } resultQueryable = new List <T>().AsQueryable(); } DataInterceptor dataInterceptor; this.DataInterceptors.TryGetValue(typeof(T), out dataInterceptor); if (dataInterceptor != null) { try { resultQueryable = dataInterceptor.InterceptGetData <T>(resultQueryable); } catch (Exception ex) { Log.LogError(LogTitle, "Calling data interceptor failed with the following exception"); Log.LogError(LogTitle, ex); } } return(resultQueryable); }