/// <exclude /> public static void SetCustomForm(DataTypeDescriptor dataTypeDescriptor, string newFormMarkup) { string dynamicDataFormFolderPath = GetFolderPath(dataTypeDescriptor.Namespace); string dynamicDataFormFileName = GetFilename(dataTypeDescriptor.Name); // Parsing for assertion XDocument.Parse(newFormMarkup); IDynamicTypeFormDefinitionFile formDefinitionFile = DataFacade.GetData<IDynamicTypeFormDefinitionFile>() .FirstOrDefault(f => f.FolderPath.Equals(dynamicDataFormFolderPath, StringComparison.OrdinalIgnoreCase) && f.FileName.Equals(dynamicDataFormFileName, StringComparison.OrdinalIgnoreCase)); if (formDefinitionFile == null) { var newFile = DataFacade.BuildNew<IDynamicTypeFormDefinitionFile>(); newFile.FolderPath = dynamicDataFormFolderPath; newFile.FileName = dynamicDataFormFileName; newFile.SetNewContent(newFormMarkup); formDefinitionFile = DataFacade.AddNew<IDynamicTypeFormDefinitionFile>(newFile); } else { formDefinitionFile.SetNewContent(newFormMarkup); DataFacade.Update(formDefinitionFile); } }
/// <summary> /// Returns custom form markup. /// </summary> /// <param name="dataTypeDescriptor">A data type descriptor</param> /// <returns></returns> public static XDocument GetCustomFormMarkup(DataTypeDescriptor dataTypeDescriptor) { var file = GetCustomFormMarkupFile(dataTypeDescriptor.Namespace, dataTypeDescriptor.Name); if (file == null) { return null; } var markupFilePath = (file as FileSystemFile).SystemPath; return XDocumentUtils.Load(markupFilePath, LoadOptions.SetBaseUri | LoadOptions.SetLineInfo); }
public DataIdClassGenerator(string className, DataTypeDescriptor dataTypeDescriptor) { _className = className; _dataTypeDescriptor = dataTypeDescriptor; }
private void ValidateDynamicAddedType(DataType dataType) { DataTypeDescriptor dataTypeDescriptor = this.InstallerContext.GetPendingDataTypeDescriptor(dataType.InterfaceTypeName); if (dataTypeDescriptor == null) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingTypeDescriptor").FormatWith(dataType.InterfaceTypeName)); return; } bool dataTypeLocalized = dataTypeDescriptor.SuperInterfaces.Contains(typeof(ILocalizedControlled)); if (!ValidateTargetLocaleInfo(dataType, dataTypeLocalized)) { return; } foreach (XElement addElement in dataType.Dataset) { var dataKeyPropertyCollection = new DataKeyPropertyCollection(); bool propertyValidationPassed = true; var fieldValues = new Dictionary <string, object>(); foreach (XAttribute attribute in addElement.Attributes()) { string fieldName = attribute.Name.LocalName; // A compatibility fix if (IsObsoleteField(dataTypeDescriptor, fieldName)) { continue; } DataFieldDescriptor dataFieldDescriptor = dataTypeDescriptor.Fields[fieldName]; if (dataFieldDescriptor == null) { _validationResult.AddFatal(Texts.DataPackageFragmentInstaller_MissingProperty(dataTypeDescriptor, fieldName)); propertyValidationPassed = false; continue; } object fieldValue; try { fieldValue = ValueTypeConverter.Convert(attribute.Value, dataFieldDescriptor.InstanceType); } catch (Exception) { _validationResult.AddFatal(Texts.DataPackageFragmentInstaller_ConversionFailed(attribute.Value, dataFieldDescriptor.InstanceType)); propertyValidationPassed = false; continue; } if (dataTypeDescriptor.KeyPropertyNames.Contains(fieldName)) { dataKeyPropertyCollection.AddKeyProperty(fieldName, fieldValue); } fieldValues.Add(fieldName, fieldValue); } if (!propertyValidationPassed) { continue; } if (!dataType.AllowOverwrite && !dataType.OnlyUpdate) { // TODO: implement check if the same key has already been added } RegisterKeyToBeAdded(dataType, dataTypeDescriptor, dataKeyPropertyCollection); // Checking foreign key references foreach (var referenceField in dataTypeDescriptor.Fields.Where(f => f.ForeignKeyReferenceTypeName != null)) { if (!fieldValues.TryGetValue(referenceField.Name, out object propertyValue) || propertyValue == null || (propertyValue is Guid guid && guid == Guid.Empty) || (propertyValue is string str && str == "")) { continue; } string referredTypeName = referenceField.ForeignKeyReferenceTypeName; var referredType = TypeManager.TryGetType(referredTypeName); if (referredType == null) { // TODO: implement reference check for dynamic types as well continue; } string targetKeyPropertyName = referredType.GetKeyPropertyNames().SingleOrDefault(); CheckForBrokenReference(dataType, referredType, targetKeyPropertyName, propertyValue); } } }
private void ValidateNonDynamicAddedType(DataType dataType) { if (dataType.InterfaceType == null) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.TypeNotConfigured").FormatWith(dataType.InterfaceTypeName)); return; } if (!typeof(IData).IsAssignableFrom(dataType.InterfaceType)) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.TypeNotInheriting").FormatWith(dataType.InterfaceType, typeof(IData))); return; } bool dataTypeLocalized = DataLocalizationFacade.IsLocalized(dataType.InterfaceType); if (!ValidateTargetLocaleInfo(dataType, dataTypeLocalized)) { return; } int itemsAlreadyPresentInDatabase = 0; DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(dataType.InterfaceType); bool isVersionedDataType = typeof(IVersioned).IsAssignableFrom(dataType.InterfaceType); var requiredPropertyNames = (from dfd in dataTypeDescriptor.Fields where !dfd.IsNullable && !(isVersionedDataType && dfd.Name == nameof(IVersioned.VersionId)) // Compatibility fix select dfd.Name).ToList(); var nonRequiredPropertyNames = dataTypeDescriptor.Fields.Select(f => f.Name) .Except(requiredPropertyNames).ToList(); foreach (XElement addElement in dataType.Dataset) { var dataKeyPropertyCollection = new DataKeyPropertyCollection(); bool propertyValidationPassed = true; var assignedPropertyNames = new List <string>(); var fieldValues = new Dictionary <string, object>(); var properties = GetDataTypeProperties(dataType.InterfaceType); foreach (XAttribute attribute in addElement.Attributes()) { string fieldName = attribute.Name.LocalName; PropertyInfo propertyInfo; if (!properties.TryGetValue(fieldName, out propertyInfo)) { // A compatibility fix if (IsObsoleteField(dataType, fieldName)) { continue; } _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingProperty").FormatWith(dataType.InterfaceType, fieldName)); propertyValidationPassed = false; continue; } if (!propertyInfo.CanWrite) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingWritableProperty").FormatWith(dataType.InterfaceType, fieldName)); propertyValidationPassed = false; continue; } object fieldValue; try { fieldValue = ValueTypeConverter.Convert(attribute.Value, propertyInfo.PropertyType); } catch (Exception) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.ConversionFailed").FormatWith(attribute.Value, propertyInfo.PropertyType)); propertyValidationPassed = false; continue; } if (dataType.InterfaceType.GetKeyPropertyNames().Contains(fieldName)) { dataKeyPropertyCollection.AddKeyProperty(fieldName, fieldValue); } assignedPropertyNames.Add(fieldName); fieldValues.Add(fieldName, fieldValue); } if (!propertyValidationPassed) { continue; } var notAssignedRequiredProperties = requiredPropertyNames.Except(assignedPropertyNames.Except(nonRequiredPropertyNames)).ToArray(); if (notAssignedRequiredProperties.Any()) { bool missingValues = false; foreach (string propertyName in notAssignedRequiredProperties) { PropertyInfo propertyInfo = dataType.InterfaceType.GetPropertiesRecursively().Single(f => f.Name == propertyName); if (propertyInfo.CanWrite) { var defaultValueAttribute = propertyInfo.GetCustomAttributesRecursively <NewInstanceDefaultFieldValueAttribute>().SingleOrDefault(); if (defaultValueAttribute == null || !defaultValueAttribute.HasValue) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.MissingPropertyVaule").FormatWith(propertyName, dataType.InterfaceType)); missingValues = true; } } } if (missingValues) { continue; } } // Validating keys already present if (!dataType.AllowOverwrite && !dataType.OnlyUpdate) { bool dataLocaleExists = !DataLocalizationFacade.IsLocalized(dataType.InterfaceType) || (!dataType.AddToAllLocales && !dataType.AddToCurrentLocale) || (dataType.Locale != null && !this.InstallerContext.IsLocalePending(dataType.Locale)); if (dataLocaleExists) { using (new DataScope(dataType.DataScopeIdentifier, dataType.Locale)) { IData data = DataFacade.TryGetDataByUniqueKey(dataType.InterfaceType, dataKeyPropertyCollection); if (data != null) { itemsAlreadyPresentInDatabase++; } } } } RegisterKeyToBeAdded(dataType, null, dataKeyPropertyCollection); // Checking foreign key references foreach (var foreignKeyProperty in DataAttributeFacade.GetDataReferenceProperties(dataType.InterfaceType)) { if (!fieldValues.ContainsKey(foreignKeyProperty.SourcePropertyName)) { continue; } object propertyValue = fieldValues[foreignKeyProperty.SourcePropertyName]; if (propertyValue == null || propertyValue.Equals(foreignKeyProperty.NullReferenceValue)) { continue; } CheckForBrokenReference(dataType, foreignKeyProperty.TargetType, foreignKeyProperty.TargetKeyPropertyName, propertyValue); } } if (itemsAlreadyPresentInDatabase > 0) { _validationResult.AddFatal(GetText("DataPackageFragmentInstaller.DataExists").FormatWith(dataType.InterfaceType, itemsAlreadyPresentInDatabase)); } }
public DataIdClassGenerator(DataTypeDescriptor dataTypeDescriptor, string dataIdClassName) { _dataTypeDescriptor = dataTypeDescriptor; _dataIdClassName = dataIdClassName; }
public string CreatePackagePack() { using (new DataScope(DataScopeIdentifier.Public)) { #region Init if (_packageName == string.Empty) { return(""); } _packageDirectoryPath = Path.Combine(_serviceDirectoryPath, _packageName); if (Directory.Exists(_packageDirectoryPath)) { Directory.Delete(_packageDirectoryPath, true); } var dataPackageDirectoryPath = Path.Combine(_serviceDirectoryPath, _packageName + "_Data"); _zipDirectoryPath = Path.Combine(_packageDirectoryPath, "Release"); _packageDirectoryPath = Path.Combine(_packageDirectoryPath, "Package"); Directory.CreateDirectory(_packageDirectoryPath); Directory.CreateDirectory(_zipDirectoryPath); if (Directory.Exists(dataPackageDirectoryPath)) { FileSystem.CopyDirectory(dataPackageDirectoryPath, _packageDirectoryPath); } string packageConfigFilePath = Path.Combine(_serviceDirectoryPath, _packageName + ".xml"); XDocument config = XDocument.Load(packageConfigFilePath); var rootConfigElement = config.Element(pc + "PackageCreator"); if (rootConfigElement == null) { throw new InvalidOperationException("Root element of config PackageCreator 2.0 not found"); } XElement blockElement; #endregion #region Init install.xml XDocument XPackage = new XDocument(); XPackage.Declaration = new XDeclaration("1.0", "utf-8", "yes"); XElement XPackageInstaller = new XElement(mi + "PackageInstaller"); XPackageInstaller.Add(new XAttribute(XNamespace.Xmlns + "mi", mi)); XElement XPackageRequirements = config.Descendants(mi + "PackageRequirements").FirstOrDefault(); XPackageInstaller.Add(XPackageRequirements); XElement XPackageInformation = config.Descendants(mi + "PackageInformation").FirstOrDefault(); AllowOverwriteDataOnInstall = XPackageInformation.AllowOverwriteAttributeValue(); XPackageInstaller.Add(XPackageInformation); XElement XPackageFragmentInstallerBinaries = new XElement(mi + "PackageFragmentInstallerBinaries"); try { XPackageFragmentInstallerBinaries = config.Descendants(mi + "PackageFragmentInstallerBinaries").First(); } catch { } XPackageFragmentInstallerBinaries.ReplaceNodes(XPackageFragmentInstallerBinaries.Elements().OrderBy(ReferencedAssemblies.AssemblyPosition)); XPackageInstaller.Add(XPackageFragmentInstallerBinaries); XElement XPackageFragmentInstallers = new XElement(mi + "PackageFragmentInstallers"); #endregion #region Init Categories foreach (var categoryType in PackageCreatorActionFacade.CategoryTypes) { if (categoryType.Value.IsInitable()) { foreach (var packageItem in PackageCreatorFacade.GetItems(categoryType.Value, config.Root)) { (packageItem as IPackInit).Init(this); } } } #endregion #region XML PageTemplates XElement PageTemplates = config.Descendants(pc + "PageTemplates").FirstOrDefault(); if (PageTemplates != null) { foreach (XElement item in PageTemplates.Elements("Add")) { var pageTemplate = (from i in DataFacade.GetData <IXmlPageTemplate>() where i.Title == item.IndexAttributeValue() select i).FirstOrDefault(); if (pageTemplate != null) { var newPageTemplateFilePath = "\\" + pageTemplate.Title + ".xml"; AddFile("App_Data\\PageTemplates" + pageTemplate.PageTemplateFilePath, "App_Data\\PageTemplates" + newPageTemplateFilePath); pageTemplate.PageTemplateFilePath = newPageTemplateFilePath; AddData(pageTemplate); } } } #endregion #region Files XElement InstallFiles = config.Descendants(pc + "Files").FirstOrDefault(); if (InstallFiles != null) { foreach (XElement item in InstallFiles.Elements("Add")) { var filename = item.IndexAttributeValue(); if (string.IsNullOrEmpty(filename)) { throw new InvalidOperationException("Files->Add attribute 'name' must be spesified"); } AddFile(filename); } } #endregion #region FilesInDirectory XElement InstallFilesInDirectory = config.Descendants(pc + "FilesInDirectories").FirstOrDefault(); if (InstallFilesInDirectory != null) { foreach (XElement item in InstallFilesInDirectory.Elements("Add")) { var path = item.IndexAttributeValue(); AddFilesInDirectory(path); } } #endregion #region Directories XElement InstallDirectories = config.Descendants(pc + "Directories").FirstOrDefault(); if (InstallDirectories != null) { foreach (XElement item in InstallDirectories.Elements("Add")) { try { var filename = item.IndexAttributeValue(); AddDirectory(filename); } catch { } } } #endregion #region Datas blockElement = rootConfigElement.Element(pc + "Datas"); if (blockElement != null) { foreach (XElement item in blockElement.Elements("Type")) { var dataTypeName = item.Attribute("type").Value; var dataScopeIdentifier = item.Element("Data").Attribute("dataScopeIdentifier").Value; AddData(dataTypeName, dataScopeIdentifier); } } #endregion #region DataItems blockElement = rootConfigElement.Element(pc + "DataItems"); if (blockElement != null) { foreach (XElement item in blockElement.Elements("Type")) { var dataTypeName = item.Attribute("type").Value; Func <XElement, Func <IData, bool> > trueAttributes = e => e.Attributes().Where(x => x.Name.Namespace == XNamespace.None) .Aggregate(new Func <IData, bool>(d => true), (f, x) => new Func <IData, bool>(d => (d.GetProperty(x.Name.LocalName) == x.Value) && f(d))); Func <IData, bool> where = item.Elements("Add") .Aggregate(new Func <IData, bool>(d => false), (f, e) => new Func <IData, bool>(d => trueAttributes(e)(d) || f(d))); AddData(dataTypeName, where); } } #endregion #warning TODO: Datatypes data format depends from datatype exists in package or not, thats why list of dtatype must created before adding data #region DynamicDataTypes XElement DynamicDataTypes = config.Descendants(pc + "DynamicDataTypes").FirstOrDefault(); XElement DynamicDataTypePackageFragmentInstaller = null; if (DynamicDataTypes != null) { List <XElement> dataTypes = new List <XElement>(); foreach (XElement item in DynamicDataTypes.Elements("Add").OrderBy(e => DataPosition(e.IndexAttributeValue()))) { var dynamicDataType = TypeManager.GetType(item.IndexAttributeValue()); var dynamicDataTypeName = TypeManager.SerializeType(dynamicDataType); AddData <IGeneratedTypeWhiteList>(d => d.TypeManagerTypeName == dynamicDataTypeName); installDataTypeNamesList.Add(dynamicDataTypeName); var type = TypeManager.GetType(item.IndexAttributeValue()); DataTypeDescriptor dataTypeDescriptor = DynamicTypeManager.GetDataTypeDescriptor(type); dataTypes.Add(new XElement("Type", new XAttribute("providerName", "GeneratedDataTypesElementProvider"), new XAttribute("dataTypeDescriptor", dataTypeDescriptor.ToXml().ToString()), new XAttribute("allowOverwrite", AllowOverwriteDataOnInstall)) ); AddFileIfExists("App_Data\\Composite\\DynamicTypeForms\\" + item.IndexAttributeValue().Replace('.', '\\') + ".xml"); } DynamicDataTypePackageFragmentInstaller = new XElement(mi + "Add", new XAttribute("installerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.DynamicDataTypePackageFragmentInstaller, Composite"), new XAttribute("uninstallerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.DynamicDataTypePackageFragmentUninstaller, Composite"), new XElement("Types", dataTypes ) ); } #endregion //Add only one MetaTypeTab using (new GuidReplacer(from cd in DataFacade.GetData <ICompositionContainer>() select new KeyValuePair <Guid, Guid>(cd.GetProperty <Guid>("Id"), GuidReplacer.CompositionContainerGuid) )) { foreach (var categoryType in PackageCreatorActionFacade.CategoryTypes) { if (categoryType.Value.IsPackagable()) { foreach (var packageItem in PackageCreatorFacade.GetItems(categoryType.Value, config.Root)) { (packageItem as IPack).Pack(this); } } } #region DynamicDataTypesData XElement element = config.Descendants(pc + "DynamicDataTypesData").FirstOrDefault(); if (element != null) { foreach (XElement item in element.Elements("Add")) { var indexAttrValue = item.IndexAttributeValue(); AddDataTypeData(TypeManager.TryGetType(indexAttrValue)); } } } #endregion #region TransformationPackageFragmentInstallers XElement ConfigurationTransformationPackageFragmentInstallers = null; var sources = new HashSet <string>(); sources.UnionWith(ConfigurationXPaths.Keys); sources.UnionWith(ConfigurationTemplates.Keys); foreach (var source in sources) { XDocument installXsl = XDocument.Parse(blankXsl); XDocument uninstallXsl = XDocument.Parse(blankXsl); HashSet <string> xpaths; if (ConfigurationXPaths.TryGetValue(source, out xpaths)) { var nodes = new Dictionary <string, Dictionary <string, XElement> >(); foreach (string xpath in xpaths) { var configuration = PackageCreatorFacade.GetConfigurationDocument(source); var element = configuration.XPathSelectElement(xpath); Regex re = new Regex(@"^(.*?)/([^/]*(\[[^\]]*\])?)$"); Match match = re.Match(xpath); if (match.Success) { var itemPath = match.Groups[1].Value; var itemKey = match.Groups[2].Value; nodes.Add(itemPath, itemKey, element); uninstallXsl.Root.Add( new XElement(xsl + "template", new XAttribute("match", xpath) ) ); } } foreach (var node in nodes) { installXsl.Root.Add( new XElement(xsl + "template", new XAttribute("match", node.Key), new XElement(xsl + "copy", new XElement(xsl + "apply-templates", new XAttribute("select", "@* | node()")), from e in node.Value select new XElement(xsl + "if", new XAttribute("test", string.Format("count({0})=0", e.Key)), e.Value ) ) ) ); } } List <XElement> templates; if (ConfigurationTemplates.TryGetValue(source, out templates)) { installXsl.Root.Add(templates); } var configDirectory = Path.Combine(_packageDirectoryPath, source); if (!Directory.Exists(configDirectory)) { Directory.CreateDirectory(configDirectory); } installXsl.SaveTabbed(Path.Combine(configDirectory, configInstallFileName)); uninstallXsl.SaveTabbed(Path.Combine(configDirectory, configUninstallFileName)); if (PCCompositeConfig.Source == source) { ConfigurationTransformationPackageFragmentInstallers = new XElement(mi + "Add", new XAttribute("installerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.ConfigurationTransformationPackageFragmentInstaller, Composite"), new XAttribute("uninstallerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.ConfigurationTransformationPackageFragmentUninstaller, Composite"), new XElement("Install", new XAttribute("xsltFilePath", string.Format(@"~\{0}\{1}", source, configInstallFileName)) ), new XElement("Uninstall", new XAttribute("xsltFilePath", string.Format(@"~\{0}\{1}", source, configUninstallFileName)) ) ); } else { XslFiles.Add( new XElement("XslFile", new XAttribute("pathXml", PackageCreatorFacade.GetConfigurationPath(source)), new XAttribute("installXsl", string.Format(@"~\{0}\{1}", source, configInstallFileName)), new XAttribute("uninstallXsl", string.Format(@"~\{0}\{1}", source, configUninstallFileName)) ) ); } } #endregion XElement XPackageFragments = config.Descendants(pc + "PackageFragmentInstallers").FirstOrDefault(); if (XPackageFragments != null) { XPackageFragmentInstallers.Add(XPackageFragments.Elements()); } XPackageFragmentInstallers.Add(ConfigurationTransformationPackageFragmentInstallers); #region FilePackageFragmentInstaller if (Files.Count + Directories.Count > 0) { XElement FilePackageFragmentInstaller = new XElement(mi + "Add", new XAttribute("installerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.FilePackageFragmentInstaller, Composite"), new XAttribute("uninstallerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.FilePackageFragmentUninstaller, Composite"), Files.Count == 0 ? null : new XElement("Files" , Files.OrderBy(d => ReferencedAssemblies.AssemblyPosition(d)) ), Directories.Count == 0 ? null : new XElement("Directories" , Directories ) ); XPackageFragmentInstallers.Add(FilePackageFragmentInstaller); } #endregion #region FileXslTransformationPackageFragmentInstaller if (XslFiles.Count > 0) { XPackageFragmentInstallers.Add(new XElement(mi + "Add", new XAttribute("installerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.FileXslTransformationPackageFragmentInstaller, Composite"), new XAttribute("uninstallerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.FileXslTransformationPackageFragmentUninstaller, Composite"), new XElement("XslFiles" , XslFiles ) ) ); } #endregion XPackageFragmentInstallers.Add(DynamicDataTypePackageFragmentInstaller); #region DataPackageFragmentInstaller if (Datas.Count > 0) { var DataPackageFragmentInstaller = new XElement(mi + "Add", new XAttribute("installerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.DataPackageFragmentInstaller, Composite"), new XAttribute("uninstallerType", "Composite.Core.PackageSystem.PackageFragmentInstallers.DataPackageFragmentUninstaller, Composite"), new XElement("Types", from t in Datas orderby t.Key orderby DataPosition(t.Value.AttributeValue("type")) select t.Value ) ); XPackageFragmentInstallers.Add(DataPackageFragmentInstaller); } #endregion DataFiles.Save(); XPackageFragmentInstallers.ReplaceNodes(XPackageFragmentInstallers.Elements().OrderBy(FragmentPosition).Select(DeleteOrderingMark)); XPackageInstaller.Add(XPackageFragmentInstallers); XPackage.Add(XPackageInstaller); XPackage.SaveTabbed(Path.Combine(_packageDirectoryPath, InstallFilename)); var zipFilename = _packageName + ".zip"; #region Zipping var filenames = Directory.GetFiles(_packageDirectoryPath, "*", SearchOption.AllDirectories); var directories = Directory.GetDirectories(_packageDirectoryPath, "*", SearchOption.AllDirectories); using (var archiveFileStream = File.Create(Path.Combine(_zipDirectoryPath, zipFilename))) using (var archive = new ZipArchive(archiveFileStream, ZipArchiveMode.Create)) { foreach (string directory in directories) { string directoryEntryName = directory.Replace(_packageDirectoryPath + "\\", "").Replace("\\", "/") + "/"; var dirEntry = archive.CreateEntry(directoryEntryName); dirEntry.LastWriteTime = Directory.GetLastWriteTime(directory); } foreach (string file in filenames) { string fileEntryName = file.Replace(_packageDirectoryPath + "\\", "").Replace("\\", "/"); var entry = archive.CreateEntry(fileEntryName, PackageCompressionLevel); using (var fileStream = File.OpenRead(file)) using (var entryStream = entry.Open()) { fileStream.CopyTo(entryStream); } } } #endregion var packageCreatorDirectory = Path.Combine(_packageDirectoryPath, "../_" + CREATOR_DRECTORY); try { Directory.CreateDirectory(packageCreatorDirectory); var packageCopyFilePath = packageCreatorDirectory + @"\" + _packageName + ".xml"; File.Copy(packageConfigFilePath, packageCopyFilePath); SetFileReadAccess(packageCopyFilePath, false); } catch { } try { if (Directory.Exists(dataPackageDirectoryPath)) { FileSystem.CopyDirectory(dataPackageDirectoryPath, packageCreatorDirectory + @"\" + _packageName + "_Data"); } } catch { } return(Path.Combine(_packageName, "Release", zipFilename)); } }
internal bool ContainsInterfaceType(DataTypeDescriptor dataTypeDescriptor) { return(ContainsInterfaceType(dataTypeDescriptor.DataTypeId)); }
private static void AddInterfaceProperties(CodeTypeDeclaration codeTypeDeclaratoin, DataTypeDescriptor dataTypeDescriptor, List <string> propertyNamesToSkip) { foreach (DataFieldDescriptor dataFieldDescriptor in dataTypeDescriptor.Fields.Where(dfd => dfd.Inherited == false)) { if (propertyNamesToSkip.Contains(dataFieldDescriptor.Name)) { continue; } var codeMemberProperty = new CodeMemberProperty { Name = dataFieldDescriptor.Name, Type = new CodeTypeReference(dataFieldDescriptor.InstanceType), HasGet = true, HasSet = true }; AddPropertyAttributes(codeMemberProperty, dataFieldDescriptor, dataTypeDescriptor.KeyPropertyNames.Contains(dataFieldDescriptor.Name)); codeTypeDeclaratoin.Members.Add(codeMemberProperty); } }
/// <summary> /// Checks that tables related to specified data type included in current DataContext class, if not - compiles a new version of DataContext that contains them /// </summary> private HelperClassesGenerationInfo EnsureNeededTypes( DataTypeDescriptor dataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> sqlDataTypeStoreDataScopes, Dictionary <DataTypeDescriptor, IEnumerable <SqlDataTypeStoreDataScope> > allSqlDataTypeStoreDataScopes, Type dataContextClassType, out Dictionary <SqlDataTypeStoreTableKey, StoreTypeInfo> fields, ref bool dataContextRecompileNeeded, bool forceCompile = false) { lock (_lock) { // Getting the interface (ensuring that it exists) Type interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor); var storeDataScopesToCompile = new List <SqlDataTypeStoreDataScope>(); var storeDataScopesAlreadyCompiled = new List <SqlDataTypeStoreDataScope>(); fields = new Dictionary <SqlDataTypeStoreTableKey, StoreTypeInfo>(); foreach (SqlDataTypeStoreDataScope storeDataScope in sqlDataTypeStoreDataScopes) { string dataContextFieldName = NamesCreator.MakeDataContextFieldName(storeDataScope.TableName); FieldInfo dataContextFieldInfo = null; if (dataContextClassType != null) { dataContextFieldInfo = dataContextClassType.GetFields(BindingFlags.Public | BindingFlags.Instance) .SingleOrDefault(f => f.Name == dataContextFieldName); } string sqlDataProviderHelperClassFullName = NamesCreator.MakeSqlDataProviderHelperClassFullName(dataTypeDescriptor, storeDataScope.DataScopeName, storeDataScope.CultureName, _dataProviderContext.ProviderName); string entityClassName = NamesCreator.MakeEntityClassFullName(dataTypeDescriptor, storeDataScope.DataScopeName, storeDataScope.CultureName, _dataProviderContext.ProviderName); Type sqlDataProviderHelperClass = null, entityClass = null; try { sqlDataProviderHelperClass = TryGetGeneratedType(sqlDataProviderHelperClassFullName); entityClass = TryGetGeneratedType(entityClassName); forceCompile = forceCompile || CodeGenerationManager.IsRecompileNeeded(interfaceType, new[] { sqlDataProviderHelperClass, entityClass }); } catch (TypeLoadException) { forceCompile = true; } if (!forceCompile) { var storeTypeInfo = new StoreTypeInfo(dataContextFieldName, entityClass, sqlDataProviderHelperClass) { DataContextField = dataContextFieldInfo }; fields.Add(new SqlDataTypeStoreTableKey(storeDataScope.DataScopeName, storeDataScope.CultureName), storeTypeInfo); } if (dataContextFieldInfo == null) { dataContextRecompileNeeded = true; } if (forceCompile) { storeDataScopesToCompile.Add(storeDataScope); } else { storeDataScopesAlreadyCompiled.Add(storeDataScope); } } if (storeDataScopesToCompile.Any()) { dataContextRecompileNeeded = true; if (!dataTypeDescriptor.IsCodeGenerated) { // Building a new descriptor so generated classes take in account field changes dataTypeDescriptor = DynamicTypeManager.BuildNewDataTypeDescriptor(interfaceType); } return(CompileMissingClasses(dataTypeDescriptor, allSqlDataTypeStoreDataScopes, fields, storeDataScopesToCompile, storeDataScopesAlreadyCompiled)); } } return(null); }
private void UpdateDataTypeStore(DataTypeDescriptor dataTypeDescriptor, Type interfaceType, XmlDataTypeStore xmlDateTypeStore) { _xmlDataTypeStoresContainer.UpdateSupportedDataTypeStore(interfaceType, xmlDateTypeStore); }
private static string CreateFilename(DataTypeDescriptor dataTypeDescriptor) { return(Path.Combine(_metaDataPath, string.Format("{0} {1}.xml", dataTypeDescriptor.Name, dataTypeDescriptor.DataTypeId))); }
internal static IEnumerable <Assembly> GetReferencedAssemblies(DataTypeDescriptor dataTypeDescriptor) { yield return(typeof(ImmutableTypeIdAttribute).Assembly); yield return(typeof(Microsoft.Practices.EnterpriseLibrary.Validation.Validators.NotNullValidatorAttribute).Assembly); }
/// <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); }
/// <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); } }
/// <exclude /> public static DataTypeDescriptor Build(Type type) { Verify.ArgumentNotNull(type, "type"); Verify.ArgumentCondition(typeof(IData).IsAssignableFrom(type), "type", "{0} does not implement {1}".FormatWith(type.FullName, typeof(IData).FullName)); Guid dataTypeId = DynamicTypeReflectionFacade.GetImmutableTypeId(type); bool isCodeGenerated = type.GetCustomInterfaceAttributes<CodeGeneratedAttribute>().Any(); var typeDescriptor = new DataTypeDescriptor(dataTypeId, type.Namespace, type.Name, TypeManager.SerializeType(type), isCodeGenerated) { Title = DynamicTypeReflectionFacade.GetTitle(type), LabelFieldName = DynamicTypeReflectionFacade.GetLabelPropertyName(type), InternalUrlPrefix = DynamicTypeReflectionFacade.GetInternalUrlPrefix(type), DataAssociations = DynamicTypeReflectionFacade.GetDataTypeAssociationDescriptors(type) }; List<Type> superInterfaces = type.GetInterfacesRecursively(t => typeof(IData).IsAssignableFrom(t) && t != typeof(IData)); typeDescriptor.SetSuperInterfaces(superInterfaces); Type buildNewHandlerType = DynamicTypeReflectionFacade.GetBuildNewHandlerType(type); if (buildNewHandlerType != null) typeDescriptor.BuildNewHandlerTypeName = TypeManager.SerializeType(buildNewHandlerType); foreach (PropertyInfo propertyInfo in type.GetProperties()) { DataFieldDescriptor fieldDescriptor = BuildFieldDescriptor(propertyInfo, false); typeDescriptor.Fields.Add(fieldDescriptor); } foreach (Type superInterfaceType in superInterfaces) { foreach (PropertyInfo propertyInfo in superInterfaceType.GetProperties()) { if (propertyInfo.Name == nameof(IPageData.PageId) && propertyInfo.DeclaringType == typeof(IPageData)) { continue; } DataFieldDescriptor fieldDescriptor = BuildFieldDescriptor(propertyInfo, true); typeDescriptor.Fields.Add(fieldDescriptor); } } ValidateAndAddKeyProperties(typeDescriptor.KeyPropertyNames, typeDescriptor.VersionKeyPropertyNames, type); string[] storeSortOrder = DynamicTypeReflectionFacade.GetSortOrder(type); if (storeSortOrder != null) { foreach (string name in storeSortOrder) { typeDescriptor.StoreSortOrderFieldNames.Add(name); } } CheckSortOrder(typeDescriptor); foreach (var dataScopeIdentifier in DynamicTypeReflectionFacade.GetDataScopes(type)) { if (!typeDescriptor.DataScopes.Contains(dataScopeIdentifier)) { typeDescriptor.DataScopes.Add(dataScopeIdentifier); } } foreach (string keyPropertyName in type.GetKeyPropertyNames()) { if (typeDescriptor.Fields[keyPropertyName] == null) { throw new InvalidOperationException( $"The type '{type}' has a non existing key property specified by the attribute '{typeof (KeyPropertyNameAttribute)}'"); } } var indexes = new List<DataTypeIndex>(); foreach (var indexAttribute in type.GetCustomAttributesRecursively<IndexAttribute>()) { foreach (var field in indexAttribute.Fields) { if (typeDescriptor.Fields[field.Item1] == null) { throw new InvalidOperationException($"Index field '{field.Item1}' is not defined"); } } indexes.Add(new DataTypeIndex(indexAttribute.Fields) { Clustered = indexAttribute.Clustered }); } indexes.Sort((a,b) => string.Compare(a.ToString(), b.ToString(), StringComparison.Ordinal)); typeDescriptor.Indexes = indexes; return typeDescriptor; }
private void CreateNewType() { _newDataTypeDescriptor = CreateNewDataTypeDescriptor(); GeneratedTypesFacade.GenerateNewType(_newDataTypeDescriptor); }
private static string GetStoreName(DataTypeDescriptor dtd) => dtd.GetFullInterfaceName();
private DataTypeDescriptor CreateNewDataTypeDescriptor( string typeNamespace, string typeName, string typeTitle, string labelFieldName, string internalUrlPrefix, bool cachable, bool publishControlled, bool localizedControlled, IEnumerable <DataFieldDescriptor> dataFieldDescriptors, DataFieldDescriptor foreignKeyDataFieldDescriptor, DataTypeAssociationDescriptor dataTypeAssociationDescriptor, DataFieldDescriptor compositionRuleForeignKeyDataFieldDescriptor) { Guid id = Guid.NewGuid(); var dataTypeDescriptor = new DataTypeDescriptor(id, typeNamespace, typeName, true) { Cachable = cachable, Title = typeTitle, LabelFieldName = labelFieldName, InternalUrlPrefix = internalUrlPrefix }; dataTypeDescriptor.DataScopes.Add(DataScopeIdentifier.Public); if (publishControlled && _dataAssociationType != DataAssociationType.Composition) { dataTypeDescriptor.AddSuperInterface(typeof(IPublishControlled)); } if (localizedControlled) { dataTypeDescriptor.AddSuperInterface(typeof(ILocalizedControlled)); } //bool addKeyField = true; if (_dataAssociationType == DataAssociationType.Aggregation) { dataTypeDescriptor.AddSuperInterface(typeof(IPageDataFolder)); } else if (_dataAssociationType == DataAssociationType.Composition) { //addKeyField = false; dataTypeDescriptor.AddSuperInterface(typeof(IPageData)); dataTypeDescriptor.AddSuperInterface(typeof(IPageRelatedData)); dataTypeDescriptor.AddSuperInterface(typeof(IPageMetaData)); } //if (addKeyField) //{ // var idDataFieldDescriptor = BuildKeyFieldDescriptor(); // dataTypeDescriptor.Fields.Add(idDataFieldDescriptor); // dataTypeDescriptor.KeyPropertyNames.Add(IdFieldName); //} foreach (DataFieldDescriptor dataFieldDescriptor in dataFieldDescriptors) { dataTypeDescriptor.Fields.Add(dataFieldDescriptor); } if (_newKeyFieldName != null) { dataTypeDescriptor.KeyPropertyNames.Add(_newKeyFieldName); } int position = 100; if (_foreignKeyDataFieldDescriptor != null) { _foreignKeyDataFieldDescriptor.Position = position++; if (foreignKeyDataFieldDescriptor.Name != PageReferenceFieldName) { dataTypeDescriptor.Fields.Add(foreignKeyDataFieldDescriptor); dataTypeDescriptor.DataAssociations.Add(dataTypeAssociationDescriptor); } } return(dataTypeDescriptor); }
internal void Remove(DataTypeDescriptor dataTypeDescriptor) { Remove(dataTypeDescriptor.DataTypeId); }
//private DataFieldDescriptor BuildKeyFieldDescriptor() //{ // DataFieldDescriptor result; // switch (_keyFieldType) // { // case KeyFieldType.Guid: // result = BuildIdField(); // break; // case KeyFieldType.RandomString4: // result = new DataFieldDescriptor(Guid.NewGuid(), IdFieldName, StoreFieldType.String(22), typeof (string)) // { // DefaultValue = DefaultValue.RandomString(4, true) // }; // break; // case KeyFieldType.RandomString8: // result = new DataFieldDescriptor(Guid.NewGuid(), IdFieldName, StoreFieldType.String(22), typeof (string)) // { // DefaultValue = DefaultValue.RandomString(8, false) // }; // break; // default: throw new InvalidOperationException("Not supported key field type value"); // } // result.Position = -1; // return result; //} private DataTypeDescriptor CreateUpdatedDataTypeDescriptor() { var dataTypeDescriptor = new DataTypeDescriptor(_oldDataTypeDescriptor.DataTypeId, _newTypeNamespace, _newTypeName, true); dataTypeDescriptor.DataScopes.Add(DataScopeIdentifier.Public); dataTypeDescriptor.Cachable = _cachable; Type[] indirectlyInheritedInterfaces = { typeof(IPublishControlled), typeof(ILocalizedControlled), typeof(IPageData), typeof(IPageFolderData), typeof(IPageMetaData) }; // Foreign interfaces should stay inherited foreach (var superInterface in _oldDataTypeDescriptor.SuperInterfaces) { if (!indirectlyInheritedInterfaces.Contains(superInterface)) { dataTypeDescriptor.AddSuperInterface(superInterface); } } if (_publishControlled && _dataAssociationType != DataAssociationType.Composition) { dataTypeDescriptor.AddSuperInterface(typeof(IPublishControlled)); } if (_localizedControlled && _dataAssociationType != DataAssociationType.Composition) { dataTypeDescriptor.AddSuperInterface(typeof(ILocalizedControlled)); } if (_oldDataTypeDescriptor.SuperInterfaces.Contains(typeof(IPageFolderData))) { dataTypeDescriptor.AddSuperInterface(typeof(IPageData)); dataTypeDescriptor.AddSuperInterface(typeof(IPageFolderData)); } else if (_oldDataTypeDescriptor.SuperInterfaces.Contains(typeof(IPageMetaData))) { dataTypeDescriptor.AddSuperInterface(typeof(IPageData)); dataTypeDescriptor.AddSuperInterface(typeof(IPageMetaData)); } else { //DataFieldDescriptor idDataFieldDescriptor = // (from dfd in _oldDataTypeDescriptor.Fields // where dfd.Name == KeyFieldName // select dfd).Single(); //dataTypeDescriptor.Fields.Add(idDataFieldDescriptor); //dataTypeDescriptor.KeyPropertyNames.Add(KeyFieldName); } dataTypeDescriptor.Title = _newTypeTitle; foreach (DataFieldDescriptor dataFieldDescriptor in _newDataFieldDescriptors) { dataTypeDescriptor.Fields.Add(dataFieldDescriptor); } if (KeyFieldName != null && !dataTypeDescriptor.KeyPropertyNames.Contains(KeyFieldName)) { dataTypeDescriptor.KeyPropertyNames.Add(KeyFieldName); } dataTypeDescriptor.LabelFieldName = _newLabelFieldName; dataTypeDescriptor.InternalUrlPrefix = _newInternalUrlPrefix; dataTypeDescriptor.DataAssociations.AddRange(_oldDataTypeDescriptor.DataAssociations); int position = 100; if (_foreignKeyDataFieldDescriptor != null) { _foreignKeyDataFieldDescriptor.Position = position++; if (_foreignKeyDataFieldDescriptor.Name != PageReferenceFieldName) { dataTypeDescriptor.Fields.Add(_foreignKeyDataFieldDescriptor); } } return(dataTypeDescriptor); }
public static void CreateStore(string providerName, DataTypeDescriptor typeDescriptor) { CreateStores(providerName, new[] { typeDescriptor }); }
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); }
private static DataTypeDescriptorFormsHelper CreateDataTypeDescriptorFormsHelper(IPageMetaDataDefinition pageMetaDataDefinition, DataTypeDescriptor dataTypeDescriptor) { var bindingPrefix = $"{pageMetaDataDefinition.Name}:{dataTypeDescriptor.Namespace}.{dataTypeDescriptor.Name}"; var helper = new DataTypeDescriptorFormsHelper(dataTypeDescriptor, bindingPrefix); var generatedTypesHelper = new GeneratedTypesHelper(dataTypeDescriptor); helper.AddReadOnlyFields(generatedTypesHelper.NotEditableDataFieldDescriptorNames); helper.FieldGroupLabel = StringResourceSystemFacade.ParseString(pageMetaDataDefinition.Label); return(helper); }
internal static string GetEmptyClassTypeFullName(DataTypeDescriptor dataTypeDescriptor) { return(NamespaceName + "." + CreateClassName(dataTypeDescriptor.GetFullInterfaceName())); }
private static bool IsObsoleteField(DataTypeDescriptor dataTypeDescriptor, string fieldName) { return(dataTypeDescriptor.SuperInterfaces.Any(type => type == typeof(ILocalizedControlled)) && fieldName == "CultureName"); }
internal static void AddAssemblyReferences(CodeGenerationBuilder codeGenerationBuilder, DataTypeDescriptor dataTypeDescriptor) { Type interfaceType = DataTypeTypesManager.GetDataType(dataTypeDescriptor); if (interfaceType == null) { return; } codeGenerationBuilder.AddReference(typeof(EmptyDataClassBase).Assembly); codeGenerationBuilder.AddReference(typeof(EditorBrowsableAttribute).Assembly); codeGenerationBuilder.AddReference(interfaceType.Assembly); if (!string.IsNullOrEmpty(dataTypeDescriptor.BuildNewHandlerTypeName)) { Type buildeNewHandlerType = TypeManager.GetType(dataTypeDescriptor.BuildNewHandlerTypeName); codeGenerationBuilder.AddReference(buildeNewHandlerType.Assembly); } }
public TypeKeyInstallationData(DataTypeDescriptor typeDescriptor) { _isLocalized = typeDescriptor.SuperInterfaces.Contains(typeof(ILocalizedControlled)); _isPublishable = typeDescriptor.SuperInterfaces.Contains(typeof(IPublishControlled)); _typeName = typeDescriptor.Name; }
internal static string MakeDataProviderHelperClassName(DataTypeDescriptor dataTypeDescriptor) { return(string.Format("{0}DataProviderHelper", dataTypeDescriptor.GetFullInterfaceName().Replace('.', '_').Replace('+', '_'))); }
/// <summary> /// Returns null if no alternate form exists. /// </summary> /// <exclude /> public static string GetAlternateFormMarkup(DataTypeDescriptor dataTypeDescriptor) { var file = GetAlternateFormMarkupFile(dataTypeDescriptor.Namespace, dataTypeDescriptor.Name); return file != null ? file.ReadAllText() : null; }
internal static InterfaceConfigurationElement RefreshLocalizationInfo(string providerName, DataTypeDescriptor dataTypeDescriptor) { var changeDescriptor = new DataTypeChangeDescriptor(dataTypeDescriptor, dataTypeDescriptor); return(Change(providerName, changeDescriptor, true)); }
public DataWrapperClassGenerator(string wrapperClassName, DataTypeDescriptor dataTypeDescriptor) { _wrapperClassName = wrapperClassName; _dataTypeDescriptor = dataTypeDescriptor; }
/// <summary> /// Gets the runtime empty data type for the given data type descriptor. /// </summary> /// <param name="dataTypeDescriptor"></param> /// <returns></returns> public static Type GetDataTypeEmptyClass(DataTypeDescriptor dataTypeDescriptor) { return(EmptyDataClassTypeManager.GetEmptyDataClassType(dataTypeDescriptor, false)); }
//private static WidgetFunctionProvider GetWidgetFunctionMarkup(Type propertyType) //{ // if (propertyType == typeof(string)) // { // return StandardWidgetFunctions.TextBoxWidget; // } // if (propertyType == typeof(Guid)) // { // return StandardWidgetFunctions.GuidTextBoxWidget; // } // if (propertyType == typeof(int)) // { // return StandardWidgetFunctions.IntegerTextBoxWidget; // } // if (propertyType == typeof(DateTime)) // { // return StandardWidgetFunctions.DateTimeSelectorWidget; // } // if (propertyType == typeof(decimal)) // { // return StandardWidgetFunctions.DecimalTextBoxWidget; // } // return null; //} private static void CheckSortOrder(DataTypeDescriptor typeDescriptor) { if (typeDescriptor.StoreSortOrderFieldNames.Count == 0) return; if (typeDescriptor.StoreSortOrderFieldNames.Count != typeDescriptor.Fields.Count) { throw new InvalidOperationException("The store sort order attribute should list all the fields of the interface"); } }
private static void AddInterfaceAttributes(CodeTypeDeclaration codeTypeDeclaration, DataTypeDescriptor dataTypeDescriptor) { codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(AutoUpdatebleAttribute).FullName, new CodeAttributeArgument[] { } )); codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(DataScopeAttribute).FullName, new [] { new CodeAttributeArgument( new CodePrimitiveExpression(DataScopeIdentifier.GetDefault().Name)) } )); codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(RelevantToUserTypeAttribute).FullName, new [] { new CodeAttributeArgument( new CodePrimitiveExpression(UserType.Developer.ToString())) } )); codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(CodeGeneratedAttribute).FullName, new CodeAttributeArgument[] { } )); codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(DataAncestorProviderAttribute).FullName, new [] { new CodeAttributeArgument( new CodeTypeOfExpression(typeof(NoAncestorDataAncestorProvider)) ) } )); codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(ImmutableTypeIdAttribute).FullName, new [] { new CodeAttributeArgument(new CodePrimitiveExpression(dataTypeDescriptor.DataTypeId.ToString())) } )); var xhtmlEmbedableEnumRef = new CodeFieldReferenceExpression( new CodeTypeReferenceExpression( typeof(XhtmlRenderingType) ), XhtmlRenderingType.Embedable.ToString()); codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(KeyTemplatedXhtmlRendererAttribute).FullName, new [] { new CodeAttributeArgument(xhtmlEmbedableEnumRef), new CodeAttributeArgument(new CodePrimitiveExpression("<span>{label}</span>")) } )); foreach (string keyFieldName in dataTypeDescriptor.KeyPropertyNames) { bool isDefinedOnSuperInterface = dataTypeDescriptor.SuperInterfaces.Any(f => f.GetProperty(keyFieldName) != null); if (!isDefinedOnSuperInterface) { codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(KeyPropertyNameAttribute).FullName, new [] { new CodeAttributeArgument(new CodePrimitiveExpression(keyFieldName)) } )); } } if (dataTypeDescriptor.StoreSortOrderFieldNames.Count > 0) { codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(StoreSortOrderAttribute).FullName, dataTypeDescriptor.StoreSortOrderFieldNames.Select(name => new CodeAttributeArgument(new CodePrimitiveExpression(name))).ToArray() )); } if (!string.IsNullOrEmpty(dataTypeDescriptor.Title)) { codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(TitleAttribute).FullName, new CodeAttributeArgument( new CodePrimitiveExpression(dataTypeDescriptor.Title) ) )); } if (!string.IsNullOrEmpty(dataTypeDescriptor.LabelFieldName)) { codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(LabelPropertyNameAttribute).FullName, new CodeAttributeArgument( new CodePrimitiveExpression(dataTypeDescriptor.LabelFieldName) ) )); } if (!string.IsNullOrEmpty(dataTypeDescriptor.InternalUrlPrefix)) { codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(InternalUrlAttribute).FullName, new CodeAttributeArgument( new CodePrimitiveExpression(dataTypeDescriptor.InternalUrlPrefix) ) )); } foreach (DataTypeAssociationDescriptor dataTypeAssociationDescriptor in dataTypeDescriptor.DataAssociations) { codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(DataAssociationAttribute).FullName, new [] { new CodeAttributeArgument(new CodeTypeOfExpression(dataTypeAssociationDescriptor.AssociatedInterfaceType)), new CodeAttributeArgument(new CodePrimitiveExpression(dataTypeAssociationDescriptor.ForeignKeyPropertyName)), new CodeAttributeArgument(new CodeFieldReferenceExpression(new CodeTypeReferenceExpression(typeof(DataAssociationType)), dataTypeAssociationDescriptor.AssociationType.ToString())) } )); } if (dataTypeDescriptor.SuperInterfaces.Contains(typeof(IPageMetaData)) == false) { if (dataTypeDescriptor.SuperInterfaces.Contains(typeof(IPublishControlled))) { codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(PublishProcessControllerTypeAttribute).FullName, new[] { new CodeAttributeArgument(new CodeTypeOfExpression(typeof(GenericPublishProcessController))) } )); } } if (dataTypeDescriptor.Cachable) { // [CachingAttribute(CachingType.Full)] codeTypeDeclaration.CustomAttributes.Add( new CodeAttributeDeclaration( typeof(CachingAttribute).FullName, new CodeAttributeArgument[] { new CodeAttributeArgument( new CodeFieldReferenceExpression( new CodeTypeReferenceExpression(typeof(CachingType)), "Full" ) ) } )); } }