/// <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);
var updateDataTypeDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, dataTypeDescriptor);
DynamicTypeManager.AlterStore(updateDataTypeDescriptor, false);
}
internal void AlterStoresForType(UpdateDataTypeDescriptor updateDataTypeDescriptor)
{
DataTypeChangeDescriptor changeDescriptor = updateDataTypeDescriptor.CreateDataTypeChangeDescriptor();
lock (_lock)
{
foreach (DataScopeIdentifier dataScope in changeDescriptor.AddedDataScopes)
{
CreateScopeData(changeDescriptor.AlteredType, dataScope);
}
foreach (DataScopeIdentifier dataScope in changeDescriptor.ExistingDataScopes)
{
AlterScopeData(updateDataTypeDescriptor, changeDescriptor, dataScope);
}
if (updateDataTypeDescriptor.PublicationAdded)
{
HandleEnablingOfPublication(changeDescriptor);
}
if (updateDataTypeDescriptor.PublicationRemoved)
{
HandleDisablingOfPublication(changeDescriptor);
}
foreach (DataScopeIdentifier dataScope in changeDescriptor.DeletedDataScopes)
{
DropScopeData(changeDescriptor.AlteredType, dataScope);
}
}
}
private void AppendFields(string tableName,
DataTypeChangeDescriptor changeDescriptor,
IEnumerable <DataFieldDescriptor> addedFieldDescriptions,
Dictionary <string, object> defaultValues = null)
{
foreach (var addedFieldDescriptor in addedFieldDescriptions)
{
string fieldName = addedFieldDescriptor.Name;
object defaultValue = null;
if (defaultValues != null && defaultValues.ContainsKey(fieldName))
{
defaultValue = defaultValues[addedFieldDescriptor.Name];
}
CreateColumn(tableName, changeDescriptor.AlteredType, 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);
}
}
}
}
public static XmlProviderInterfaceConfigurationElement Change(UpdateDataTypeDescriptor updateDataTypeDescriptor)
{
DataTypeChangeDescriptor changeDescriptor = updateDataTypeDescriptor.CreateDataTypeChangeDescriptor();
var xmlDataProviderConfiguration = new XmlDataProviderConfiguration(updateDataTypeDescriptor.ProviderName);
object key = xmlDataProviderConfiguration.Section.Interfaces.GetKey(changeDescriptor.OriginalType);
var oldConfigurationElement = xmlDataProviderConfiguration.Section.Interfaces.Get(key);
var newConfigurationElement = BuildXmlProviderInterfaceConfigurationElement(changeDescriptor.AlteredType, oldConfigurationElement);
XmlDataProviderStoreManipulator.AlterStore(updateDataTypeDescriptor, oldConfigurationElement, newConfigurationElement);
xmlDataProviderConfiguration.Section.Interfaces.Remove(key);
xmlDataProviderConfiguration.Section.Interfaces.Add(newConfigurationElement);
xmlDataProviderConfiguration.Save();
return(newConfigurationElement);
}
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);
}
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 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);
}
}
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);
}
}
private static DataTypeChangeDescriptor.ExistingFieldInfo GetExistingFieldInfo(DataTypeChangeDescriptor dataTypeChangeDescriptor, string name)
{
return(dataTypeChangeDescriptor.ExistingFields.FirstOrDefault(f => f.OriginalField.Name == name));
}
public static void AlterStore(UpdateDataTypeDescriptor updateDescriptor, XmlProviderInterfaceConfigurationElement oldConfigurationElement, XmlProviderInterfaceConfigurationElement newConfigurationElement)
{
DataTypeChangeDescriptor dataTypeChangeDescriptor = updateDescriptor.CreateDataTypeChangeDescriptor();
foreach (KeyValuePair <string, Type> kvp in oldConfigurationElement.PropertyInitializers)
{
newConfigurationElement.AddPropertyInitializer(kvp.Key, kvp.Value);
}
Dictionary <string, object> newFieldValues = new Dictionary <string, object>();
foreach (DataScopeIdentifier scopeIdentifier in dataTypeChangeDescriptor.AddedDataScopes)
{
foreach (DataScopeConfigurationElement dataScopeConfigurationElement in newConfigurationElement.DataScopes[scopeIdentifier.Name].Values)
{
CreateStore(updateDescriptor.ProviderName, dataScopeConfigurationElement);
}
}
foreach (DataScopeIdentifier scopeIdentifier in dataTypeChangeDescriptor.ExistingDataScopes)
{
foreach (KeyValuePair <string, DataScopeConfigurationElement> fileForLanguage in oldConfigurationElement.DataScopes[scopeIdentifier.Name])
{
string cultureName = fileForLanguage.Key;
if (!newConfigurationElement.DataScopes[scopeIdentifier.Name].ContainsKey(cultureName))
{
continue;
}
var oldDataScopeConfigurationElement = fileForLanguage.Value;
var newDataScopeConfigurationElement = newConfigurationElement.DataScopes[scopeIdentifier.Name][cultureName];
newFieldValues = new Dictionary <string, object>
{
{ "PublicationStatus", GenericPublishProcessController.Published }
};
CopyData(updateDescriptor.ProviderName, dataTypeChangeDescriptor, oldDataScopeConfigurationElement, newDataScopeConfigurationElement, newFieldValues);
}
}
if (updateDescriptor.PublicationAdded)
{
foreach (var fileByLanguage in oldConfigurationElement.DataScopes[DataScopeIdentifier.PublicName])
{
var oldDataScopeConfigurationElement = fileByLanguage.Value;
var newDataScopeConfigurationElement = newConfigurationElement.DataScopes[DataScopeIdentifier.AdministratedName][fileByLanguage.Key];
newFieldValues = new Dictionary <string, object>
{
{ "PublicationStatus", GenericPublishProcessController.Published }
};
CopyData(updateDescriptor.ProviderName, dataTypeChangeDescriptor, oldDataScopeConfigurationElement, newDataScopeConfigurationElement, newFieldValues, false);
}
}
if (updateDescriptor.PublicationRemoved)
{
foreach (var fileByLanguage in oldConfigurationElement.DataScopes[DataScopeIdentifier.AdministratedName])
{
var oldDataScopeConfigurationElement = fileByLanguage.Value;
var newDataScopeConfigurationElement = newConfigurationElement.DataScopes[DataScopeIdentifier.PublicName][fileByLanguage.Key];
CopyData(updateDescriptor.ProviderName, dataTypeChangeDescriptor, oldDataScopeConfigurationElement, newDataScopeConfigurationElement, newFieldValues, false);
}
}
bool oldTypeLocalized = updateDescriptor.OldDataTypeDescriptor.Localizeable;
bool newTypeLocalized = updateDescriptor.NewDataTypeDescriptor.Localizeable;
if (!oldTypeLocalized && newTypeLocalized)
{
foreach (var newStore in newConfigurationElement.DataScopes.Values.SelectMany(kvp => kvp.Values))
{
CreateStore(updateDescriptor.ProviderName, newStore);
}
foreach (string dataScopeIdentifier in oldConfigurationElement.DataScopes.Keys)
{
var oldFilesByCulture = oldConfigurationElement.DataScopes[dataScopeIdentifier];
string invariantCultureKey = "";
if (oldFilesByCulture.ContainsKey(invariantCultureKey))
{
var oldDataScopeConfigurationElement = oldFilesByCulture[invariantCultureKey];
if (updateDescriptor.LocalesToCopyTo != null)
{
foreach (CultureInfo locale in updateDescriptor.LocalesToCopyTo)
{
var newDataScopeConfigurationElement = newConfigurationElement.DataScopes[dataScopeIdentifier][locale.Name];
var nfv = new Dictionary <string, object>(newFieldValues)
{
{ "SourceCultureName", locale.Name }
};
CopyData(updateDescriptor.ProviderName, dataTypeChangeDescriptor, oldDataScopeConfigurationElement, newDataScopeConfigurationElement, nfv, false);
}
}
DropStore(updateDescriptor.ProviderName, oldDataScopeConfigurationElement);
}
}
}
if (oldTypeLocalized && !newTypeLocalized)
{
foreach (var newStore in newConfigurationElement.DataScopes.Values.SelectMany(kvp => kvp.Values))
{
CreateStore(updateDescriptor.ProviderName, newStore);
}
if (updateDescriptor.LocaleToCopyFrom != null)
{
foreach (string dataScopeIdentifier in oldConfigurationElement.DataScopes.Keys)
{
var oldDataScopeConfigurationElement = oldConfigurationElement.DataScopes[dataScopeIdentifier][updateDescriptor.LocaleToCopyFrom.Name];
var newDataScopeConfigurationElement = newConfigurationElement.DataScopes[dataScopeIdentifier][""];
CopyData(updateDescriptor.ProviderName, dataTypeChangeDescriptor, oldDataScopeConfigurationElement, newDataScopeConfigurationElement, newFieldValues, false);
}
}
foreach (var oldStore in oldConfigurationElement.DataScopes.SelectMany(d => d.Value).Where(f => f.Key != "").Select(f => f.Value))
{
DropStore(updateDescriptor.ProviderName, oldStore);
}
}
foreach (DataScopeIdentifier scopeIdentifier in dataTypeChangeDescriptor.DeletedDataScopes)
{
foreach (DataScopeConfigurationElement dataScopeConfigurationElement in oldConfigurationElement.DataScopes[scopeIdentifier.Name].Values)
{
DropStore(updateDescriptor.ProviderName, dataScopeConfigurationElement);
}
}
}
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)
{
var existingField = (Guid)oldElement.Attribute(versionIdSourceFieldName);
if (existingField != null)
{
newChildAttributes.Add(new XAttribute(fieldDescriptor.Name, existingField));
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);
}
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>();
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 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.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.KeyPropertyNames, 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);
}
}
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));
}
internal static InterfaceConfigurationElement RefreshLocalizationInfo(string providerName, DataTypeDescriptor dataTypeDescriptor)
{
var changeDescriptor = new DataTypeChangeDescriptor(dataTypeDescriptor, dataTypeDescriptor);
return(Change(providerName, changeDescriptor, true));
}
