/// <summary> /// For internal use only!!! /// This method will create the store if the interfaceType has not been configured. /// </summary> /// <param name="interfaceType"></param> /// <param name="providerName"></param> // Helper public static void EnsureCreateStore(Type interfaceType, string providerName) { DataTypeDescriptor dataTypeDescriptor; if (!TryGetDataTypeDescriptor(interfaceType, out dataTypeDescriptor)) { dataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType); } if (providerName == null) { // Checking if any of exising dynamic data providers already has a store for the specified interface type if (DataProviderRegistry.DynamicDataProviderNames .Select(DataProviderPluginFacade.GetDataProvider) .Cast <IDynamicDataProvider>() .Any(dynamicDataProvider => dynamicDataProvider.GetKnownInterfaces().Contains(interfaceType))) { return; } providerName = DataProviderRegistry.DefaultDynamicTypeDataProviderName; } else { var dataProvider = (IDynamicDataProvider)DataProviderPluginFacade.GetDataProvider(providerName); if (dataProvider.GetKnownInterfaces().Contains(interfaceType)) { return; } } CreateStore(providerName, dataTypeDescriptor, true); CodeGenerationManager.GenerateCompositeGeneratedAssembly(true); }
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)); }
public T GetDataFromDataSourceId <T>(DataSourceId dataSourceId, bool useCaching) where T : class, IData { if (null == dataSourceId) { throw new ArgumentNullException("dataSourceId"); } useCaching = useCaching && DataCachingFacade.IsTypeCacheable(typeof(T)); using (new DataScope(dataSourceId.DataScopeIdentifier, dataSourceId.LocaleScope)) { T resultData = null; string cacheKey = string.Empty; if (useCaching) { cacheKey = dataSourceId.ToString(); resultData = (T)_dataBySourceIdCache.Get(cacheKey); } if (resultData == null) { resultData = DataProviderPluginFacade.GetData <T>(dataSourceId.ProviderName, dataSourceId.DataId); if (useCaching && resultData != null && _dataBySourceIdCache.Enabled) { _dataBySourceIdCache.Add(cacheKey, resultData); } } if (useCaching && resultData != null) { resultData = DataWrappingFacade.Wrap(resultData); } DataInterceptor dataInterceptor; this.DataInterceptors.TryGetValue(typeof(T), out dataInterceptor); if (dataInterceptor != null) { try { resultData = dataInterceptor.InterceptGetDataFromDataSourceId <T>(resultData); } catch (Exception ex) { Log.LogError(LogTitle, "Calling data interceptor failed with the following exception"); Log.LogError(LogTitle, ex); } } return(resultData); } }
public T GetDataFromDataSourceId <T>(DataSourceId dataSourceId, bool useCaching) where T : class, IData { Verify.ArgumentNotNull(dataSourceId, nameof(dataSourceId)); useCaching = useCaching && DataCachingFacade.IsTypeCacheable(typeof(T)); using (new DataScope(dataSourceId.DataScopeIdentifier, dataSourceId.LocaleScope)) { T resultData = null; string cacheKey = string.Empty; if (useCaching) { cacheKey = dataSourceId.ToString(); resultData = (T)_dataBySourceIdCache.Get(cacheKey); } if (resultData == null) { resultData = DataProviderPluginFacade.GetData <T>(dataSourceId.ProviderName, dataSourceId.DataId); if (useCaching && resultData != null && _dataBySourceIdCache.Enabled) { _dataBySourceIdCache.Add(cacheKey, resultData); } } if (useCaching && resultData != null) { resultData = DataWrappingFacade.Wrap(resultData); } foreach (var dataInterceptor in GetDataInterceptors(typeof(T))) { try { resultData = dataInterceptor.InterceptGetDataFromDataSourceId <T>(resultData); } catch (Exception ex) { Log.LogError(LogTitle, ex); } } return(resultData); } }
/// <exclude /> public void AddLocale(string providerName, CultureInfo cultureInfo) { Verify.ArgumentNotNullOrEmpty(providerName, nameof(providerName)); Verify.ArgumentNotNull(cultureInfo, nameof(cultureInfo)); using (var transactionScope = TransactionsFacade.CreateNewScope()) { DataProviderPluginFacade.AddLocale(providerName, cultureInfo); transactionScope.Complete(); } if (!SystemSetupFacade.SetupIsRunning) { CodeGenerationManager.GenerateCompositeGeneratedAssembly(true); } }
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); }
/// <exclude /> public void AlterStore(UpdateDataTypeDescriptor updateDataTypeDescriptor, bool forceCompile) { DataTypeChangeDescriptor dataTypeChangeDescriptor = updateDataTypeDescriptor.CreateDataTypeChangeDescriptor(); dataTypeChangeDescriptor.AlteredType.Validate(); using (var transactionScope = TransactionsFacade.CreateNewScope()) { DataMetaDataFacade.PersistMetaData(dataTypeChangeDescriptor.AlteredType); if (dataTypeChangeDescriptor.AlteredTypeHasChanges) { DataProviderPluginFacade.AlterStore(updateDataTypeDescriptor, forceCompile); } transactionScope.Complete(); } }
/// <exclude /> public void RemoveLocale(string providerName, CultureInfo cultureInfo) { if (string.IsNullOrEmpty(providerName)) { throw new ArgumentNullException("providerName"); } if (cultureInfo == null) { throw new ArgumentNullException("cultureInfo"); } using (var transactionScope = TransactionsFacade.CreateNewScope()) { DataProviderPluginFacade.RemoveLocale(providerName, cultureInfo); transactionScope.Complete(); } CodeGenerationManager.GenerateCompositeGeneratedAssembly(true); }
/// <exclude /> public void DropStore(string providerName, DataTypeDescriptor typeDescriptor, bool makeAFlush) { Verify.ArgumentNotNullOrEmpty(providerName, "providerName"); Verify.ArgumentNotNull(typeDescriptor, "typeDescriptor"); typeDescriptor.Validate(); using (var transactionScope = TransactionsFacade.CreateNewScope()) { DataProviderPluginFacade.DropStore(providerName, typeDescriptor); DataMetaDataFacade.DeleteMetaData(typeDescriptor.DataTypeId); transactionScope.Complete(); } if (makeAFlush) { GlobalEventSystemFacade.FlushTheSystem(); } }
public void InitializeDataTypes() { using (TimerProfilerFacade.CreateTimerProfiler()) { _dataProviderNames = new List <string>(); _interfaceTypeToReadableProviderNames = new Dictionary <Type, List <string> >(); _interfaceTypeToWriteableProviderNames = new Dictionary <Type, List <string> >(); _knownInterfaceTypeToDynamicProviderNames = new Dictionary <Type, List <string> >(); _initializationErrors = new Hashtable <Type, Exception>(); _generatedInterfaceTypes = new List <Type>(); if (DataProviderPluginFacade.HasConfiguration()) { BuildDataProviderNames(); BuildDictionaries(); } else if (RuntimeInformation.IsDebugBuild) { Log.LogError("DataProviderRegistry", string.Format("Failed to load the configuration section '{0}' from the configuration", DataProviderSettings.SectionName)); } } }
public bool EnsureDataStores() { if (!DataProviderPluginFacade.HasConfiguration()) { Log.LogError(LogTitle, "Failed to load the configuration section '{0}' from the configuration", DataProviderSettings.SectionName); return(false); } var typeDescriptors = new List <DataTypeDescriptor>(); foreach (Type type in _interfaceTypes) { try { if (!DataProviderRegistry.AllKnownInterfaces.Contains(type)) { var dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(type); dataTypeDescriptor.Validate(); typeDescriptors.Add(dataTypeDescriptor); } } catch (Exception ex) { throw new InvalidOperationException(string.Format("Failed to validate type '{0}'", type), ex); } } if (typeDescriptors.Any()) { DataProviderPluginFacade.CreateStores(DataProviderRegistry.DefaultDynamicTypeDataProviderName, typeDescriptors); string typeNames = string.Join(", ", typeDescriptors.Select(t => t.GetFullInterfaceName())); Log.LogVerbose(LogTitle, "Stores for the following data types were created: " + typeNames); } return(typeDescriptors.Count > 0); }
/// <exclude /> public void CreateStores(string providerName, IReadOnlyCollection <DataTypeDescriptor> typeDescriptors, bool doFlush) { Verify.ArgumentNotNullOrEmpty(providerName, "providerName"); Verify.ArgumentNotNull(typeDescriptors, "typeDescriptors"); typeDescriptors.ForEach(d => d.Validate()); using (var transactionScope = TransactionsFacade.CreateNewScope()) { foreach (var typeDescriptor in typeDescriptors) { DataMetaDataFacade.PersistMetaData(typeDescriptor); } DataProviderPluginFacade.CreateStores(providerName, typeDescriptors); transactionScope.Complete(); } if (doFlush) { GlobalEventSystemFacade.FlushTheSystem(); } }
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); }
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); }
private void CopyData(Type interfaceType) { IWritableDataProvider targetDataProvider = DataProviderPluginFacade.GetDataProvider(TargetProviderName) as IWritableDataProvider; Verify.IsNotNull(targetDataProvider, "Failed to get target data provider, probably it's not writeable."); foreach (DataScopeIdentifier dataScopeIdentifier in interfaceType.GetSupportedDataScopes()) { Log.LogVerbose(LogTitle, "Copying scope '{0}' data for type '{1}'".FormatWith(dataScopeIdentifier.Name, interfaceType.FullName)); foreach (CultureInfo cultureInfo in GetSupportedCultures(interfaceType)) { using (new DataScope(dataScopeIdentifier, cultureInfo)) { List <IData> dataset; try { dataset = DataFacade.GetData(interfaceType, SourceProviderName).ToDataList(); if (_specialHandleInterfaces.ContainsKey(interfaceType)) { _specialHandleInterfaces[interfaceType](dataset, this.SourceProviderName, this.TargetProviderName); } } catch (Exception) { Log.LogCritical(LogTitle, "Failed to read data from type '{0}'. See the log for the details." .FormatWith(interfaceType.FullName)); throw; } List <IData> filteredDataset = null; HashSet <string> dataIDs = null; if (IgnorePrimaryKeyViolation) { filteredDataset = new List <IData>(); dataIDs = new HashSet <string>(); } foreach (var data in dataset) { if (IgnorePrimaryKeyViolation) { string dataId = data.DataSourceId.ToString(); if (dataIDs.Contains(dataId)) { LoggingService.LogWarning(LogTitle, "Cannot insert a data row, since it's data ID is already used. DataID: '{0}'".FormatWith(dataId)); continue; } dataIDs.Add(dataId); filteredDataset.Add(data); } FixData(data); } if (IgnorePrimaryKeyViolation) { dataIDs = null; dataset = filteredDataset; } try { AddData(interfaceType, dataset, targetDataProvider); } catch (Exception e) { Log.LogError(LogTitle, $"Adding failed while adding {interfaceType.Namespace}.{interfaceType.Name} because {e.Message}"); Log.LogError(LogTitle, e.InnerException); throw; } } } } }
private void Delete <T>(IEnumerable <T> dataset, bool suppressEventing, CascadeDeleteType cascadeDeleteType, bool referencesFromAllScopes, HashSet <DataSourceId> dataPendingDeletion) where T : class, IData { Verify.ArgumentNotNull(dataset, nameof(dataset)); dataset = dataset.Evaluate(); foreach (var data in dataset) { var dataSourceId = data.DataSourceId; if (!dataPendingDeletion.Contains(dataSourceId)) { dataPendingDeletion.Add(dataSourceId); } } if (cascadeDeleteType != CascadeDeleteType.Disable) { foreach (IData element in dataset) { Verify.ArgumentCondition(element != null, nameof(dataset), "dataset may not contain nulls"); if (!element.IsDataReferred()) { continue; } Type interfaceType = element.DataSourceId.InterfaceType; // Not deleting references if the data is versioned and not all of the // versions of the element are to be deleted if (element is IVersioned) { var key = element.GetUniqueKey(); var versions = DataFacade.TryGetDataVersionsByUniqueKey(interfaceType, key).ToList(); if (versions.Count > 1 && (dataset.Count() < versions.Count || !versions.All(v => dataPendingDeletion.Contains(v.DataSourceId)))) { continue; } } Verify.IsTrue(cascadeDeleteType != CascadeDeleteType.Disallow, "One of the given datas is referenced by one or more datas"); element.RemoveOptionalReferences(); IEnumerable <IData> referees; using (new DataScope(element.DataSourceId.DataScopeIdentifier)) { // For some weird reason, this line does not work.... /MRJ // IEnumerable<IData> referees = dataset.GetRefereesRecursively(); referees = element.GetReferees(referencesFromAllScopes) .Where(reference => !dataPendingDeletion.Contains(reference.DataSourceId)) .Evaluate(); } foreach (IData referee in referees) { if (!referee.CascadeDeleteAllowed(interfaceType)) { throw new InvalidOperationException("One of the given datas is referenced by one or more datas that does not allow cascade delete"); } } Delete <IData>(referees, suppressEventing, cascadeDeleteType, referencesFromAllScopes); } } Dictionary <string, Dictionary <Type, List <IData> > > sortedDatas = dataset.ToDataProviderAndInterfaceTypeSortedDictionary(); foreach (KeyValuePair <string, Dictionary <Type, List <IData> > > providerPair in sortedDatas) { foreach (KeyValuePair <Type, List <IData> > interfaceTypePair in providerPair.Value) { DataProviderPluginFacade.Delete(providerPair.Key, interfaceTypePair.Value.Select(d => d.DataSourceId)); if (DataCachingFacade.IsTypeCacheable(interfaceTypePair.Key)) { DataCachingFacade.ClearCache(interfaceTypePair.Key, interfaceTypePair.Value.First().DataSourceId.DataScopeIdentifier); } } } if (!suppressEventing) { foreach (IData element in dataset) { DataEventSystemFacade.FireDataDeletedEvent(element.DataSourceId.InterfaceType, element); } } }
public void Update(IEnumerable <IData> dataset, bool suppressEventing, bool performForeignKeyIntegrityCheck, bool performValidation) { Verify.ArgumentNotNull(dataset, "dataset"); var sortedDataset = dataset.ToDataProviderAndInterfaceTypeSortedDictionary(); if (!suppressEventing) { foreach (IData data in dataset) { DataEventSystemFacade.FireDataBeforeUpdateEvent(data.DataSourceId.InterfaceType, data); } } foreach (IData data in dataset) { if (performValidation) { CheckValidationResult(ValidationFacade.Validate(data), data.DataSourceId.InterfaceType); } if (performForeignKeyIntegrityCheck) { data.ValidateForeignKeyIntegrity(); } } foreach (KeyValuePair <string, Dictionary <Type, List <IData> > > providerPair in sortedDataset) { foreach (KeyValuePair <Type, List <IData> > interfaceTypePair in providerPair.Value) { List <IData> dataToUpdate = interfaceTypePair.Value; if (DataCachingFacade.IsTypeCacheable(interfaceTypePair.Key)) { List <IData> newDataToUpdate = new List <IData>(); foreach (IData d in interfaceTypePair.Value) { newDataToUpdate.Add(DataWrappingFacade.UnWrap(d)); } dataToUpdate = newDataToUpdate; } DataProviderPluginFacade.Update(providerPair.Key, dataToUpdate); if (DataCachingFacade.IsTypeCacheable(interfaceTypePair.Key)) { DataCachingFacade.ClearCache(interfaceTypePair.Key); } } } if (!suppressEventing) { foreach (IData data in dataset) { DataEventSystemFacade.FireDataAfterUpdateEvent(data.DataSourceId.InterfaceType, data); } } }
public bool ValidatePath <TFile>(TFile file, string providerName, out string errorMessage) where TFile : IFile { return(DataProviderPluginFacade.ValidatePath <TFile>(file, providerName, out errorMessage)); }
private void BuildDictionaries() { using (TimerProfilerFacade.CreateTimerProfiler("Adding supported types")) { foreach (string providerName in _dataProviderNames) { IEnumerable <Type> types = DataProviderPluginFacade.GetSupportedInterfaces(providerName); bool writeableProvider = DataProviderPluginFacade.IsWriteableProvider(providerName); foreach (Type type in types) { AddType(type, providerName, writeableProvider); } if (DataProviderPluginFacade.IsGeneratedTypesProvider(providerName)) { IEnumerable <Type> generatedTypes = DataProviderPluginFacade.GetGeneratedInterfaces(providerName); foreach (Type type in generatedTypes) { AddType(type, providerName, writeableProvider); if (!_generatedInterfaceTypes.Contains(type)) { _generatedInterfaceTypes.Add(type); } } } } } using (TimerProfilerFacade.CreateTimerProfiler("Adding known interfaces")) { foreach (string providerName in _dataProviderNames) { if (DataProviderPluginFacade.IsDynamicProvider(providerName)) { IEnumerable <Type> knownTypes = DataProviderPluginFacade.GetKnownInterfaces(providerName); foreach (Type knownType in knownTypes) { if (!_interfaceTypeToReadableProviderNames.Keys.Contains(knownType)) { List <string> providerNames; if (!_knownInterfaceTypeToDynamicProviderNames.TryGetValue(knownType, out providerNames)) { providerNames = new List <string>(); _knownInterfaceTypeToDynamicProviderNames.Add(knownType, providerNames); if (RuntimeInformation.IsDebugBuild) { Log.LogVerbose("DataProviderRegistry", "Adding known IData interface: {0}", knownType); } } providerNames.Add(providerName); } } } } } }
public void GetCodeToCompile(CodeGenerationBuilder builder) { var sqlDataProvider = (SqlDataProvider)DataProviderPluginFacade.GetDataProvider(ProviderName); sqlDataProvider.BuildAllCode(builder); }
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 void Delete <T>(IEnumerable <T> dataset, bool suppressEventing, CascadeDeleteType cascadeDeleteType, bool referencesFromAllScopes, HashSet <DataSourceId> dataPendingDeletion) where T : class, IData { Verify.ArgumentNotNull(dataset, nameof(dataset)); dataset = dataset.Evaluate(); foreach (var data in dataset) { var dataSourceId = data.DataSourceId; if (!dataPendingDeletion.Contains(dataSourceId)) { dataPendingDeletion.Add(dataSourceId); } } if (cascadeDeleteType != CascadeDeleteType.Disable) { foreach (IData data in dataset) { Verify.ArgumentCondition(data != null, nameof(dataset), "dataset may not contain nulls"); Type interfaceType = data.DataSourceId.InterfaceType; // Not deleting references if the data is versioned and not all of the // versions of the element are to be deleted if (data is IVersioned && interfaceType.GetKeyProperties().Count == 1) { var key = data.GetUniqueKey(); var versions = DataFacade.TryGetDataVersionsByUniqueKey(interfaceType, key).ToList(); if (versions.Count > 1 && (dataset.Count() < versions.Count || !versions.All(v => dataPendingDeletion.Contains(v.DataSourceId)))) { continue; } } using (new DataScope(data.DataSourceId.DataScopeIdentifier)) { var allReferences = DataReferenceFacade.GetRefereesInt(data, referencesFromAllScopes, (a, b) => true); if (allReferences.Count == 0) { continue; } Verify.IsTrue(cascadeDeleteType != CascadeDeleteType.Disallow, "One of the given datas is referenced by one or more datas"); var optionalReferences = allReferences.Where(kvp => kvp.Item2.IsOptionalReference); var notOptionalReferences = allReferences.Where(kvp => !kvp.Item2.IsOptionalReference && !dataPendingDeletion.Contains(kvp.Item1.DataSourceId)).Evaluate(); foreach (var reference in optionalReferences) { var referee = reference.Item1; reference.Item2.SourcePropertyInfo.SetValue(referee, null, null); DataFacade.Update(referee, false, true, false); } foreach (var refereeInfo in notOptionalReferences) { if (!refereeInfo.Item2.AllowCascadeDeletes) { throw new InvalidOperationException("One of the given data items is referenced by one or more data items that do not allow cascade delete."); } } var toDelete = notOptionalReferences.Select(_ => _.Item1); Delete <IData>(toDelete, suppressEventing, cascadeDeleteType, referencesFromAllScopes); } } } Dictionary <string, Dictionary <Type, List <IData> > > sortedDatas = dataset.ToDataProviderAndInterfaceTypeSortedDictionary(); foreach (KeyValuePair <string, Dictionary <Type, List <IData> > > providerPair in sortedDatas) { foreach (KeyValuePair <Type, List <IData> > interfaceTypePair in providerPair.Value) { DataProviderPluginFacade.Delete(providerPair.Key, interfaceTypePair.Value.Select(d => d.DataSourceId)); if (DataCachingFacade.IsTypeCacheable(interfaceTypePair.Key)) { DataCachingFacade.RemoveFromCache(interfaceTypePair.Value); } } } if (!suppressEventing) { foreach (IData element in dataset) { DataEventSystemFacade.FireDataDeletedEvent(element.DataSourceId.InterfaceType, element); } } }