static DataLocalizationFacadeImpl() { DataEventSystemFacade.SubscribeToDataAfterUpdate <ISystemActiveLocale>(OnSystemActiveLocaleChanged, true); DataEventSystemFacade.SubscribeToDataAfterAdd <ISystemActiveLocale>(OnSystemActiveLocaleChanged, true); DataEventSystemFacade.SubscribeToDataDeleted <ISystemActiveLocale>(OnSystemActiveLocaleChanged, true); DataEventSystemFacade.SubscribeToStoreChanged <ISystemActiveLocale>(OnSystemActiveLocaleStoreChanged, true); }
static DataFacadeImpl() { DataEventSystemFacade.SubscribeToDataAfterUpdate <IData>(OnDataChanged, true); DataEventSystemFacade.SubscribeToDataDeleted <IData>(OnDataChanged, true); DataEventSystemFacade.SubscribeToDataBeforeAdd <IData>(SetChangeHistoryInformation, true); DataEventSystemFacade.SubscribeToDataBeforeUpdate <IData>(SetChangeHistoryInformation, true); }
private static void SubscribeToEvents() { DataEventSystemFacade.SubscribeToDataDeleted <IPagePlaceholderContent>(OnPagePlaceholderChanged, true); DataEventSystemFacade.SubscribeToDataAfterUpdate <IPagePlaceholderContent>(OnPagePlaceholderChanged, true); DataEventSystemFacade.SubscribeToDataAfterAdd <IPagePlaceholderContent>(OnPagePlaceholderChanged, true); DataEventSystemFacade.SubscribeToStoreChanged <IPagePlaceholderContent>(OnPagePlaceholderStoreChanged, true); DataEventSystemFacade.SubscribeToDataAfterUpdate <IPage>(OnPageChanged, true); DataEventSystemFacade.SubscribeToDataAfterAdd <IPage>(OnPageChanged, true); DataEventSystemFacade.SubscribeToDataDeleted <IPage>(OnPageChanged, true); DataEventSystemFacade.SubscribeToStoreChanged <IPage>(OnPageStoreChanged, true); DataEventSystemFacade.SubscribeToDataAfterAdd <IPageStructure>(OnPageStructureChanged, true); DataEventSystemFacade.SubscribeToDataAfterUpdate <IPageStructure>(OnPageStructureChanged, true); DataEventSystemFacade.SubscribeToDataDeleted <IPageStructure>(OnPageStructureChanged, true); DataEventSystemFacade.SubscribeToStoreChanged <IPageStructure>(OnPageStructureStoreChanged, true); }
public T BuildNew <T>(bool suppressEventing) where T : class, IData { ValidateBuildNewType(typeof(T)); Type generatedType = DataTypeTypesManager.GetDataTypeEmptyClass(typeof(T)); IData data = (IData)Activator.CreateInstance(generatedType, new object[] { }); SetNewInstanceFieldDefaultValues(data); if (suppressEventing == false) { DataEventSystemFacade.FireDataAfterBuildNewEvent <T>(data); } return((T)data); }
public IData BuildNew(Type interfaceType, bool suppressEventling) { if (interfaceType == null) { throw new ArgumentNullException("interfaceType"); } ValidateBuildNewType(interfaceType); Type generatedType = DataTypeTypesManager.GetDataTypeEmptyClass(interfaceType); IData data = (IData)Activator.CreateInstance(generatedType, new object[] { }); SetNewInstanceFieldDefaultValues(data); if (!suppressEventling) { DataEventSystemFacade.FireDataAfterBuildNewEvent(generatedType, data); } return(data); }
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); } } }
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 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); } } }
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); } } }