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