/// <summary> /// Creates an instance of <see cref="EntityKeyProperty"/>. /// </summary> /// <param name="genParams">Parameters for the generation of DTOs.</param> public EntityKeyProperty(XElement entityNode, XElement propertyRefNode, IEnumerable <XElement> propertyNodeElements, GenerateDTOsParams genParams) { // Get the Entity name string entityName = entityNode.Attribute(EdmxNodeAttributes.EntityType_Name).Value; // Set the DTO name this.DTOName = Utils.ConstructDTOName(entityName, genParams); // Set the Property name string propertyNameDesired = propertyRefNode.Attribute(EdmxNodeAttributes.PropertyRef_Name).Value; this.Name = PropertyHelper.GetPropertyName(propertyNameDesired, entityName); // Find the Property node XElement propertyNode = propertyNodeElements.FirstOrDefault(p => p.Attribute(EdmxNodeAttributes.Property_Name).Value == propertyNameDesired); // Check Property node exists if (propertyNode == null) { throw new ApplicationException(string.Format(Resources.Error_PropertyKeyMissing, entityName, propertyNameDesired)); } this.Type = PropertyHelper.GetTypeFromEDMXProperty(propertyNode, entityName); }
/// <summary> /// Gets the Entity Navigations from the provided EDMX Document. /// </summary> /// <param name="genParams">Parameters for the generation of DTOs.</param> /// <returns></returns> private static List <EntityNavigation> GetEntitiesNavigations(GenerateDTOsParams genParams) { LogManager.LogMethodStart(); // Get Entity Associations List <EntityAssociation> entitiesAssociations = DTOGenerator.GetEntitiesAssociations(genParams); // Get Entity Key Properties List <EntityKeyProperty> entitiesKeys = DTOGenerator.GetEntitiesKeyProperties(genParams); // Get Entities NavigationProperty Nodes IEnumerable <XElement> navigationNodeElements = genParams.EDMXDocument.DescendantsCSDL(EdmxNodes.NavigationProperty); var result = new List <EntityNavigation>(); foreach (XElement navigationNode in navigationNodeElements) { result.Add(new EntityNavigation(navigationNode, entitiesAssociations, entitiesKeys, genParams)); } LogManager.LogMethodEnd(); return(result); }
/// <summary> /// Creates an instance of <see cref="DTOEntity"/>. /// </summary> /// <param name="typeNode">Type node.</param> /// <param name="genParams">Parameters for the generation of DTOs.</param> /// <param name="navigations">Entity navigations available.</param> public DTOEntity(XElement typeNode, GenerateDTOsParams genParams, List <EntityNavigation> navigations) : base(typeNode, genParams) { // Define Class Base Type (if exists) string entityBaseType = EdmxHelper.GetEntityBaseType(typeNode); if (string.IsNullOrWhiteSpace(entityBaseType) == false) { // Check if base type is going to be generated if (genParams.TypesToGenerateFilter.Contains(entityBaseType) == true) { this.NameBaseDTO = Utils.ConstructDTOName(entityBaseType, genParams); } } #region Set IsAbstract if (typeNode.Attribute(EdmxNodeAttributes.EntityType_Abstract) != null) { string abstractValue = typeNode.Attribute(EdmxNodeAttributes.EntityType_Abstract).Value.ToLower(); this.IsAbstract = (abstractValue == Resources.XmlBoolTrue); } #endregion Set IsAbstract #region Set Navigation Properties if (navigations != null) { IEnumerable <EntityNavigation> myNavigations = navigations.Where(a => a.DTOName == this.NameDTO); foreach (EntityNavigation entityNav in myNavigations) { foreach (EntityNavigationProperty navProperty in entityNav.NavigationProperties) { // Add property only if target type is going to be generated if (genParams.TypesToGenerateFilter.Contains(navProperty.EntityTargetName) == true) { if (genParams.AssociationType == AssociationType.KeyProperty && this.Properties.Exists(p => p.PropertyName == navProperty.Name)) { VisualStudioHelper.AddToErrorList(TaskErrorCategory.Warning, string.Format(Resources.Warning_PropertyNameConflict, this.Name, navProperty.Name, navProperty.EntityTargetName), genParams.TargetProject, null, null, null); } else { this.Properties.Add(new DTOClassProperty( entityNav.NavigationPropertyNameEDMX, navProperty, genParams.DTOsServiceReady)); } } } } } #endregion Set Association Properties }
/// <summary> /// Gets the Entity Keys of the provided EDMX Document. /// </summary> /// <param name="genParams">Parameters for the generation of DTOs.</param> /// <returns></returns> private static List <EntityKeyProperty> GetEntitiesKeyProperties(GenerateDTOsParams genParams) { LogManager.LogMethodStart(); IEnumerable <XElement> entityNodeElements = genParams.EDMXDocument.DescendantsCSDL(EdmxNodes.EntityType); var result = new List <EntityKeyProperty>(); foreach (XElement entityNode in entityNodeElements) { result.AddRange(DTOGenerator.GetEntityKeys(entityNode, entityNode, entityNodeElements, genParams)); } LogManager.LogMethodEnd(); return(result); }
/// <summary> /// Constructs a dto name using the entity name and configuration received. /// </summary> /// <param name="entityName">Entity name.</param> /// <param name="genParams">Parameters for the generation of DTOs.</param> /// <returns></returns> public static string ConstructDTOName(string entityName, GenerateDTOsParams genParams) { if (string.IsNullOrWhiteSpace(entityName) == true) { return(null); } string dtoName = entityName; if (genParams.ClassIdentifierUse == ClassIdentifierUse.Prefix) { dtoName = (genParams.ClassIdentifierWord + dtoName); } else if (genParams.ClassIdentifierUse == ClassIdentifierUse.Suffix) { dtoName = (dtoName + genParams.ClassIdentifierWord); } return(dtoName); }
/// <summary> /// Gets the Associations of the provided EDMX Document. /// </summary> /// <param name="genParams">Parameters for the generation of DTOs.</param> /// <returns></returns> private static List <EntityAssociation> GetEntitiesAssociations(GenerateDTOsParams genParams) { LogManager.LogMethodStart(); IEnumerable <XElement> associationNodeElements = EdmxHelper.GetAssociationNodes(genParams.EDMXDocument); var result = new List <EntityAssociation>(); foreach (XElement associationNodeElement in associationNodeElements) { result.Add(new EntityAssociation(associationNodeElement, EntityAssociationEnd.First, genParams)); result.Add(new EntityAssociation(associationNodeElement, EntityAssociationEnd.Second, genParams)); } LogManager.LogMethodEnd(); return(result); }
/// <summary> /// Gets the enum types available. /// </summary> /// <param name="parameters">Parameters for the generation of DTOs.</param> /// <returns></returns> private static List <EnumType> GetEnumTypes(GenerateDTOsParams parameters) { var enums = new List <EnumType>(); foreach (XElement xEnum in EdmxHelper.GetEnumTypeNodes(parameters.EDMXDocument)) { var enumType = new EnumType(); enumType.Name = xEnum.Attribute(EdmxNodeAttributes.EntityType_Name).Value; XAttribute attrExternalType = xEnum.Attribute(EdmxNodeAttributes.EnumType_ExternalTypeName); if (attrExternalType != null) { enumType.ExternalTypeName = attrExternalType.Value; VisualStudioHelper.AddToErrorList(TaskErrorCategory.Warning, string.Format(Resources.Warning_ManuallyAddReferenceForEnum, enumType.ExternalTypeName), parameters.TargetProject, null, null, null); } enums.Add(enumType); } return(enums); }
/// <summary> /// Creates an instance of <see cref="EntityAssociation"/>. /// </summary> /// <param name="genParams">Parameters for the generation of DTOs.</param> public EntityAssociation(XElement associationNode, EntityAssociationEnd entityAssociationEndDesired, GenerateDTOsParams genParams) { // Set Association Name this.AssociationName = associationNode.Attribute(EdmxNodeAttributes.Association_Name).Value; // Get End nodes XElement[] endNodes = associationNode.DescendantsCSDL(EdmxNodes.End).ToArray(); // Get the position of the desired End node int endPosition = (entityAssociationEndDesired == EntityAssociationEnd.First ? 0 : 1); // Set DTO Name this.EntityName = endNodes[endPosition].Attribute(EdmxNodeAttributes.End_Type).Value; string[] entityNameSplitted = this.EntityName.Split(new string[] { Resources.Dot }, StringSplitOptions.RemoveEmptyEntries); this.EntityName = entityNameSplitted[(entityNameSplitted.Length - 1)]; this.DTOName = Utils.ConstructDTOName(this.EntityName, genParams); // Set End Role Name this.EndRoleName = endNodes[endPosition].Attribute(EdmxNodeAttributes.End_Role).Value; // Set Multiplicity this.EndMultiplicity = EntityAssociationHelper.GetMultiplicity(endNodes[endPosition]); }
/// <summary> /// Gets the Keys of an Entity. /// </summary> /// <param name="entityNodeKeysOwner">EntityType node to get the keys from.</param> /// <param name="entityNodeToSetKeys">EntityType node to set the keys.</param> /// <param name="entityNodeElements">EntityType nodes.</param> /// <param name="genParams">Parameters for the generation of DTOs.</param> /// <returns></returns> private static List <EntityKeyProperty> GetEntityKeys(XElement entityNodeKeysOwner, XElement entityNodeToSetKeys, IEnumerable <XElement> entityNodeElements, GenerateDTOsParams genParams) { LogManager.LogMethodStart(); var result = new List <EntityKeyProperty>(); IEnumerable <XElement> propertyRefNodeElements = entityNodeKeysOwner.DescendantsCSDL(EdmxNodes.PropertyRef); IEnumerable <XElement> propertyNodeElements = entityNodeKeysOwner.DescendantsCSDL(EdmxNodes.Property); foreach (var propertyRefNode in propertyRefNodeElements) { result.Add(new EntityKeyProperty(entityNodeToSetKeys, propertyRefNode, propertyNodeElements, genParams)); } // Does this Entity have a Base Type ? string entityBaseType = EdmxHelper.GetEntityBaseType(entityNodeKeysOwner); if (entityBaseType != null) { // Find the Base Type node XElement entityBaseTypeNode = entityNodeElements.FirstOrDefault( e => e.Attribute(EdmxNodeAttributes.EntityType_Name).Value == entityBaseType); if (entityBaseTypeNode == null) { throw new ApplicationException(string.Format(Resources.Error_BaseTypeNotFound, entityNodeKeysOwner.Attribute(EdmxNodeAttributes.EntityType_Name).Value, entityBaseType)); } // Add the Entity Base Type keys to the resulting keys result.AddRange(DTOGenerator.GetEntityKeys(entityBaseTypeNode, entityNodeToSetKeys, entityNodeElements, genParams)); } LogManager.LogMethodEnd(); return(result); }
/// <summary> /// Generates the DTOs of the EDMX Document provided using the parameters received. /// </summary> /// <param name="parameters">Parameters for the generation of DTOs.</param> /// <param name="worker">BackgroundWorker reference.</param> public static List <DTOEntity> GenerateDTOs(GenerateDTOsParams parameters, BackgroundWorker worker) { LogManager.LogMethodStart(); if (parameters.DTOsServiceReady) { VisualStudioHelper.AddReferenceToProject(parameters.TargetProject, Resources.AssemblySystemRuntimeSerialization, Resources.AssemblySystemRuntimeSerialization); } if (GeneratorManager.CheckCancellationPending()) { return(null); } EditPoint objEditPoint; // EditPoint to reuse CodeParameter objCodeParameter; // CodeParameter to reuse CodeNamespace objNamespace = null; // Namespace item to add Classes ProjectItem sourceFileItem = null; // Source File Item to save int dtosGenerated = 0; List <EnumType> enums = DTOGenerator.GetEnumTypes(parameters); PropertyHelper.SetEnumTypes(enums); List <DTOEntity> entitiesDTOs = DTOGenerator.GetEntityDTOs(parameters); if (GeneratorManager.CheckCancellationPending()) { return(null); } worker.ReportProgress(0, new GeneratorOnProgressEventArgs(0, string.Format(Resources.Text_DTOsGenerated, dtosGenerated, entitiesDTOs.Count))); TemplateClass.CreateFile(); // Imports to add to the Source File var importList = new List <SourceCodeImport>(); // EnumTypes defined in the EDMX ? if (enums.Exists(e => e.IsExternal == false)) { importList.Add(new SourceCodeImport(parameters.EntitiesNamespace)); VisualStudioHelper.AddReferenceToProject(parameters.TargetProject, parameters.EDMXProject); } // Include imports of external enums. foreach (string externalEnumNamespace in enums.Where(e => e.IsExternal).Select(e => e.Namespace).Distinct()) { importList.Add(new SourceCodeImport(externalEnumNamespace)); } // Generate Source File if type is One Source File if (parameters.SourceFileGenerationType == SourceFileGenerationType.OneSourceFile) { sourceFileItem = null; // Generate Source and Get the Namespace item objNamespace = VisualStudioHelper.GenerateSourceAndGetNamespace( parameters.TargetProject, parameters.TargetProjectFolder, parameters.SourceFileName, parameters.SourceFileHeaderComment, parameters.SourceNamespace, parameters.DTOsServiceReady, out sourceFileItem); // Add Imports to Source File VisualStudioHelper.AddImportsToSourceCode(ref sourceFileItem, importList); } // Check Cancellation Pending if (GeneratorManager.CheckCancellationPending()) { return(null); } // Loop through Entities DTOs foreach (DTOEntity entityDTO in entitiesDTOs) { // Generate Source File if type is Source File per Class if (parameters.SourceFileGenerationType == SourceFileGenerationType.SourceFilePerClass) { sourceFileItem = null; // Generate Source and Get the Namespace item objNamespace = VisualStudioHelper.GenerateSourceAndGetNamespace( parameters.TargetProject, parameters.TargetProjectFolder, entityDTO.NameDTO, parameters.SourceFileHeaderComment, parameters.SourceNamespace, parameters.DTOsServiceReady, out sourceFileItem); // Add Imports to Source File VisualStudioHelper.AddImportsToSourceCode(ref sourceFileItem, importList); } // Add Class CodeClass objCodeClass = objNamespace.AddClassWithPartialSupport(entityDTO.NameDTO, entityDTO.NameBaseDTO, entityDTO.DTOClassAccess, entityDTO.DTOClassKind); // Set IsAbstract objCodeClass.IsAbstract = entityDTO.IsAbstract; // Set Class Attributes foreach (DTOAttribute classAttr in entityDTO.Attributes) { objCodeClass.AddAttribute(classAttr.Name, classAttr.Parameters, AppConstants.PLACE_AT_THE_END); } // Set Class Properties foreach (DTOClassProperty entityProperty in entityDTO.Properties) { // Add Property CodeProperty objCodeProperty = objCodeClass.AddProperty(entityProperty.PropertyName, entityProperty.PropertyName, entityProperty.PropertyType, AppConstants.PLACE_AT_THE_END, entityProperty.PropertyAccess, null); // Get end of accessors auto-generated code objEditPoint = objCodeProperty.Setter.EndPoint.CreateEditPoint(); objEditPoint.LineDown(); objEditPoint.EndOfLine(); var getSetEndPoint = objEditPoint.CreateEditPoint(); // Move to the start of accessors auto-generated code objEditPoint = objCodeProperty.Getter.StartPoint.CreateEditPoint(); objEditPoint.LineUp(); objEditPoint.LineUp(); objEditPoint.EndOfLine(); // Replace accessors auto-generated code with a more cleaner one objEditPoint.ReplaceText(getSetEndPoint, Resources.CSharpCodeGetSetWithBrackets, Convert.ToInt32(vsEPReplaceTextOptions.vsEPReplaceTextAutoformat)); // Set Property Attributes foreach (DTOAttribute propAttr in entityProperty.PropertyAttributes) { objCodeProperty.AddAttribute(propAttr.Name, propAttr.Parameters, AppConstants.PLACE_AT_THE_END); } objEditPoint = objCodeProperty.StartPoint.CreateEditPoint(); objEditPoint.SmartFormat(objEditPoint); } if (parameters.GenerateDTOConstructors) { // Add empty Constructor CodeFunction emptyConstructor = objCodeClass.AddFunction(objCodeClass.Name, vsCMFunction.vsCMFunctionConstructor, null, AppConstants.PLACE_AT_THE_END, vsCMAccess.vsCMAccessPublic, null); // Does this DTO have a Base Class ? if (entityDTO.BaseDTO != null) { // Add call to empty Base Constructor objEditPoint = emptyConstructor.StartPoint.CreateEditPoint(); objEditPoint.EndOfLine(); objEditPoint.Insert(Resources.Space + Resources.CSharpCodeBaseConstructor); } // Does this DTO have properties ? if (entityDTO.Properties.Count > 0) { // Add Constructor with all properties as parameters CodeFunction constructorWithParams = objCodeClass.AddFunction(objCodeClass.Name, vsCMFunction.vsCMFunctionConstructor, null, AppConstants.PLACE_AT_THE_END, vsCMAccess.vsCMAccessPublic, null); foreach (DTOClassProperty entityProperty in entityDTO.Properties) { // Add Constructor parameter objCodeParameter = constructorWithParams.AddParameter( Utils.SetFirstLetterLowercase(entityProperty.PropertyName), entityProperty.PropertyType, AppConstants.PLACE_AT_THE_END); // Add assignment objEditPoint = constructorWithParams.EndPoint.CreateEditPoint(); objEditPoint.LineUp(); objEditPoint.EndOfLine(); objEditPoint.Insert(Environment.NewLine + AppConstants.TAB + AppConstants.TAB + AppConstants.TAB); objEditPoint.Insert(string.Format(Resources.CSharpCodeAssignmentThis, entityProperty.PropertyName, objCodeParameter.Name)); } // Does this DTO have a Base Class ? if (entityDTO.BaseDTO != null) { // Get the Base Class properties (includes the properties of the base recursively) List <DTOClassProperty> baseProperties = DTOGenerator.GetPropertiesForConstructor(entityDTO.BaseDTO); // Base Constructor parameters var sbBaseParameters = new StringBuilder(); foreach (DTOClassProperty entityProperty in baseProperties) { // Add Constructor parameter objCodeParameter = constructorWithParams.AddParameter( Utils.SetFirstLetterLowercase(entityProperty.PropertyName), entityProperty.PropertyType, AppConstants.PLACE_AT_THE_END); // Add parameter separation if other parameters exists if (sbBaseParameters.Length > 0) { sbBaseParameters.Append(Resources.CommaSpace); } // Add to Base Constructor parameters sbBaseParameters.Append(objCodeParameter.Name); } // Add call to Base Constructor with parameters objEditPoint = constructorWithParams.StartPoint.CreateEditPoint(); objEditPoint.EndOfLine(); objEditPoint.Insert( Environment.NewLine + AppConstants.TAB + AppConstants.TAB + AppConstants.TAB); objEditPoint.Insert( string.Format(Resources.CSharpCodeBaseConstructorWithParams, sbBaseParameters.ToString())); } // END if DTO has a Base Class } // END if DTO has properties } // END if Generate DTO Constructor methods // Save changes to Source File Item sourceFileItem.Save(); // Count DTO generated dtosGenerated++; // Report Progress int progress = ((dtosGenerated * 100) / entitiesDTOs.Count); if (progress < 100) { worker.ReportProgress(progress, new GeneratorOnProgressEventArgs(progress, string.Format(Resources.Text_DTOsGenerated, dtosGenerated, entitiesDTOs.Count))); } // Check Cancellation Pending if (GeneratorManager.CheckCancellationPending()) { return(null); } } // END Loop through Entities DTOs // Save Target Project parameters.TargetProject.Save(); // Delete Template Class File TemplateClass.Delete(); // Report Progress worker.ReportProgress(100, new GeneratorOnProgressEventArgs(100, string.Format(Resources.Text_DTOsGenerated, dtosGenerated, entitiesDTOs.Count))); LogManager.LogMethodEnd(); // Return the DTOs generated return(entitiesDTOs); }
/// <summary> /// Gets the objects that represents the DTOs that needs to be generated from the received EDMX Document. /// </summary> /// <param name="parameters">Parameters for the generation of DTOs.</param> /// <returns></returns> private static List <DTOEntity> GetEntityDTOs(GenerateDTOsParams parameters) { LogManager.LogMethodStart(); // Variables string typeName = null; bool generateType = false; var complexTypeDTOs = new List <DTOEntity>(); var entityTypeDTOs = new List <DTOEntity>(); // Get the DTOs for the ComplexType nodes foreach (XElement complexType in EdmxHelper.GetComplexTypeNodes(parameters.EDMXDocument)) { typeName = complexType.Attribute(EdmxNodeAttributes.EntityType_Name).Value; generateType = parameters.TypesToGenerateFilter.Contains(typeName); if (generateType == true) { List <EntityNavigation> entityNavigations = null; complexTypeDTOs.Add(new DTOEntity(complexType, parameters, entityNavigations)); } } // Set the Complex Types available PropertyHelper.SetComplexTypes(complexTypeDTOs); // Get Navigation Properties List <EntityNavigation> entitiesNavigations = DTOGenerator.GetEntitiesNavigations(parameters); // Get the DTOs for the EntityType nodes foreach (XElement entityTypeNode in EdmxHelper.GetEntityTypeNodes(parameters.EDMXDocument)) { typeName = entityTypeNode.Attribute(EdmxNodeAttributes.EntityType_Name).Value; generateType = parameters.TypesToGenerateFilter.Contains(typeName); if (generateType == true) { entityTypeDTOs.Add(new DTOEntity(entityTypeNode, parameters, entitiesNavigations)); } } foreach (DTOEntity dto in entityTypeDTOs) { // Set Know Types of DTO dto.SetKnownTypes(entityTypeDTOs, parameters.DTOsServiceReady); // Set DTOs childs of DTO dto.SetChilds(entityTypeDTOs); // Set reference to DTO Base Class dto.SetDTOBase(entityTypeDTOs); // Set Navigation Target DTO references foreach (DTOClassProperty dtoProperty in dto.Properties.Where(p => p.IsNavigation == true)) { DTOEntity dtoTarget = entityTypeDTOs.FirstOrDefault(e => e.NameDTO == dtoProperty.NavigatesToDTOName); if (dtoTarget != null) { dtoProperty.SetNavigatesToDTOReference(dtoTarget); } } } // Get the final result var result = new List <DTOEntity>(); result.AddRange(complexTypeDTOs); result.AddRange(entityTypeDTOs); LogManager.LogMethodEnd(); return(result); }
/// <summary> /// Gets target name of <see cref="GenerateDTOsParams"/>. /// </summary> /// <param name="dtosParams">DTO parameters from where to obtain the target name.</param> /// <returns></returns> private static string GetTargetName(GenerateDTOsParams dtosParams) { return(ConfigurationHelper.GetTargetName(dtosParams.TargetType, dtosParams.TargetProject, dtosParams.TargetProjectFolder)); }
/// <summary> /// Creates an instance of <see cref="EntityNavigation"/>. /// </summary> /// <param name="genParams">Parameters for the generation of DTOs.</param> public EntityNavigation(XElement navigationNode, List <EntityAssociation> entitiesAssociations, List <EntityKeyProperty> entitiesKeys, GenerateDTOsParams genParams) { // Set DTO Name string entityName = navigationNode.Parent.Attribute(EdmxNodeAttributes.EntityType_Name).Value; this.DTOName = Utils.ConstructDTOName(entityName, genParams); // Get the To Role End name string toRole = navigationNode.Attribute(EdmxNodeAttributes.NavigationProperty_ToRole).Value; // Get the Association Name string associationName = EdmxHelper.GetNavigationAssociationName(navigationNode); this.NavigationProperties = new List <EntityNavigationProperty>(); // Find the Association EntityAssociation association = ( from a in entitiesAssociations where (a.AssociationName == associationName) && (a.EndRoleName == toRole) select a ).FirstOrDefault(); // Find the DTO associated keys IEnumerable <EntityKeyProperty> dtoToKeys = entitiesKeys.Where(k => k.DTOName == association.DTOName); // Get the base Property Name this.NavigationPropertyNameEDMX = navigationNode.Attribute(EdmxNodeAttributes.NavigationProperty_Name).Value; string propertyName = PropertyHelper.GetPropertyName(this.NavigationPropertyNameEDMX, entityName); // Set association type desired, can change if requirements are not met AssociationType associationTypeDesired = genParams.AssociationType; if (association.EndMultiplicity == EntityAssociationMultiplicity.Many) { if ((associationTypeDesired != AssociationType.ClassType) && (dtoToKeys.Count() != 1)) { // TODO: ffernandez, indicate Project-ProjectItem-Line-Column VisualStudioHelper.AddToErrorList(TaskErrorCategory.Warning, string.Format(Resources.Warning_CannotCreateNavPropManyKeyProp, this.DTOName, association.DTOName), null, null, null, null); associationTypeDesired = AssociationType.ClassType; } bool isList = true; if (associationTypeDesired == AssociationType.ClassType) { // List<T> Type string type = string.Format(Resources.CSharpTypeListT, association.DTOName); this.NavigationProperties.Add(new EntityNavigationProperty(type, propertyName, isList, association.DTOName, association.EntityName, association.DTOName)); } else { // AssociationTypeEnum.KeyProperty EntityKeyProperty dtoToKey = dtoToKeys.First(); // List<T> Type string type = string.Format(Resources.CSharpTypeListT, dtoToKey.Type); propertyName += (Resources.NameSeparator + dtoToKey.Name); this.NavigationProperties.Add(new EntityNavigationProperty(type, propertyName, isList, dtoToKey.Type, association.EntityName, association.DTOName)); } } else { // EntityAssociationMultiplicityEnum.One // EntityAssociationMultiplicityEnum.ZeroOrOne bool isList = false; string listOf = null; if (associationTypeDesired == AssociationType.ClassType) { this.NavigationProperties.Add(new EntityNavigationProperty(association.DTOName, propertyName, isList, listOf, association.EntityName, association.DTOName)); } else { // AssociationTypeEnum.KeyProperty foreach (EntityKeyProperty dtoToKey in dtoToKeys) { string propName = (propertyName + Resources.NameSeparator + dtoToKey.Name); this.NavigationProperties.Add(new EntityNavigationProperty(dtoToKey.Type, propName, isList, listOf, association.EntityName, association.DTOName)); } } } }
/// <summary> /// Creates an instance of <see cref="DTOComplex"/>. /// </summary> /// <param name="typeNode">Type node.</param> /// <param name="genParams">Parameters for the generation of DTOs.</param> public DTOComplex(XElement typeNode, GenerateDTOsParams genParams) : base(typeNode, genParams) { }
public DTOClass(XElement typeNode, GenerateDTOsParams genParams) { // Set source type name this.Name = typeNode.Attribute(EdmxNodeAttributes.EntityType_Name).Value; // Set DTO name this.NameDTO = Utils.ConstructDTOName(this.Name, genParams); #region Set Class Attributes this.Attributes = new List <DTOAttribute>(); if (genParams.DTOsServiceReady) { const string parameters = null; this.Attributes.Add(new DTOAttribute(Resources.AttributeDataContract, parameters)); } #endregion Set Class Attributes // Set Assembler (it does not have one by default) this.Assembler = null; // Set Class Access this.DTOClassAccess = vsCMAccess.vsCMAccessPublic; // Set the Class Kind to partial so the final user can extend it this.DTOClassKind = vsCMClassKind.vsCMClassKindPartialClass; #region Set Properties this.Properties = new List <DTOClassProperty>(); // Get Key Node XElement keyNode = typeNode.DescendantsCSDL(EdmxNodes.Key).FirstOrDefault(); // Get source keys var sourceKeys = new List <string>(); if (keyNode != null) { sourceKeys = keyNode.DescendantsCSDL(EdmxNodes.PropertyRef) .Select(n => n.Attribute(EdmxNodeAttributes.PropertyRef_Name).Value).ToList(); } // Get Property nodes IEnumerable <XElement> entityPropertiesNodes = typeNode.DescendantsCSDL(EdmxNodes.Property); // Variables string edmxTypeValue; string[] edmxTypeValueSplitted; string edmxTypeName; bool addProperty; bool isEnum; foreach (XElement propertyNode in entityPropertiesNodes) { addProperty = true; isEnum = false; // Get the Type value edmxTypeValue = propertyNode.Attribute(EdmxNodeAttributes.Property_Type).Value; // Split typeValue to check if it is a Complex Type edmxTypeValueSplitted = edmxTypeValue.Split(new string[] { Resources.Dot }, StringSplitOptions.RemoveEmptyEntries); // Get EDMX type name (split to ensure that if it is from the same model we only get the name) edmxTypeName = edmxTypeValueSplitted[(edmxTypeValueSplitted.Length - 1)]; // Check if property type is complex or entity type if (genParams.AllComplexTypesNames.Contains(edmxTypeName) == true || genParams.AllEntityTypesNames.Contains(edmxTypeName) == true) { // Check if the type is going to be generated addProperty = genParams.TypesToGenerateFilter.Contains(edmxTypeName); } else if (genParams.AllEnumTypesNames.Contains(edmxTypeName) == true) { isEnum = true; } if (addProperty == true) { // Check if it is a complex type property bool isComplex = (genParams.AllComplexTypesNames.Contains(edmxTypeName) == true); this.Properties.Add(new DTOClassProperty(propertyNode, sourceKeys, this.Name, genParams.DTOsServiceReady, isComplex, isEnum)); } } #endregion Set Properties }