/// <summary> /// Use this method to register data type descriptors that have been validated and will be /// intstalled. /// </summary> /// <param name="interfaceName"></param> /// <param name="dataTypeDescriptor"></param> public void AddPendingDataTypeDescritpor(string interfaceName, DataTypeDescriptor dataTypeDescriptor) { Verify.ArgumentNotNullOrEmpty(interfaceName, "interfaceName"); Verify.ArgumentNotNull(dataTypeDescriptor, "dataTypeDescriptor"); _pendingDataTypeDescriptors.Add(interfaceName, dataTypeDescriptor); }
internal static Type TryGetType(DataTypeDescriptor dataTypeDescriptor, bool forceReCompilation, out bool codeGenerationNeeded) { Verify.ArgumentNotNull(dataTypeDescriptor, "dataTypeDescriptor"); codeGenerationNeeded = false; Type type; if (!forceReCompilation) { type = TypeManager.TryGetType(dataTypeDescriptor.GetFullInterfaceName()); if (type != null) return type; if (!dataTypeDescriptor.IsCodeGenerated) { type = TypeManager.TryGetType(dataTypeDescriptor.TypeManagerTypeName); if (type != null) return type; } } if (!dataTypeDescriptor.IsCodeGenerated) { return null; } if (forceReCompilation) { type = TypeManager.TryGetType(dataTypeDescriptor.GetFullInterfaceName()); if (type != null) return type; } codeGenerationNeeded = true; return null; }
/// <summary> /// This method will return type given by the dataTypeDescriptor. /// If the data type does not exist, one will be dynamically /// runtime code generated. /// </summary> /// <param name="dataTypeDescriptor"></param> /// <param name="forceReCompilation">If this is true a new type will be compiled regardless if one already exists.</param> /// <returns></returns> public static Type GetType(DataTypeDescriptor dataTypeDescriptor, bool forceReCompilation = false) { bool codeGenerationNeeded; Type type = TryGetType(dataTypeDescriptor, forceReCompilation, out codeGenerationNeeded); if (type != null) { return type; } if (codeGenerationNeeded) { lock (_lock) { type = TypeManager.TryGetType(dataTypeDescriptor.GetFullInterfaceName()); if (type != null) return type; var codeGenerationBuilder = new CodeGenerationBuilder("DataInterface: " + dataTypeDescriptor.Name); InterfaceCodeGenerator.AddAssemblyReferences(codeGenerationBuilder, dataTypeDescriptor); InterfaceCodeGenerator.AddInterfaceTypeCode(codeGenerationBuilder, dataTypeDescriptor); IEnumerable<Type> types = CodeGenerationManager.CompileRuntimeTempTypes(codeGenerationBuilder); return types.Single(); } } return null; }
public XmlDataTypeStore(DataTypeDescriptor dataTypeDescriptor, Type dataProviderHelperType, Type dataIdClassType, IEnumerable<XmlDataTypeStoreDataScope> xmlDateTypeStoreDataScopes, bool isGeneratedDataType) { if (dataProviderHelperType == null) throw new ArgumentNullException("dataProviderHelperType"); if (dataIdClassType == null) throw new ArgumentNullException("dataIdClassType"); DataTypeDescriptor = dataTypeDescriptor; DataProviderHelperType = dataProviderHelperType; DataIdClassType = dataIdClassType; IsGeneratedDataType = isGeneratedDataType; _xmlDateTypeStoreDataScopes = xmlDateTypeStoreDataScopes.Evaluate(); var ordering = new List<Func<XElement, IComparable>>(); foreach (string key in dataTypeDescriptor.KeyPropertyNames) { XName localKey = key; ordering.Add(f => (string)f.Attribute(localKey) ?? ""); } Func<IEnumerable<XElement>, IOrderedEnumerable<XElement>> orderer = f => ordering.Skip(1).Aggregate(f.OrderBy(ordering.First()), Enumerable.ThenBy); foreach (XmlDataTypeStoreDataScope xmlDataTypeStoreDataScope in _xmlDateTypeStoreDataScopes) { DataScopeIdentifier dataScopeIdentifier = DataScopeIdentifier.Deserialize(xmlDataTypeStoreDataScope.DataScopeName); CultureInfo culture = CultureInfo.CreateSpecificCulture(xmlDataTypeStoreDataScope.CultureName); Type dataType = dataTypeDescriptor.GetInterfaceType(); Action cacheFlush = () => DataEventSystemFacade.FireExternalStoreChangedEvent(dataType, dataScopeIdentifier.ToPublicationScope(), culture); XmlDataProviderDocumentCache.RegisterExternalFileChangeAction(xmlDataTypeStoreDataScope.Filename, cacheFlush); XmlDataProviderDocumentWriter.RegisterFileOrderer(xmlDataTypeStoreDataScope.Filename, orderer); } }
/// <summary> /// Adds the assembly references required by the supplied <see cref="DataTypeDescriptor"/> to the supplied <see cref="CodeGenerationBuilder"/> /// </summary> /// <param name="codeGenerationBuilder">Assembly refences is added to this builder</param> /// <param name="dataTypeDescriptor">Data type descriptor which may contain references to assemblies</param> public static void AddAssemblyReferences(CodeGenerationBuilder codeGenerationBuilder, DataTypeDescriptor dataTypeDescriptor) { foreach (Assembly assembly in GetReferencedAssemblies(dataTypeDescriptor)) { codeGenerationBuilder.AddReference(assembly); } }
/// <summary> /// Given a <see cref="DataTypeDescriptor"/> creates a interface declaration inheriting from IData, a valid C1 Datatype. /// </summary> /// <param name="dataTypeDescriptor">A description of the data type to generate interface for</param> /// <returns>The generated interface</returns> public static CodeTypeDeclaration CreateCodeTypeDeclaration(DataTypeDescriptor dataTypeDescriptor) { try { var codeTypeDeclaration = new CodeTypeDeclaration(dataTypeDescriptor.Name) { IsInterface = true }; codeTypeDeclaration.BaseTypes.Add(new CodeTypeReference(typeof(IData))); var propertyNamesToSkip = new List<string>(); foreach (Type superInterface in dataTypeDescriptor.SuperInterfaces) { codeTypeDeclaration.BaseTypes.Add(new CodeTypeReference(superInterface)); propertyNamesToSkip.AddRange(superInterface.GetAllProperties().Select(p => p.Name)); } AddInterfaceAttributes(codeTypeDeclaration, dataTypeDescriptor); AddInterfaceProperties(codeTypeDeclaration, dataTypeDescriptor, propertyNamesToSkip); return codeTypeDeclaration; } catch (Exception ex) { throw new InvalidOperationException(string.Format("Failed to generate interface for type '{0}'", dataTypeDescriptor.TypeManagerTypeName), ex); } }
internal static string MakeFileName(DataTypeDescriptor dataTypeDescriptor, DataScopeIdentifier dataScopeIdentifier, string cultureName) { string typeFullName = StringExtensionMethods.CreateNamespace(dataTypeDescriptor.Namespace, dataTypeDescriptor.Name, '.'); string publicationScopePart = ""; switch (dataScopeIdentifier.Name) { case DataScopeIdentifier.PublicName: break; case DataScopeIdentifier.AdministratedName: publicationScopePart = "_" + PublicationScope.Unpublished; break; default: throw new InvalidOperationException("Unsupported data scope identifier: '{0}'".FormatWith(dataScopeIdentifier.Name)); } string cultureNamePart = ""; if (cultureName != "") { cultureNamePart = "_" + cultureName; } return typeFullName + publicationScopePart + cultureNamePart + ".xml"; }
/// <summary> /// This method validates if the existing .NET runtime type match the recorded meta data (DataTypeDescriptor). /// In case there is a mismatch, changes might have been done to the runtime type and an update on /// the existing store(s)could not be performed. /// </summary> /// <param name="interfaceType"></param> /// <param name="existingDataTypeDescriptor"></param> /// <param name="errorMessage"></param> /// <returns></returns> public static bool Validate(Type interfaceType, DataTypeDescriptor existingDataTypeDescriptor, out string errorMessage) { DataTypeDescriptor newDataTypeDescriptor; try { newDataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(interfaceType); } catch (Exception) { errorMessage = null; return true; } try { new DataTypeChangeDescriptor(existingDataTypeDescriptor, newDataTypeDescriptor); } catch (Exception ex) { errorMessage = ex.Message; return false; } errorMessage = null; return true; }
/// <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; }
/// <summary> /// Create an invariant store /// </summary> /// <param name="providerName"></param> /// <param name="dataTypeDescriptor"></param> public static void AddNew(string providerName, DataTypeDescriptor dataTypeDescriptor) { var xmlDataProviderConfiguration = new XmlDataProviderConfiguration(providerName); string interfaceType = dataTypeDescriptor.TypeManagerTypeName; if (interfaceType != null) { object key = xmlDataProviderConfiguration.Section.Interfaces.GetKey(dataTypeDescriptor); if (key != null) { Log.LogWarning(LogTitle, "Configuration file '{0}' already contains an interface type '{1} 'with id '{2}'. " + "Possibly there are multiple AppDomain-s running.", xmlDataProviderConfiguration.ConfigurationFilePath, dataTypeDescriptor, dataTypeDescriptor.DataTypeId); return; } } XmlProviderInterfaceConfigurationElement configurationElement = BuildXmlProviderInterfaceConfigurationElement(dataTypeDescriptor); XmlDataProviderStoreManipulator.CreateStore(providerName, configurationElement); xmlDataProviderConfiguration.Section.Interfaces.Add(configurationElement); xmlDataProviderConfiguration.Save(); }
internal void AddDataType(DataTypeDescriptor dataTypeDescriptor, IEnumerable<SqlDataTypeStoreDataScope> sqlDataTypeStoreDataScopes) { Type interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor); if (interfaceType == null) return; IEnumerable<Tuple<string, string>> names; SqlProviderCodeGenerator codeGenerator = new SqlProviderCodeGenerator(_providerName); IEnumerable<CodeTypeDeclaration> codeTypeDeclarations = codeGenerator.CreateCodeDOMs(dataTypeDescriptor, sqlDataTypeStoreDataScopes, out names); codeTypeDeclarations.ForEach(f => _codeGenerationBuilder.AddType(_namespaceName, f)); _entityClassNamesAndDataContextFieldNames.AddRange(names); _codeGenerationBuilder.AddReference(interfaceType.Assembly); // Property serializer for entity tokens and more string dataIdClassFullName = NamesCreator.MakeDataIdClassFullName(dataTypeDescriptor, _providerName); var keyPropertiesDictionary = new Dictionary<string, Type>(); var keyPropertiesList = new List<Tuple<string, Type>>(); foreach (var keyField in dataTypeDescriptor.KeyFields) { Verify.That(!keyPropertiesDictionary.ContainsKey(keyField.Name), "Key field with name '{0}' already present. Data type: {1}. Check for multiple [KeyPropertyName(...)] attributes", keyField.Name, dataTypeDescriptor.Namespace + "." + dataTypeDescriptor.Name); keyPropertiesDictionary.Add(keyField.Name, keyField.InstanceType); keyPropertiesList.Add(new Tuple<string, Type>(keyField.Name, keyField.InstanceType)); } PropertySerializerTypeCodeGenerator.AddPropertySerializerTypeCode(_codeGenerationBuilder, dataIdClassFullName, keyPropertiesList); }
internal static InterfaceConfigurationElement AddNew(string providerName, DataTypeDescriptor dataTypeDescriptor) { lock (_syncRoot) { var configuration = new SqlDataProviderConfiguration(providerName); if (configuration.Section.Interfaces.ContainsInterfaceType(dataTypeDescriptor.DataTypeId)) { Log.LogWarning(LogTitle, "Configuration file '{0}' already contains an interface with data type ID '{1}', type name '{2}'. " + "Possibly there are multiple AppDomain-s running.", configuration.ConfigurationFilePath, dataTypeDescriptor.DataTypeId, dataTypeDescriptor); return configuration.Section.Interfaces.Get(dataTypeDescriptor); } InterfaceConfigurationElement interfaceConfig = BuildInterfaceConfigurationElement(dataTypeDescriptor); configuration.Section.Interfaces.Add(interfaceConfig); configuration.Save(); return interfaceConfig; } }
internal void AddLocale(DataTypeDescriptor typeDescriptor, CultureInfo cultureInfo) { foreach (DataScopeIdentifier dataScope in typeDescriptor.DataScopes) { CreateStore(typeDescriptor, dataScope, cultureInfo); } }
internal void RemoveLocale(string providerName, DataTypeDescriptor typeDescriptor, CultureInfo cultureInfo) { foreach (DataScopeIdentifier dataScope in typeDescriptor.DataScopes) { DropStore(typeDescriptor, dataScope, cultureInfo); } }
private void CreateScopeData(DataTypeDescriptor typeDescriptor, DataScopeIdentifier dataScope) { foreach (var cultureInfo in GetCultures(typeDescriptor)) { CreateStore(typeDescriptor, dataScope, cultureInfo); } }
public EntityBaseClassGenerator(DataTypeDescriptor dataTypeDescriptor, string entityBaseClassName, string dataIdClassName, string providerName) { _entityBaseClassName = entityBaseClassName; _dataIdClassName = dataIdClassName; _dataTypeDescriptor = dataTypeDescriptor; _providerName = providerName; }
/// <summary> /// Adds the source code defined by <see cref="DataTypeDescriptor"/> to the supplied <see cref="CodeGenerationBuilder"/> /// </summary> /// <param name="codeGenerationBuilder">Source code is added to this builder</param> /// <param name="dataTypeDescriptor">Data type descriptor to convert into source code</param> public static void AddInterfaceTypeCode(CodeGenerationBuilder codeGenerationBuilder, DataTypeDescriptor dataTypeDescriptor) { var codeTypeDeclaration = CreateCodeTypeDeclaration(dataTypeDescriptor); var codeNamespace = new CodeNamespace(dataTypeDescriptor.Namespace); codeNamespace.Types.Add(codeTypeDeclaration); codeGenerationBuilder.AddNamespace(codeNamespace); }
public XmlProviderCodeGenerator(DataTypeDescriptor dataTypeDescriptor, string namespaceName) { _dataTypeDescriptor = dataTypeDescriptor; DataProviderHelperClassFullName = namespaceName + "." + NamesCreator.MakeDataProviderHelperClassName(dataTypeDescriptor); WrapperClassFullName = namespaceName + "." + NamesCreator.MakeWrapperClassName(dataTypeDescriptor); DataIdClassFullName = namespaceName + "." + NamesCreator.MakeDataIdClassName(dataTypeDescriptor); }
public SqlDataProviderHelperGenerator(DataTypeDescriptor dataTypeDescriptor, string sqlDataProviderHelperClassName, string dataIdClassName, string entityClassName, string dataContextFieldName) { _dataTypeDescriptor = dataTypeDescriptor; _sqlDataProviderHelperClassName = sqlDataProviderHelperClassName; _dataIdClassName = dataIdClassName; _entityClassName = entityClassName; _dataContextFieldName = dataContextFieldName; }
internal static IEnumerable<CultureInfo> GetCultures(DataTypeDescriptor typeDescriptor) { if (typeDescriptor.Localizeable) { return DataLocalizationFacade.ActiveLocalizationCultures; } return new [] { CultureInfo.InvariantCulture }; }
internal UpdateDataTypeDescriptor(DataTypeDescriptor oldDataTypeDescriptor, DataTypeDescriptor newDataTypeDescriptor, string providerName) { OldDataTypeDescriptor = oldDataTypeDescriptor; NewDataTypeDescriptor = newDataTypeDescriptor; ProviderName = providerName; }
/// <exclude /> public GeneratedTypesHelper(DataTypeDescriptor oldDataTypeDescriptor) { Verify.ArgumentNotNull(oldDataTypeDescriptor, "oldDataTypeDescriptor"); _oldType = oldDataTypeDescriptor.GetInterfaceType(); _oldDataTypeDescriptor = oldDataTypeDescriptor; Initialize(); }
public EntityClassGenerator(DataTypeDescriptor dataTypeDescriptor, string entityClassName, string entityBaseClassName, string tableName, string dataScopeIdentifierName, string localeCultureName) { _dataTypeDescriptor = dataTypeDescriptor; _entityClassName = entityClassName; _entityBaseClassName = entityBaseClassName; _tableName = tableName; _dataScopeIdentifierName = dataScopeIdentifierName; _localeCultureName = localeCultureName; }
/// <exclude /> public GeneratedTypesHelper(Type oldType) { Verify.ArgumentNotNull(oldType, "oldType"); _oldType = oldType; _oldDataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(oldType); Initialize(); }
//public static GeneratedTypesHelper.KeyFieldType ParseKeyFieldType(string keyFieldTypeStr) //{ // return (GeneratedTypesHelper.KeyFieldType) Enum.Parse(typeof (GeneratedTypesHelper.KeyFieldType), keyFieldTypeStr); //} public static GeneratedTypesHelper.KeyFieldType GetKeyFieldType(DataTypeDescriptor dataTypeDescriptor) { var idField = dataTypeDescriptor.Fields.Single(f => f.Name == "Id"); if (idField != null) { return GetKeyFieldType(idField); } return GeneratedTypesHelper.KeyFieldType.Undefined; }
internal DataTypeChangeDescriptor(DataTypeDescriptor originalTypeDescriptor, DataTypeDescriptor alteredTypeDescriptor, bool originalTypeDataExists) { if (originalTypeDescriptor.DataTypeId != alteredTypeDescriptor.DataTypeId) throw new ArgumentException("The original and current data type descriptors must have the same data type id"); _original = originalTypeDescriptor; _altered = alteredTypeDescriptor; _originalTypeDataExists = originalTypeDataExists; ValidateTypeChanges(); }
/// <exclude /> public DataTypeDescriptorFormsHelper(DataTypeDescriptor dataTypeDescriptor, string bindingNamesPrefix, bool showPublicationStatusSelector, EntityToken entityToken) { if (dataTypeDescriptor == null) throw new ArgumentNullException("dataTypeDescriptor"); _dataTypeDescriptor = dataTypeDescriptor; _bindingNamesPrefix = bindingNamesPrefix; _showPublicationStatusSelector = showPublicationStatusSelector; EntityToken = entityToken; LayoutIconHandle = null; }
public DataProviderHelperClassGenerator( string helperClassName, string wrapperClassName, string dataIdClassName, DataTypeDescriptor dataTypeDescriptor) { _helperClassName = helperClassName; _wrapperClassName = wrapperClassName; _dataIdClassName = dataIdClassName; _dataTypeDescriptor = dataTypeDescriptor; }
internal static bool ConfigurationExists( string providerName, DataTypeDescriptor dataTypeDescriptor) { lock (_syncRoot) { var configuration = new SqlDataProviderConfiguration(providerName); InterfaceConfigurationElement interfaceConfig = BuildInterfaceConfigurationElement(dataTypeDescriptor); return configuration.Section.Interfaces.ContainsInterfaceType(interfaceConfig); } }
internal static void AddEmptyDataClassTypeCode(CodeGenerationBuilder codeGenerationBuilder, DataTypeDescriptor dataTypeDescriptor, Type baseClassType = null, CodeAttributeDeclaration codeAttributeDeclaration = null) { Type interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor); if (interfaceType == null) return; if (baseClassType == null) baseClassType = typeof(EmptyDataClassBase); CodeTypeDeclaration codeTypeDeclaration = CreateCodeTypeDeclaration(dataTypeDescriptor, baseClassType, codeAttributeDeclaration); codeGenerationBuilder.AddType(NamespaceName, codeTypeDeclaration); }
/// <exclude /> public DataTypeDescriptorFormsHelper(DataTypeDescriptor dataTypeDescriptor) : this(dataTypeDescriptor, null, false, null) { }
// Overload /// <exclude /> public static void UpdateDataTypeDescriptor(DataTypeDescriptor dataTypeDescriptor) { UpdateDataTypeDescriptor(dataTypeDescriptor, true); }
/// <exclude /> public DataTypeDescriptorFormsHelper(DataTypeDescriptor dataTypeDescriptor, string bindingNamesPrefix) : this(dataTypeDescriptor, bindingNamesPrefix, false, null) { }
// Overload /// <exclude /> public static void CreateStore(DataTypeDescriptor typeDescriptor) { CreateStore(DataProviderRegistry.DefaultDynamicTypeDataProviderName, typeDescriptor, true); }
/// <summary> /// /// </summary> /// <param name="interfaceType"></param> /// <param name="existingDataTypeDescriptor">Use null to get existing data type descriptor</param> /// <returns></returns> public static bool Validate(Type interfaceType, DataTypeDescriptor existingDataTypeDescriptor) { string errorMessage; return(Validate(interfaceType, existingDataTypeDescriptor, out errorMessage)); }
// Overload /// <exclude /> public static void CreateStore(DataTypeDescriptor typeDescriptor, bool doFlush) { CreateStore(DataProviderRegistry.DefaultDynamicTypeDataProviderName, typeDescriptor, doFlush); }
/// <exclude /> public static bool TryGetDataTypeDescriptor(Guid immutableTypeId, out DataTypeDescriptor dataTypeDescriptor) { return(_dynamicTypeManager.TryGetDataTypeDescriptor(immutableTypeId, out dataTypeDescriptor)); }
// Overload /// <exclude /> public static void CreateStore(string providerName, DataTypeDescriptor typeDescriptor) { CreateStore(providerName, typeDescriptor, true); }
/// <summary> /// This method returns the full interface name. F.e. "Composite.Data.Types.IPage" /// </summary> /// <param name="dataTypeDescriptor"></param> /// <returns></returns> public static string GetFullInterfaceName(this DataTypeDescriptor dataTypeDescriptor) { return(dataTypeDescriptor.Namespace + "." + dataTypeDescriptor.Name); }
/// <exclude /> public bool Equals(DataTypeDescriptor dataTypeDescriptor) { return(dataTypeDescriptor != null && dataTypeDescriptor.DataTypeId == this.DataTypeId); }
// Overload /// <exclude /> public static void DropStore(string providerName, DataTypeDescriptor typeDescriptor) { DropStore(providerName, typeDescriptor, true); }
// Overload /// <exclude /> public static void DropStore(DataTypeDescriptor typeDescriptor) { DropStore(null, typeDescriptor, true); }
/// <exclude /> public static void CreateStore(string providerName, DataTypeDescriptor typeDescriptor, bool doFlush) { _dynamicTypeManager.CreateStores(providerName, new[] { typeDescriptor }, doFlush); OnStoreCreated?.Invoke(typeDescriptor); }
internal DataFieldDescriptorCollection(DataTypeDescriptor parent) { _parent = parent; }
// Overload /// <exclude /> public static bool TryGetDataTypeDescriptor(Type interfaceType, out DataTypeDescriptor dataTypeDescriptor) { return(_dynamicTypeManager.TryGetDataTypeDescriptor(interfaceType.GetImmutableTypeId(), out dataTypeDescriptor)); }
/// <exclude /> public DataTypeChangeDescriptor(DataTypeDescriptor originalTypeDescriptor, DataTypeDescriptor alteredTypeDescriptor) : this(originalTypeDescriptor, alteredTypeDescriptor, true) { }
internal static DataTypeDescriptor FromXml(XElement element, bool inheritedFieldsIncluded) { Verify.ArgumentNotNull(element, "element"); if (element.Name != "DataTypeDescriptor") { throw new ArgumentException("The xml is not correctly formatted."); } Guid dataTypeId = (Guid)element.GetRequiredAttribute("dataTypeId"); string name = element.GetRequiredAttributeValue("name"); string @namespace = element.GetRequiredAttributeValue("namespace"); bool isCodeGenerated = (bool)element.GetRequiredAttribute("isCodeGenerated"); XAttribute cachableAttribute = element.Attribute("cachable"); XAttribute buildNewHandlerTypeNameAttribute = element.Attribute("buildNewHandlerTypeName"); XElement dataAssociationsElement = element.GetRequiredElement("DataAssociations"); XElement dataScopesElement = element.GetRequiredElement("DataScopes"); XElement keyPropertyNamesElement = element.GetRequiredElement("KeyPropertyNames"); XElement versionKeyPropertyNamesElement = element.Element("VersionKeyPropertyNames"); XElement superInterfacesElement = element.GetRequiredElement("SuperInterfaces"); XElement fieldsElement = element.GetRequiredElement("Fields"); XElement indexesElement = element.Element("Indexes"); XAttribute titleAttribute = element.Attribute("title"); XAttribute labelFieldNameAttribute = element.Attribute("labelFieldName"); XAttribute internalUrlPrefixAttribute = element.Attribute("internalUrlPrefix"); string typeManagerTypeName = (string)element.Attribute("typeManagerTypeName"); bool cachable = cachableAttribute != null && (bool)cachableAttribute; var dataTypeDescriptor = new DataTypeDescriptor(dataTypeId, @namespace, name, isCodeGenerated) { Cachable = cachable }; if (titleAttribute != null) { dataTypeDescriptor.Title = titleAttribute.Value; } if (labelFieldNameAttribute != null) { dataTypeDescriptor.LabelFieldName = labelFieldNameAttribute.Value; } if (internalUrlPrefixAttribute != null) { dataTypeDescriptor.InternalUrlPrefix = internalUrlPrefixAttribute.Value; } if (typeManagerTypeName != null) { typeManagerTypeName = TypeManager.FixLegasyTypeName(typeManagerTypeName); dataTypeDescriptor.TypeManagerTypeName = typeManagerTypeName; } if (buildNewHandlerTypeNameAttribute != null) { dataTypeDescriptor.BuildNewHandlerTypeName = buildNewHandlerTypeNameAttribute.Value; } foreach (XElement elm in dataAssociationsElement.Elements()) { var dataTypeAssociationDescriptor = DataTypeAssociationDescriptor.FromXml(elm); dataTypeDescriptor.DataAssociations.Add(dataTypeAssociationDescriptor); } foreach (XElement elm in dataScopesElement.Elements("DataScopeIdentifier")) { string dataScopeName = elm.GetRequiredAttributeValue("name"); if (DataScopeIdentifier.IsLegasyDataScope(dataScopeName)) { Log.LogWarning(LogTitle, "Ignored legacy data scope '{0}' on type '{1}.{2}' while deserializing DataTypeDescriptor. The '{0}' data scope is no longer supported.".FormatWith(dataScopeName, @namespace, name)); continue; } DataScopeIdentifier dataScopeIdentifier = DataScopeIdentifier.Deserialize(dataScopeName); dataTypeDescriptor.DataScopes.Add(dataScopeIdentifier); } foreach (XElement elm in superInterfacesElement.Elements("SuperInterface")) { string superInterfaceTypeName = elm.GetRequiredAttributeValue("type"); if (superInterfaceTypeName.StartsWith("Composite.Data.ProcessControlled.IDeleteControlled")) { Log.LogWarning(LogTitle, $"Ignored legacy super interface '{superInterfaceTypeName}' on type '{@namespace}.{name}' while deserializing DataTypeDescriptor. This super interface is no longer supported."); continue; } Type superInterface; try { superInterface = TypeManager.GetType(superInterfaceTypeName); } catch (Exception ex) { throw XmlConfigurationExtensionMethods.GetConfigurationException($"Failed to load super interface '{superInterfaceTypeName}'", ex, elm); } dataTypeDescriptor.AddSuperInterface(superInterface, !inheritedFieldsIncluded); } foreach (XElement elm in fieldsElement.Elements()) { var dataFieldDescriptor = DataFieldDescriptor.FromXml(elm); try { dataTypeDescriptor.Fields.Add(dataFieldDescriptor); } catch (Exception ex) { throw XmlConfigurationExtensionMethods.GetConfigurationException("Failed to add a data field: " + ex.Message, ex, elm); } } foreach (XElement elm in keyPropertyNamesElement.Elements("KeyPropertyName")) { var propertyName = elm.GetRequiredAttributeValue("name"); bool isDefinedOnSuperInterface = dataTypeDescriptor.SuperInterfaces.Any(f => f.GetProperty(propertyName) != null); if (!isDefinedOnSuperInterface) { dataTypeDescriptor.KeyPropertyNames.Add(propertyName); } } if (versionKeyPropertyNamesElement != null) { foreach (XElement elm in versionKeyPropertyNamesElement.Elements("VersionKeyPropertyName")) { var propertyName = elm.GetRequiredAttributeValue("name"); dataTypeDescriptor.VersionKeyPropertyNames.Add(propertyName); } } if (indexesElement != null) { dataTypeDescriptor.Indexes = indexesElement.Elements("Index").Select(DataTypeIndex.FromXml).ToList(); } // Loading field rendering profiles for static data types if (!isCodeGenerated && typeManagerTypeName != null) { Type type = Type.GetType(typeManagerTypeName); if (type != null) { foreach (var fieldDescriptor in dataTypeDescriptor.Fields) { var property = type.GetProperty(fieldDescriptor.Name); if (property != null) { var formRenderingProfile = DynamicTypeReflectionFacade.GetFormRenderingProfile(property); if (formRenderingProfile != null) { fieldDescriptor.FormRenderingProfile = formRenderingProfile; } } } } } return(dataTypeDescriptor); }
/// <exclude /> public static void UpdateDataTypeDescriptor(DataTypeDescriptor dataTypeDescriptor, bool flushTheSystem) { _dynamicTypeManager.UpdateDataTypeDescriptor(dataTypeDescriptor, flushTheSystem); }
/// <exclude /> public DataTypeDescriptorFormsHelper(DataTypeDescriptor dataTypeDescriptor, bool showPublicationStatusSelector, EntityToken entityToken) : this(dataTypeDescriptor, null, showPublicationStatusSelector, entityToken) { }