private DataTypeDescriptorFormsHelper GetDataTypeDescriptorFormsHelper()
{
if (_helper == null)
{
var type = GetInterfaceType();
var guid = type.GetImmutableTypeId();
var typeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(guid);
if (typeDescriptor == null)
{
throw new InvalidOperationException(string.Format("Can not find the type descriptor for the type '{0}'", type));
}
var generatedTypesHelper = new GeneratedTypesHelper(typeDescriptor)
{
AllowForeignKeyEditing = true
};
_helper = new DataTypeDescriptorFormsHelper(typeDescriptor, true, EntityToken)
{
LayoutIconHandle = "generated-type-data-add"
};
_helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames);
_typeName = typeDescriptor.Name;
}
return(_helper);
}
private Dictionary <DataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> > BuildAllExistingDataTypeStoreDataScopes()
{
var allSqlDataTypeStoreDataScopes = new Dictionary <DataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> >();
foreach (InterfaceConfigurationElement element in _interfaceConfigurationElements)
{
Guid dataTypeId = element.DataTypeId;
var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(dataTypeId, true);
if (dataTypeDescriptor == null)
{
Log.LogWarning(LogTitle, "Failed to get data type descriptor by id '{0}'".FormatWith(dataTypeId));
continue;
}
var sqlDataTypeStoreDataScopes = new List <SqlDataTypeStoreDataScope>();
foreach (StorageInformation storageInformation in element.Stores)
{
var sqlDataTypeStoreDataScope = new SqlDataTypeStoreDataScope
{
DataScopeName = storageInformation.DataScope,
CultureName = storageInformation.CultureName,
TableName = storageInformation.TableName
};
sqlDataTypeStoreDataScopes.Add(sqlDataTypeStoreDataScope);
}
allSqlDataTypeStoreDataScopes.Add(dataTypeDescriptor, sqlDataTypeStoreDataScopes);
}
return(allSqlDataTypeStoreDataScopes);
}
private DataTypeDescriptorFormsHelper GetDataTypeDescriptorFormsHelper()
{
if (_helper == null)
{
var dataEntityToken = (DataEntityToken)EntityToken;
var guid = dataEntityToken.Data.DataSourceId.InterfaceType.GetImmutableTypeId();
var typeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(guid);
var generatedTypesHelper = new GeneratedTypesHelper(typeDescriptor)
{
AllowForeignKeyEditing = true
};
_helper = new DataTypeDescriptorFormsHelper(typeDescriptor, true, EntityToken)
{
LayoutIconHandle = "generated-type-data-edit"
};
_helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames);
_typeName = typeDescriptor.Name;
}
return(_helper);
}
/// <summary>
///
/// </summary>
/// <param name="interfaceType"></param>
/// <param name="existingDataTypeDescriptor">Use null to get existing data type descriptor</param>
/// <param name="errorMessage"></param>
/// <returns></returns>
public static bool Validate(Type interfaceType, DataTypeDescriptor existingDataTypeDescriptor, out string errorMessage)
{
if (existingDataTypeDescriptor == null)
{
existingDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(interfaceType.GetImmutableTypeId());
if (existingDataTypeDescriptor == null)
{
errorMessage = null;
return(true);
}
}
errorMessage = _typeSpecificValidations.GetOrAdd(
interfaceType,
f =>
{
string message;
bool isValid = DataTypeValidator.Validate(interfaceType, existingDataTypeDescriptor, out message);
if (isValid)
{
return(null);
}
var sb = new StringBuilder();
sb.AppendLine(string.Format("The data type interface '{0}' did not validate and can't be used at the moment.", interfaceType));
sb.AppendLine(message);
return(sb.ToString());
}
);
return(errorMessage == null);
}
// 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 initialCodeActivity_ExecuteCode(object sender, EventArgs e)
{
var entityToken = EntityToken as AssociatedDataElementProviderHelperEntityToken;
if (!string.IsNullOrEmpty(entityToken?.Payload))
{
var type = TypeManager.GetType(entityToken.Payload);
var id = type.GetImmutableTypeId();
var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(id);
UpdateBinding("DataTypeDescriptor", dataTypeDescriptor);
UpdateBinding(BindingNames.PageId, new Guid(entityToken.Id));
if (!PermissionsFacade.GetPermissionsForCurrentUser(EntityToken).Contains(PermissionType.Publish) || !typeof(IPublishControlled).IsAssignableFrom(type))
{
var formData = WorkflowFacade.GetFormData(InstanceId, true);
if (formData.ExcludedEvents == null)
{
formData.ExcludedEvents = new List <string>();
}
formData.ExcludedEvents.Add("SaveAndPublish");
}
}
}
private static string GetDataTypeLabel(object datatype)
{
var str = (string)datatype;
Guid dataTypeId;
if (Guid.TryParse(str, out dataTypeId))
{
if (dataTypeId == new Guid("C046F704-D3E4-4b3d-8CB9-77564FB0B9E7"))
{
return(Texts.DataType_Page);
}
if (dataTypeId == new Guid("A8716C78-1499-4155-875B-2545006385B2"))
{
return(Texts.DataType_MediaFile);
}
var descriptor = DataMetaDataFacade.GetDataTypeDescriptor(dataTypeId);
if (descriptor != null)
{
return(descriptor.Title ?? descriptor.Name);
}
}
return(str);
}
// 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 void BuildAllCode(CodeGenerationBuilder codeGenerationBuilder)
{
var codeBuilder = new XmlDataProviderCodeBuilder(_dataProviderContext.ProviderName, codeGenerationBuilder);
foreach (XmlProviderInterfaceConfigurationElement element in _dataTypeConfigurationElements)
{
if (element.DataTypeId == Guid.Empty)
{
continue;
}
Guid dataTypeId = element.DataTypeId;
DataTypeDescriptor dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(dataTypeId);
if (dataTypeDescriptor == null)
{
Log.LogError(LogTitle, "Failed to find interface by id '{0}'. Skipping code generation for that type", dataTypeId);
continue;
}
if (!dataTypeDescriptor.ValidateRuntimeType())
{
Log.LogError(LogTitle, "The non code generated interface type '{0}' was not found, skipping code generation for that type", dataTypeDescriptor);
continue;
}
codeBuilder.AddDataType(dataTypeDescriptor);
}
}
private DataTypeDescriptor GetDataTypeDescriptor()
{
Type type = TypeManager.GetType(this.Payload);
Guid guid = type.GetImmutableTypeId();
return(DataMetaDataFacade.GetDataTypeDescriptor(guid));
}
/// <summary>
/// This method will return the type of the empty data class type.
/// If the type does not exist, one will be runtime code generated
/// using the type to get a data type descriptor.
/// </summary>
/// <param name="interfaceType">The data interface type to get the empty class type for.</param>
/// <param name="forceReCompilation">
/// If this is true a new empty class will be
/// compiled at runtime regardless if it exists or not.
/// Use with caution!
/// </param>
/// <returns>The empty class type for the given data interface type.</returns>
public static Type GetEmptyDataClassType(Type interfaceType, bool forceReCompilation = false)
{
VerifyAssemblyLocation(interfaceType);
var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(interfaceType.GetImmutableTypeId(), true);
return(GetEmptyDataClassType(dataTypeDescriptor, forceReCompilation));
}
private DataTypeDescriptor GetDataTypeDescriptor()
{
Type type = GetTypeFromEntityToken();
Guid guid = type.GetImmutableTypeId();
return(DataMetaDataFacade.GetDataTypeDescriptor(guid));
}
private DataTypeDescriptor GetDataTypeDescriptor()
{
GeneratedDataTypesElementProviderTypeEntityToken entityToken = (GeneratedDataTypesElementProviderTypeEntityToken)this.EntityToken;
Type type = TypeManager.GetType(entityToken.SerializedTypeName);
Guid guid = type.GetImmutableTypeId();
return(DataMetaDataFacade.GetDataTypeDescriptor(guid));
}
/// <exclude />
public void UpdateDataTypeDescriptor(DataTypeDescriptor dataTypeDescriptor, bool flushTheSystem)
{
dataTypeDescriptor.Validate();
DataMetaDataFacade.PersistMetaData(dataTypeDescriptor);
if (flushTheSystem)
{
GlobalEventSystemFacade.FlushTheSystem();
}
}
/// <summary>
/// This method will return the type of the empty data class type.
/// If the type does not exist, one will be runtime code generated
/// using the type to get a data type descriptor.
/// </summary>
/// <param name="interfaceType">The data interface type to get the empty class type for.</param>
/// <param name="forceReCompilation">
/// If this is true a new empty class will be
/// compiled at runtime regardless if it exists or not.
/// Use with caution!
/// </param>
/// <returns>The empty class type for the given data interface type.</returns>
public static Type GetEmptyDataClassType(Type interfaceType, bool forceReCompilation = false)
{
if (!DataTypeTypesManager.IsAllowedDataTypeAssembly(interfaceType))
{
string message = string.Format("The data interface '{0}' is not located in an assembly in the website Bin folder. Please move it to that location", interfaceType);
Log.LogError("EmptyDataClassTypeManager", message);
throw new InvalidOperationException(message);
}
DataTypeDescriptor dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(interfaceType.GetImmutableTypeId(), true);
return(GetEmptyDataClassType(dataTypeDescriptor, forceReCompilation));
}
private static DataTypeDescriptor GetDataTypeDescriptorNotNull(XmlProviderInterfaceConfigurationElement element)
{
Guid dataTypeId = element.DataTypeId;
var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(dataTypeId, true);
if (dataTypeDescriptor == null)
{
throw NewConfigurationException(element, "Failed to get a DataTypeDescriptor by id '{0}'".FormatWith(dataTypeId));
}
return(dataTypeDescriptor);
}
// 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);
}
}
private static IEnumerable <PropertyInfo> GetPageReferenceFields(Type referencedType)
{
var descriptor = DataMetaDataFacade.GetDataTypeDescriptor(referencedType.GetImmutableTypeId());
if (descriptor == null)
{
return(Enumerable.Empty <PropertyInfo>());
}
return(descriptor.Fields.Where(f => f.InstanceType == typeof(Guid) &&
f.ForeignKeyReferenceTypeName != null &&
TypeManager.TryGetType(f.ForeignKeyReferenceTypeName) == typeof(IPage))
.Select(f => referencedType.GetProperty(f.Name)));
}
/// <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();
}
}
/// <summary>
/// Loads all the data types referenced in the provider's configuration file.
/// </summary>
private static Dictionary <Guid, Type> LoadDataTypes(IEnumerable <InterfaceConfigurationElement> configurationElements)
{
var dataTypeDescriptors = new List <DataTypeDescriptor>();
foreach (InterfaceConfigurationElement element in configurationElements)
{
Guid dataTypeId = element.DataTypeId;
var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(dataTypeId, true);
if (dataTypeDescriptor == null)
{
throw NewConfigurationException(element, "Failed to get a DataTypeDescriptor by id '{0}'".FormatWith(dataTypeId));
}
dataTypeDescriptors.Add(dataTypeDescriptor);
}
return(DataTypeTypesManager.GetDataTypes(dataTypeDescriptors));
}
private DataTypeDescriptorFormsHelper GetDataTypeDescriptorFormsHelper()
{
if (_helper == null)
{
var dataEntityToken = (DataEntityToken)EntityToken;
var interfaceType = dataEntityToken.Data.DataSourceId.InterfaceType;
var guid = interfaceType.GetImmutableTypeId();
var typeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(guid);
var generatedTypesHelper = new GeneratedTypesHelper(typeDescriptor);
_helper = new DataTypeDescriptorFormsHelper(typeDescriptor, true, EntityToken);
_helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames);
_typeName = typeDescriptor.Name;
}
return(_helper);
}
/// <exclude />
public void DropStore(string providerName, DataTypeDescriptor typeDescriptor, bool makeAFlush)
{
Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
Verify.ArgumentNotNull(typeDescriptor, "typeDescriptor");
typeDescriptor.Validate();
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
DataProviderPluginFacade.DropStore(providerName, typeDescriptor);
DataMetaDataFacade.DeleteMetaData(typeDescriptor.DataTypeId);
transactionScope.Complete();
}
if (makeAFlush)
{
GlobalEventSystemFacade.FlushTheSystem();
}
}
public FlowToken Execute(EntityToken entityToken, ActionToken actionToken, FlowControllerServicesContainer flowControllerServicesContainer)
{
var token = (GeneratedDataTypesElementProviderTypeEntityToken)entityToken;
var type = TypeManager.GetType(token.SerializedTypeName);
Guid guid = type.GetImmutableTypeId();
var oldDataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(guid);
var superInfterface = ((ToggleSuperInterfaceActionToken)actionToken).InterfaceType;
var newDataTypeDescriptor = oldDataTypeDescriptor.Clone();
if (newDataTypeDescriptor.SuperInterfaces.Contains(superInfterface))
{
newDataTypeDescriptor.RemoveSuperInterface(superInfterface);
}
else
{
newDataTypeDescriptor.AddSuperInterface(superInfterface);
}
if (newDataTypeDescriptor.DataScopes.Count == 0)
{
newDataTypeDescriptor.DataScopes.Add(DataScopeIdentifier.Public);
}
if (oldDataTypeDescriptor.DataScopes.Count == 0)
{
oldDataTypeDescriptor.DataScopes.Add(DataScopeIdentifier.Public);
}
var updateDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor, true);
GeneratedTypesFacade.UpdateType(updateDescriptor);
EntityTokenCacheFacade.ClearCache();
var treeRefresher = new ParentTreeRefresher(flowControllerServicesContainer);
treeRefresher.PostRefreshMesseges(entityToken);
return(null);
}
private DataTypeDescriptor GetDataTypeDescriptor()
{
Type type;
if (this.EntityToken is AssociatedDataElementProviderHelperEntityToken)
{
var castedEntityToken = this.EntityToken as AssociatedDataElementProviderHelperEntityToken;
type = TypeManager.GetType(castedEntityToken.Payload);
}
else
{
var entityToken = (GeneratedDataTypesElementProviderTypeEntityToken)this.EntityToken;
type = TypeManager.GetType(entityToken.SerializedTypeName);
}
Guid guid = type.GetImmutableTypeId();
return(DataMetaDataFacade.GetDataTypeDescriptor(guid));
}
internal void BuildAllCode(CodeGenerationBuilder codeGenerationBuilder)
{
var codeBuilder = new SqlDataProviderCodeBuilder(_dataProviderContext.ProviderName, codeGenerationBuilder);
foreach (InterfaceConfigurationElement element in _interfaceConfigurationElements)
{
if (element.DataTypeId == Guid.Empty)
{
continue;
}
var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(element.DataTypeId);
if (!dataTypeDescriptor.ValidateRuntimeType())
{
Log.LogError(LogTitle, string.Format("The non code generated interface type '{0}' was not found, skipping code generation for that type", dataTypeDescriptor));
continue;
}
var sqlDataTypeStoreDataScopes = new List <SqlDataTypeStoreDataScope>();
foreach (StorageInformation storageInformation in element.Stores)
{
var sqlDataTypeStoreDataScope = new SqlDataTypeStoreDataScope
{
DataScopeName = storageInformation.DataScope,
CultureName = storageInformation.CultureName,
TableName = storageInformation.TableName
};
sqlDataTypeStoreDataScopes.Add(sqlDataTypeStoreDataScope);
}
codeBuilder.AddDataType(dataTypeDescriptor, sqlDataTypeStoreDataScopes);
}
codeBuilder.AddDataContext();
}
/// <exclude />
public void CreateStores(string providerName, IReadOnlyCollection <DataTypeDescriptor> typeDescriptors, bool doFlush)
{
Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
Verify.ArgumentNotNull(typeDescriptors, "typeDescriptors");
typeDescriptors.ForEach(d => d.Validate());
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
foreach (var typeDescriptor in typeDescriptors)
{
DataMetaDataFacade.PersistMetaData(typeDescriptor);
}
DataProviderPluginFacade.CreateStores(providerName, typeDescriptors);
transactionScope.Complete();
}
if (doFlush)
{
GlobalEventSystemFacade.FlushTheSystem();
}
}
internal void CopyPageData(IPage sourcePage, IPage newPage)
{
Guid sourcePageId = sourcePage.Id;
Guid newPageId = newPage.Id;
Guid sourceVersionId = sourcePage.VersionId;
Guid newVersionId = newPage.VersionId;
var newPlaceholders = new List <IPagePlaceholderContent>();
var placeholders =
DataFacade.GetData <IPagePlaceholderContent>(false)
.Where(ph => ph.PageId == sourcePageId &&
ph.VersionId == sourceVersionId)
.ToList();
foreach (var placeholderContent in placeholders)
{
var newPlaceholder = DataFacade.BuildNew <IPagePlaceholderContent>();
newPlaceholder.PageId = newPageId;
newPlaceholder.PlaceHolderId = placeholderContent.PlaceHolderId;
newPlaceholder.Content = placeholderContent.Content;
newPlaceholder.VersionId = newVersionId;
newPlaceholders.Add(newPlaceholder);
}
DataFacade.AddNew <IPagePlaceholderContent>(newPlaceholders);
var sourceMetaData = sourcePage.GetMetaData().Cast <IPageMetaData>()
.Where(d => d.VersionId == sourceVersionId);
foreach (var metaDataItem in sourceMetaData)
{
var metaDataType = metaDataItem.DataSourceId.InterfaceType;
var typeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(metaDataType.GetImmutableTypeId());
var definition = PageMetaDataFacade.GetMetaDataDefinition(sourcePageId, metaDataItem.GetTypeTitle());
var newDataItem = (IPageMetaData)DataFacade.BuildNew(metaDataType);
var properties = metaDataType.GetPropertiesRecursively().ToDictionary(p => p.Name);
foreach (var field in typeDescriptor.Fields)
{
var propertyInfo = properties[field.Name];
propertyInfo.SetValue(newDataItem, propertyInfo.GetValue(metaDataItem));
}
newDataItem.VersionId = newVersionId;
newDataItem.Id = Guid.NewGuid();
newDataItem.PageId = newPageId;
newDataItem.PublicationStatus = GenericPublishProcessController.Draft;
newDataItem = (IPageMetaData)DataFacade.AddNew((IData)newDataItem);
if (definition != null)
{
string title = newDataItem.GetTypeTitle();
newPage.AddMetaDataDefinition(title, title, newDataItem.GetImmutableTypeId(),
definition.MetaDataContainerId);
}
}
List <string> selectableTreeIds = TreeFacade.AllTrees.Where(
tree => tree.HasAttachmentPoints(sourcePage.GetDataEntityToken()))
.Where(tree => !tree.HasAttachmentPoints(newPage.GetDataEntityToken()))
.Select(tree => tree.TreeId).ToList();
foreach (var selectableTreeId in selectableTreeIds)
{
TreeFacade.AddPersistedAttachmentPoint(selectableTreeId, newPage.DataSourceId.InterfaceType,
newPage.DataSourceId.GetKeyValue());
}
foreach (var dataFolderType in sourcePage.GetDefinedFolderTypes())
{
newPage.AddFolderDefinition(dataFolderType);
}
}
private InterfaceGeneratedClassesInfo InitializeStoreTypes(InterfaceConfigurationElement element,
Dictionary <DataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> > allSqlDataTypeStoreDataScopes,
Type dataContextClass,
Dictionary <Guid, Type> dataTypes,
bool forceCompile,
ref bool dataContextRecompilationNeeded,
ref HelperClassesGenerationInfo helperClassesGenerationInfo)
{
var result = new InterfaceGeneratedClassesInfo();
var dataScopes = new List <SqlDataTypeStoreDataScope>();
foreach (StorageInformation storageInformation in element.Stores)
{
var sqlDataTypeStoreDataScope = new SqlDataTypeStoreDataScope
{
DataScopeName = storageInformation.DataScope,
CultureName = storageInformation.CultureName,
TableName = storageInformation.TableName
};
dataScopes.Add(sqlDataTypeStoreDataScope);
}
result.DataScopes = dataScopes;
Guid dataTypeId = element.DataTypeId;
var dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(dataTypeId, true);
if (dataTypeDescriptor == null)
{
throw NewConfigurationException(element, "Failed to get a DataTypeDescriptor by id '{0}'".FormatWith(dataTypeId));
}
result.DataTypeDescriptor = dataTypeDescriptor;
Type interfaceType = null;
try
{
if (dataTypes == null ||
!dataTypes.TryGetValue(dataTypeId, out interfaceType) ||
interfaceType == null)
{
interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor);
}
if (interfaceType == null)
{
Log.LogWarning(LogTitle, "The data interface type '{0}' does not exists and is not code generated. It will not be unusable", dataTypeDescriptor.TypeManagerTypeName);
return(result);
}
result.InterfaceType = interfaceType;
string validationMessage;
bool isValid = DataTypeValidationRegistry.Validate(interfaceType, dataTypeDescriptor, out validationMessage);
if (!isValid)
{
Log.LogCritical(LogTitle, validationMessage);
throw new InvalidOperationException(validationMessage);
}
Dictionary <SqlDataTypeStoreTableKey, StoreTypeInfo> fields;
helperClassesGenerationInfo = EnsureNeededTypes(dataTypeDescriptor,
dataScopes, allSqlDataTypeStoreDataScopes, dataContextClass,
out fields, ref dataContextRecompilationNeeded, forceCompile);
result.Fields = fields;
return(result);
}
catch (Exception ex)
{
if (interfaceType != null)
{
DataProviderRegistry.RegisterDataTypeInitializationError(interfaceType, ex);
DataProviderRegistry.AddKnownDataType(interfaceType, _dataProviderContext.ProviderName);
Log.LogError(LogTitle, "Failed initialization for the datatype {0}", dataTypeDescriptor.TypeManagerTypeName);
}
Log.LogError(LogTitle, ex);
result.Fields = new Dictionary <SqlDataTypeStoreTableKey, StoreTypeInfo>();
return(result);
}
}
/// <exclude />
public bool TryGetDataTypeDescriptor(Guid immutableTypeId, out DataTypeDescriptor dataTypeDescriptor)
{
dataTypeDescriptor = DataMetaDataFacade.GetDataTypeDescriptor(immutableTypeId);
return(dataTypeDescriptor != null);
}
