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