// Helper internal static bool EnsureUpdateStore(Type interfaceType, string providerName, bool makeAFlush) { using (TimerProfilerFacade.CreateTimerProfiler(interfaceType.ToString())) { var newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType); var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId); if (oldDataTypeDescriptor == null) { DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor); return(false); } var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor); if (!dataTypeChangeDescriptor.AlteredTypeHasChanges) { return(false); } Log.LogVerbose("DynamicTypeManager", "Updating the store for interface type '{0}' on the '{1}' data provider", interfaceType, providerName); var updateDataTypeDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor, providerName); AlterStore(updateDataTypeDescriptor, makeAFlush); return(true); } }
// Helper internal static bool IsEnsureUpdateStoreNeeded(Type interfaceType) { using (TimerProfilerFacade.CreateTimerProfiler()) { DataTypeDescriptor newDataTypeDescriptor; if (!TryGetDataTypeDescriptor(interfaceType, out newDataTypeDescriptor)) { newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType); } var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId); if (oldDataTypeDescriptor == null) { DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor); return(false); } var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor); if (!dataTypeChangeDescriptor.AlteredTypeHasChanges) { return(false); } return(dataTypeChangeDescriptor.AlteredTypeHasChanges); } }
// Helper internal static bool EnsureUpdateStore(Type interfaceType, string providerName, bool makeAFlush) { using (TimerProfilerFacade.CreateTimerProfiler(interfaceType.ToString())) { var newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType); var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId); if (interfaceType.IsGenerated()) { var customFields = oldDataTypeDescriptor.Fields.Where(f => !f.Inherited && !oldDataTypeDescriptor.KeyPropertyNames .Contains(f.Name)); foreach (var field in customFields) { newDataTypeDescriptor.Fields.Remove(newDataTypeDescriptor.Fields[field.Name]); newDataTypeDescriptor.Fields.Add(field); } } if (oldDataTypeDescriptor == null) { DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor); return(false); } var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor); if (!dataTypeChangeDescriptor.AlteredTypeHasChanges) { if (dataTypeChangeDescriptor.TypeHasMetaDataChanges) { Log.LogInformation(nameof(DynamicTypeManager), $"Updating data type descriptor for type '{newDataTypeDescriptor.GetFullInterfaceName()}'"); DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor); } return(false); } Log.LogVerbose(nameof(DynamicTypeManager), "Updating the store for interface type '{0}' on the '{1}' data provider", interfaceType, providerName); var updateDataTypeDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor, providerName); AlterStore(updateDataTypeDescriptor, makeAFlush); return(true); } }
/// <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(); } }
internal static InterfaceConfigurationElement Change(string providerName, DataTypeChangeDescriptor changeDescriptor, bool localeChanges) { lock (_syncRoot) { var originalType = changeDescriptor.OriginalType; var alteredType = changeDescriptor.AlteredType; bool typeNameChanged = originalType.Namespace != alteredType.Namespace || originalType.Name != alteredType.Name; if (!localeChanges && !changeDescriptor.AddedDataScopes.Any() && !changeDescriptor.DeletedDataScopes.Any() && !changeDescriptor.AddedKeyFields.Any() && !changeDescriptor.DeletedKeyFields.Any() && !changeDescriptor.KeyFieldsOrderChanged && !typeNameChanged) { // No changes to the config is needed, lets not touch the file. return null; } var configuration = new SqlDataProviderConfiguration(providerName); Guid dataTypeId = originalType.DataTypeId; var existingElement = configuration.Section.Interfaces.Get(originalType); Verify.IsNotNull(existingElement, "Configuration does not contain the original interface with id '{0}'", dataTypeId); configuration.Section.Interfaces.Remove(originalType); InterfaceConfigurationElement newInterfaceConfig = BuildInterfaceConfigurationElement(alteredType, existingElement, typeNameChanged); configuration.Section.Interfaces.Add(newInterfaceConfig); configuration.Save(); return newInterfaceConfig; } }
private void AlterScopeData(UpdateDataTypeDescriptor updateDataTypeDescriptor, DataTypeChangeDescriptor changeDescriptor, DataScopeIdentifier dataScope) { var culturesToDelete = new List<CultureInfo>(); var culturesToChange = new List<CultureInfo>(); var oldCultures = GetCultures(changeDescriptor.OriginalType).Evaluate(); var newCultures = GetCultures(changeDescriptor.AlteredType).Evaluate(); foreach (var culture in oldCultures) { if (newCultures.Contains(culture)) { culturesToChange.Add(culture); } else { culturesToDelete.Add(culture); } } var culturesToAdd = newCultures.Where(culture => !oldCultures.Contains(culture)).ToList(); culturesToAdd.ForEach(culture => CreateStore(changeDescriptor.AlteredType, dataScope, culture)); culturesToChange.ForEach(culture => AlterStore(updateDataTypeDescriptor, changeDescriptor, dataScope, culture)); if (updateDataTypeDescriptor.LocalesToCopyTo != null) { StringBuilder fieldList = GetCommonFields(changeDescriptor); string fromTableName = GetConfiguredTableName(changeDescriptor.OriginalType, dataScope, ""); foreach (CultureInfo locale in updateDataTypeDescriptor.LocalesToCopyTo) { string toTableName = DynamicTypesCommon.GenerateTableName(changeDescriptor.AlteredType, dataScope, locale); string copyCommandText = string.Format(@" INSERT INTO [{0}] ({2}) SELECT {2} FROM [{1}];", toTableName, fromTableName, fieldList); ExecuteNonQuery(copyCommandText); string updateCommandText = string.Format("UPDATE [{0}] SET [{1}] = '{2}'", toTableName, "SourceCultureName", locale.Name); ExecuteNonQuery(updateCommandText); } string removeCommandText = string.Format(@"DELETE FROM [{0}];", fromTableName); ExecuteNonQuery(removeCommandText); } if (updateDataTypeDescriptor.LocaleToCopyFrom != null) { StringBuilder fieldList = GetCommonFields(changeDescriptor); string fromTableName = GetConfiguredTableName(changeDescriptor.OriginalType, dataScope, updateDataTypeDescriptor.LocaleToCopyFrom.Name); string toTableName = DynamicTypesCommon.GenerateTableName(changeDescriptor.AlteredType, dataScope, CultureInfo.InvariantCulture); string copyCommandText = string.Format(@" INSERT INTO [{0}] ({2}) SELECT {2} FROM [{1}];", toTableName, fromTableName, fieldList); ExecuteNonQuery(copyCommandText); } culturesToDelete.ForEach(culture => DropStore(changeDescriptor.OriginalType, dataScope, culture)); }
private static StringBuilder GetCommonFields(DataTypeChangeDescriptor changeDescriptor) { var fieldList = new StringBuilder(); foreach (DataFieldDescriptor dataFieldDescriptor in changeDescriptor.OriginalType.Fields) { if (!changeDescriptor.AlteredType.Fields.Any(f => f.Id == dataFieldDescriptor.Id)) continue; if (fieldList.Length > 0) fieldList.Append(", "); fieldList.Append("[" + dataFieldDescriptor.Name + "]"); } return fieldList; }
private static DataTypeChangeDescriptor.ExistingFieldInfo GetExistingFieldInfo(DataTypeChangeDescriptor dataTypeChangeDescriptor, string name) { return dataTypeChangeDescriptor.ExistingFields.FirstOrDefault(f => f.OriginalField.Name == name); }
private static void CopyData(string providerName, DataTypeChangeDescriptor dataTypeChangeDescriptor, DataScopeConfigurationElement oldDataScopeConfigurationElement, DataScopeConfigurationElement newDataScopeConfigurationElement, Dictionary<string, object> newFieldValues, bool deleteOldFile = true) { string oldFilename = ResolvePath(oldDataScopeConfigurationElement.Filename, providerName); string newFilename = ResolvePath(newDataScopeConfigurationElement.Filename, providerName); XDocument oldDocument = XDocumentUtils.Load(PathUtil.Resolve(oldFilename)); List<XElement> newElements = new List<XElement>(); foreach (XElement oldElement in oldDocument.Root.Elements()) { List<XAttribute> newChildAttributes = new List<XAttribute>(); foreach (XAttribute oldChildAttribute in oldElement.Attributes()) { var existingFieldInfo = GetExistingFieldInfo(dataTypeChangeDescriptor, oldChildAttribute.Name.LocalName); if (existingFieldInfo != null) { if (existingFieldInfo.OriginalField.Name != existingFieldInfo.AlteredField.Name) { XAttribute newChildAttribute = new XAttribute(existingFieldInfo.AlteredField.Name, oldChildAttribute.Value); newChildAttributes.Add(newChildAttribute); } else { newChildAttributes.Add(oldChildAttribute); } } // It may happen that some data were added before data descriptors are updated, in the case of using // [AutoUpdateable] attribute. else if (dataTypeChangeDescriptor.AddedFields.Any(addedField => addedField.Name == oldChildAttribute.Name)) { newChildAttributes.Add(oldChildAttribute); } } // Adding default value for fields that are NULL and become required foreach (var existingFieldInfo in dataTypeChangeDescriptor.ExistingFields) { bool fieldBecomeRequired = existingFieldInfo.OriginalField.IsNullable && !existingFieldInfo.AlteredField.IsNullable; string fieldName = existingFieldInfo.AlteredField.Name; if (fieldBecomeRequired && !newChildAttributes.Any(attr => attr.Name.LocalName == fieldName)) { newChildAttributes.Add(new XAttribute(fieldName, GetDefaultValue(existingFieldInfo.AlteredField))); } } foreach (DataFieldDescriptor fieldDescriptor in dataTypeChangeDescriptor.AddedFields) { if (fieldDescriptor.IsNullable == false && !newChildAttributes.Any(attr => attr.Name == fieldDescriptor.Name)) { XAttribute newChildAttribute = new XAttribute(fieldDescriptor.Name, GetDefaultValue(fieldDescriptor)); if (newFieldValues.ContainsKey(fieldDescriptor.Name)) { newChildAttribute.SetValue(newFieldValues[fieldDescriptor.Name]); } newChildAttributes.Add(newChildAttribute); } else if (newFieldValues.ContainsKey(fieldDescriptor.Name)) { XAttribute attribute = newChildAttributes.SingleOrDefault(attr => attr.Name == fieldDescriptor.Name); if (attribute != null) { attribute.SetValue(newFieldValues[fieldDescriptor.Name]); } } } XElement newElement = new XElement(newDataScopeConfigurationElement.ElementName, newChildAttributes); newElements.Add(newElement); } if (deleteOldFile) { C1File.Delete(oldFilename); } XElement newRoot = new XElement(XmlDataProviderDocumentWriter.GetRootElementName(newDataScopeConfigurationElement.ElementName)); newRoot.Add(newElements); XDocument newDocument = new XDocument(); newDocument.Add(newRoot); XDocumentUtils.Save(newDocument, newFilename); }
private static void CopyData(string providerName, DataTypeChangeDescriptor dataTypeChangeDescriptor, DataScopeConfigurationElement oldDataScopeConfigurationElement, DataScopeConfigurationElement newDataScopeConfigurationElement, Dictionary<string, object> newFieldValues, bool deleteOldFile = true) { string oldFilename = ResolvePath(oldDataScopeConfigurationElement.Filename, providerName); string newFilename = ResolvePath(newDataScopeConfigurationElement.Filename, providerName); XDocument oldDocument = XDocumentUtils.Load(PathUtil.Resolve(oldFilename)); List<XElement> newElements = new List<XElement>(); bool addingVersionId = dataTypeChangeDescriptor.AddedFields.Any(f => f.Name == nameof(IVersioned.VersionId)) && dataTypeChangeDescriptor.AlteredType.SuperInterfaces.Any(s => s == typeof (IVersioned)); string versionIdSourceFieldName = null; if (addingVersionId) { if (dataTypeChangeDescriptor.AlteredType.DataTypeId == typeof(IPage).GetImmutableTypeId()) { versionIdSourceFieldName = nameof(IPage.Id); } else { versionIdSourceFieldName = dataTypeChangeDescriptor.AlteredType.Fields .Where(f => f.InstanceType == typeof(Guid) && (f.ForeignKeyReferenceTypeName?.Contains(typeof(IPage).FullName) ?? false)) .OrderByDescending(f => f.Name == nameof(IPageData.PageId)) .Select(f => f.Name) .FirstOrDefault(); } } foreach (XElement oldElement in oldDocument.Root.Elements()) { List<XAttribute> newChildAttributes = new List<XAttribute>(); foreach (XAttribute oldChildAttribute in oldElement.Attributes()) { var existingFieldInfo = GetExistingFieldInfo(dataTypeChangeDescriptor, oldChildAttribute.Name.LocalName); if (existingFieldInfo != null) { if (existingFieldInfo.OriginalField.Name != existingFieldInfo.AlteredField.Name) { XAttribute newChildAttribute = new XAttribute(existingFieldInfo.AlteredField.Name, oldChildAttribute.Value); newChildAttributes.Add(newChildAttribute); } else { newChildAttributes.Add(oldChildAttribute); } } // It may happen that some data were added before data descriptors are updated, in the case of using // [AutoUpdateable] attribute. else if (dataTypeChangeDescriptor.AddedFields.Any(addedField => addedField.Name == oldChildAttribute.Name)) { newChildAttributes.Add(oldChildAttribute); } } // Adding default value for fields that are NULL and become required foreach (var existingFieldInfo in dataTypeChangeDescriptor.ExistingFields) { bool fieldBecomeRequired = existingFieldInfo.OriginalField.IsNullable && !existingFieldInfo.AlteredField.IsNullable; string fieldName = existingFieldInfo.AlteredField.Name; if (fieldBecomeRequired && !newChildAttributes.Any(attr => attr.Name.LocalName == fieldName)) { newChildAttributes.Add(new XAttribute(fieldName, GetDefaultValue(existingFieldInfo.AlteredField))); } } foreach (DataFieldDescriptor fieldDescriptor in dataTypeChangeDescriptor.AddedFields) { if (addingVersionId && fieldDescriptor.Name == nameof(IVersioned.VersionId) && versionIdSourceFieldName != null) { if (!oldElement.Attributes().Any(a => a.Name.LocalName == nameof(IVersioned.VersionId))) { var sourceFieldValue = (Guid)oldElement.Attribute(versionIdSourceFieldName); newChildAttributes.Add(new XAttribute(fieldDescriptor.Name, sourceFieldValue)); } continue; } if (!fieldDescriptor.IsNullable && !newChildAttributes.Any(attr => attr.Name == fieldDescriptor.Name)) { object value; if (!newFieldValues.TryGetValue(fieldDescriptor.Name, out value)) { value = GetDefaultValue(fieldDescriptor); } newChildAttributes.Add(new XAttribute(fieldDescriptor.Name, value)); } else if (newFieldValues.ContainsKey(fieldDescriptor.Name)) { XAttribute attribute = newChildAttributes.SingleOrDefault(attr => attr.Name == fieldDescriptor.Name); attribute?.SetValue(newFieldValues[fieldDescriptor.Name]); } } XElement newElement = new XElement(newDataScopeConfigurationElement.ElementName, newChildAttributes); newElements.Add(newElement); } if (deleteOldFile) { C1File.Delete(oldFilename); } var newDocument = new XDocument( new XElement(XmlDataProviderDocumentWriter.GetRootElementName(newDataScopeConfigurationElement.ElementName), newElements)); XDocumentUtils.Save(newDocument, newFilename); }
private void HandleDisablingOfPublication(DataTypeChangeDescriptor changeDescriptor) { IEnumerable<CultureInfo> locales = GetCultures(changeDescriptor.OriginalType); foreach (CultureInfo locale in locales) { string oldTableName = GetConfiguredTableName(changeDescriptor.OriginalType, DataScopeIdentifier.Administrated, locale.Name); string newTableName = DynamicTypesCommon.GenerateTableName(changeDescriptor.AlteredType, DataScopeIdentifier.Public, locale); StringBuilder fieldList = GetCommonFields(changeDescriptor); string removeCommandText = string.Format(@"DELETE FROM [{0}];", newTableName); ExecuteNonQuery(removeCommandText); string copyCommandText = string.Format(@" INSERT INTO [{0}] ({2}) SELECT {2} FROM [{1}];", newTableName, oldTableName, fieldList); ExecuteNonQuery(copyCommandText); } }
// Helper internal static bool EnsureUpdateStore(Type interfaceType, string providerName, bool makeAFlush) { using (TimerProfilerFacade.CreateTimerProfiler(interfaceType.ToString())) { var newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType); var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId); if (oldDataTypeDescriptor == null) { DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor); return false; } var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor); if (!dataTypeChangeDescriptor.AlteredTypeHasChanges) return false; Log.LogVerbose("DynamicTypeManager", "Updating the store for interface type '{0}' on the '{1}' data provider", interfaceType, providerName); var updateDataTypeDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor, providerName); AlterStore(updateDataTypeDescriptor, makeAFlush); return true; } }
internal static InterfaceConfigurationElement RefreshLocalizationInfo(string providerName, DataTypeDescriptor dataTypeDescriptor) { var changeDescriptor = new DataTypeChangeDescriptor(dataTypeDescriptor, dataTypeDescriptor); return Change(providerName, changeDescriptor, true); }
private void AlterStore(UpdateDataTypeDescriptor updateDataTypeDescriptor, DataTypeChangeDescriptor changeDescriptor, DataScopeIdentifier dataScope, CultureInfo culture) { try { string originalTableName = GetConfiguredTableName(changeDescriptor.OriginalType, dataScope, culture.Name); string alteredTableName = originalTableName; // This could be done more nicely! But only give the table a new name if the type has changed its name and not because we changed the naming scheme if (updateDataTypeDescriptor.OldDataTypeDescriptor.Name != updateDataTypeDescriptor.NewDataTypeDescriptor.Name || updateDataTypeDescriptor.OldDataTypeDescriptor.Namespace != updateDataTypeDescriptor.NewDataTypeDescriptor.Namespace) { alteredTableName = DynamicTypesCommon.GenerateTableName(changeDescriptor.AlteredType, dataScope, culture); } var tables = GetTablesList(); if (!tables.Contains(originalTableName)) { throw new InvalidOperationException( string.Format( "Unable to alter data type store. The database does not contain expected table {0}", originalTableName)); } bool primaryKeyChanged = changeDescriptor.AddedKeyFields.Any() || changeDescriptor.DeletedKeyFields.Any() || changeDescriptor.KeyFieldsOrderChanged || changeDescriptor.OriginalType.PrimaryKeyIsClusteredIndex != changeDescriptor.AlteredType.PrimaryKeyIsClusteredIndex; DropConstraints(originalTableName, primaryKeyChanged); if (originalTableName != alteredTableName) { if (tables.Contains(alteredTableName)) throw new InvalidOperationException( string.Format("Can not rename table to {0}. A table with that name already exists", alteredTableName)); RenameTable(originalTableName, alteredTableName); } var newIndexes = changeDescriptor.AlteredType.Indexes.Select(i => i.ToString()).ToList(); foreach (var oldIndex in changeDescriptor.OriginalType.Indexes) { if (!newIndexes.Contains(oldIndex.ToString())) { DropIndex(alteredTableName, oldIndex); } } DropFields(alteredTableName, changeDescriptor.DeletedFields, changeDescriptor.OriginalType.Fields); ImplementFieldChanges(alteredTableName, changeDescriptor.ExistingFields); Dictionary<string, object> defaultValues = null; if (updateDataTypeDescriptor.PublicationAdded) { defaultValues = new Dictionary<string, object> { {"PublicationStatus", GenericPublishProcessController.Draft} }; } AppendFields(alteredTableName, changeDescriptor, changeDescriptor.AddedFields, defaultValues); // Clustered index has to be created first. var createIndexActions = new List<Tuple<bool, Action>>(); if (primaryKeyChanged) { bool isClusteredIndex = changeDescriptor.AlteredType.PrimaryKeyIsClusteredIndex; createIndexActions.Add(new Tuple<bool, Action>(isClusteredIndex, () => ExecuteNonQuery(SetPrimaryKey(alteredTableName, changeDescriptor.AlteredType.PhysicalKeyPropertyNames, isClusteredIndex)) )); } var oldIndexes = changeDescriptor.OriginalType.Indexes.Select(i => i.ToString()).ToList(); foreach (var newIndex in changeDescriptor.AlteredType.Indexes) { if (!oldIndexes.Contains(newIndex.ToString())) { var index = newIndex; createIndexActions.Add(new Tuple<bool, Action>(newIndex.Clustered, () => CreateIndex(alteredTableName, index))); } } createIndexActions.Sort((a, b) => b.Item1.CompareTo(a.Item1)); foreach (var createIndex in createIndexActions) { createIndex.Item2(); } SqlTableInformationStore.ClearCache(_connectionString, originalTableName); SqlTableInformationStore.ClearCache(_connectionString, alteredTableName); } catch (Exception ex) { throw MakeVerboseException(ex); } }
// Helper internal static bool IsEnsureUpdateStoreNeeded(Type interfaceType) { using (TimerProfilerFacade.CreateTimerProfiler()) { DataTypeDescriptor newDataTypeDescriptor; if (!TryGetDataTypeDescriptor(interfaceType, out newDataTypeDescriptor)) { newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType); } var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId); if (oldDataTypeDescriptor == null) { DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor); return false; } var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor); if (!dataTypeChangeDescriptor.AlteredTypeHasChanges) { return false; } return dataTypeChangeDescriptor.AlteredTypeHasChanges; } }
private void AppendFields(string tableName, DataTypeChangeDescriptor changeDescriptor, IEnumerable<DataFieldDescriptor> addedFieldDescriptions, Dictionary<string, object> defaultValues = null) { foreach (var addedFieldDescriptor in addedFieldDescriptions) { object defaultValue = null; if (defaultValues != null && defaultValues.ContainsKey(addedFieldDescriptor.Name)) { defaultValue = defaultValues[addedFieldDescriptor.Name]; } CreateColumn(tableName, addedFieldDescriptor, defaultValue); // Updating VersionId field if (addedFieldDescriptor.Name == nameof(IVersioned.VersionId) && changeDescriptor.AlteredType.SuperInterfaces.Contains(typeof (IVersioned))) { string sourceField; if (changeDescriptor.AlteredType.DataTypeId == typeof (IPage).GetImmutableTypeId()) { sourceField = nameof(IPage.Id); } else { sourceField = changeDescriptor.AlteredType.Fields .Where(f => f.InstanceType == typeof(Guid) && (f.ForeignKeyReferenceTypeName?.Contains(typeof (IPage).FullName) ?? false)) .OrderByDescending(f => f.Name == nameof(IPageData.PageId)) .Select(f => f.Name) .FirstOrDefault(); } if (sourceField != null) { string updateVersionIdCommandText = $"UPDATE [{tableName}] SET [{nameof(IVersioned.VersionId)}] = [{sourceField}]"; ExecuteNonQuery(updateVersionIdCommandText); } } } }
// Helper internal static bool EnsureUpdateStore(Type interfaceType, string providerName, bool makeAFlush) { using (TimerProfilerFacade.CreateTimerProfiler(interfaceType.ToString())) { var newDataTypeDescriptor = BuildNewDataTypeDescriptor(interfaceType); var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(newDataTypeDescriptor.DataTypeId); if (interfaceType.IsGenerated()) { var customFields = oldDataTypeDescriptor.Fields.Where(f => !f.Inherited && !oldDataTypeDescriptor.KeyPropertyNames .Contains(f.Name)); foreach (var field in customFields) { newDataTypeDescriptor.Fields.Remove(newDataTypeDescriptor.Fields[field.Name]); newDataTypeDescriptor.Fields.Add(field); } } if (oldDataTypeDescriptor == null) { DataMetaDataFacade.PersistMetaData(newDataTypeDescriptor); return false; } var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor); if (!dataTypeChangeDescriptor.AlteredTypeHasChanges) return false; Log.LogVerbose("DynamicTypeManager", "Updating the store for interface type '{0}' on the '{1}' data provider", interfaceType, providerName); var updateDataTypeDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor, providerName); AlterStore(updateDataTypeDescriptor, makeAFlush); return true; } }
private void HandleEnablingOfPublication(DataTypeChangeDescriptor changeDescriptor) { IEnumerable<CultureInfo> locales = GetCultures(changeDescriptor.OriginalType); foreach (CultureInfo locale in locales) { string oldTableName = GetConfiguredTableName(changeDescriptor.OriginalType, DataScopeIdentifier.Public, locale.Name); string newTableName = DynamicTypesCommon.GenerateTableName(changeDescriptor.AlteredType, DataScopeIdentifier.Administrated, locale); StringBuilder fieldList = GetCommonFields(changeDescriptor); string copyCommandText = string.Format(@" INSERT INTO [{0}] ({2}) SELECT {2} FROM [{1}];", newTableName, oldTableName, fieldList); ExecuteNonQuery(copyCommandText); string updateOldCommandText = string.Format("UPDATE [{0}] SET [{1}] = '{2}'", oldTableName, "PublicationStatus", GenericPublishProcessController.Published); ExecuteNonQuery(updateOldCommandText); string updateNewCommandText = string.Format("UPDATE [{0}] SET [{1}] = '{2}'", newTableName, "PublicationStatus", GenericPublishProcessController.Published); ExecuteNonQuery(updateNewCommandText); } }
/// <summary> /// This method will remove a foreign key (if any exists) that is no longer possible with the /// new meta data system (IPageMetaDataDefinition) /// </summary> /// <param name="dataTypeDescriptor"></param> /// <param name="dataStoreExists"></param> private void UpdateWithNewPageFolderForeignKeySystem(DataTypeDescriptor dataTypeDescriptor, bool dataStoreExists) { if (dataTypeDescriptor.IsPageFolderDataType == false) { return; } DataFieldDescriptor dataFieldDescriptor = dataTypeDescriptor.Fields["IAggregationDescriptionIdForeignKey"]; if (dataFieldDescriptor == null) { return; } Log.LogVerbose("GeneratedTypesFacade", string.Format("Removing the property {0} on the type {1}.{2}", dataFieldDescriptor.Name, dataTypeDescriptor.Namespace, dataTypeDescriptor.Name)); if(!dataStoreExists) { dataTypeDescriptor.Fields.Remove(dataFieldDescriptor); DynamicTypeManager.UpdateDataTypeDescriptor(dataTypeDescriptor, false); return; } DataTypeDescriptor oldDataTypeDescriptor = dataTypeDescriptor.Clone(); dataTypeDescriptor.Fields.Remove(dataFieldDescriptor); var dataTypeChangeDescriptor = new DataTypeChangeDescriptor(oldDataTypeDescriptor, dataTypeDescriptor); UpdateDataTypeDescriptor updateDataTypeDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, dataTypeDescriptor); DynamicTypeManager.AlterStore(updateDataTypeDescriptor, false); }