public GeneratorManagerParams(GenerateDTOsParams dtosParams, GenerateAssemblersParams assemblersParams, bool generateAssemblers) { this.DTOsParams = dtosParams; this.AssemblersParams = assemblersParams; this.GenerateAssemblers = generateAssemblers; }
/// <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); }
public GeneratorManagerParams(GenerateDTOsParams dtosParams, GenerateAssemblersParams assemblersParams, bool generateAssemblers) { this.DTOsParams = dtosParams; this.AssemblersParams = assemblersParams; this.GenerateAssemblers = generateAssemblers; }
/// <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> /// 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> /// 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> /// 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) { }
/// <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> /// 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 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> /// 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 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> /// 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> /// 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 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> /// Gets the parameters for GeneratorManager. /// </summary> /// <returns></returns> private GeneratorManagerParams GetGeneratorManagerParams() { #region Entity source dynamic entitySource = null; if (this.rbSourceEdmx.Checked == true) { // Get entity source as ProjectItem (it is an EDMX Document) entitySource = (this.lstEntitySources.SelectedItem as ProjectItem); } else { // Get entity source as Project entitySource = this.CurrentSourceProject; } #endregion Entity source #region General // Source File Header Comment string sourceFileHeaderComment = null; if (this.cbCustomHeaderComment.Checked) { sourceFileHeaderComment = this.txtCustomHeaderComment.Text; } #endregion General #region DTOs // Get the types to generate filter List<string> typesToGenerateFilter = this.GetTypesToGenerateFilter(onlyFilteredTypes: true); // Target Project targetProjectDTOs = null; ProjectItem targetProjectFolderDTOs = null; object nodeValueDTOs = (this.treeTargetDTOs.SelectedNode as TreeNodeExtended).Value; if (nodeValueDTOs is Project) { targetProjectDTOs = (nodeValueDTOs as Project); } else { targetProjectDTOs = (nodeValueDTOs as ProjectItem).ContainingProject; targetProjectFolderDTOs = (nodeValueDTOs as ProjectItem); } string sourceNamespaceDTOs = this.GetSourceFileNamespaceForDTOs(); string sourceFileNameDTOs = this.txtSourceFileNameDTOs.Text.Trim(); // Get source file generation type for DTOs SourceFileGenerationType sourceFileGenerationTypeDTOs = SourceFileGenerationType.SourceFilePerClass; if (this.rbOneSourceFileDTOs.Checked) { sourceFileGenerationTypeDTOs = SourceFileGenerationType.OneSourceFile; } AssociationType associationType = AssociationType.KeyProperty; if (this.rbAssociationConfigUseClassTypes.Checked) { associationType = AssociationType.ClassType; } // Set generate types flags bool generateAllTypes = (this.chbGenerateAllTypes.CheckState == CheckState.Checked); bool generateAllComplexTypes = (this.chbGenerateComplexTypes.CheckState == CheckState.Checked); bool generateAllEntityTypes = (this.chbGenerateEntityTypes.CheckState == CheckState.Checked); // Set Identifier ClassIdentifierUse dtosClassIdentifierUse = ClassIdentifierUse.None; string dtosClassIdentifierWord = string.Empty; if (this.rbDTOIdentifierPrefix.Checked == true) { dtosClassIdentifierUse = ClassIdentifierUse.Prefix; dtosClassIdentifierWord = this.txtDTOIdentifierWord.Text.Trim(); } else if (this.rbDTOIdentifierSuffix.Checked == true) { dtosClassIdentifierUse = ClassIdentifierUse.Suffix; dtosClassIdentifierWord = this.txtDTOIdentifierWord.Text.Trim(); } // Set DTOs parameters var dtosParams = new GenerateDTOsParams(targetProjectDTOs, targetProjectFolderDTOs, entitySource, typesToGenerateFilter, generateAllTypes, generateAllComplexTypes, generateAllEntityTypes, sourceFileHeaderComment, this.cbUseDefaultNamespaceDTOs.Checked, sourceNamespaceDTOs, this.cbServiceReadyDTOs.Checked, dtosClassIdentifierUse, dtosClassIdentifierWord, sourceFileGenerationTypeDTOs, sourceFileNameDTOs, associationType, this.cbGenerateDTOConstructors.Checked); #endregion DTOs #region Assemblers GenerateAssemblersParams assemblersParams = null; if (this.cbGenerateAssemblers.Checked) { // Target Project targetProjectAssemblers = null; ProjectItem targetProjectFolderAssemblers = null; object nodeValueAssemblers = (this.treeTargetAssemblers.SelectedNode as TreeNodeExtended).Value; if (nodeValueAssemblers is Project) { targetProjectAssemblers = (nodeValueAssemblers as Project); } else { targetProjectAssemblers = (nodeValueAssemblers as ProjectItem).ContainingProject; targetProjectFolderAssemblers = (nodeValueAssemblers as ProjectItem); } string sourceNamespaceAssemblers = this.GetSourceFileNamespaceForAssemblers(); string sourceFileNameAssemblers = this.txtSourceFileNameAssemblers.Text.Trim(); // Get the source file generation type for Assemblers SourceFileGenerationType sourceFileGenerationTypeAssemblers = SourceFileGenerationType.SourceFilePerClass; if (this.rbOneSourceFileAssemblers.Checked) { sourceFileGenerationTypeAssemblers = SourceFileGenerationType.OneSourceFile; } // Set Identifier ClassIdentifierUse assemblersClassIdentifierUse = ClassIdentifierUse.None; string assemblersClassIdentifierWord = string.Empty; if (this.rbAssemblerIdentifierPrefix.Checked == true) { assemblersClassIdentifierUse = ClassIdentifierUse.Prefix; assemblersClassIdentifierWord = this.txtAssemblerIdentifierWord.Text.Trim(); } else if (this.rbAssemblerIdentifierSuffix.Checked == true) { assemblersClassIdentifierUse = ClassIdentifierUse.Suffix; assemblersClassIdentifierWord = this.txtAssemblerIdentifierWord.Text.Trim(); } // Set Assemblers parameters assemblersParams = new GenerateAssemblersParams(targetProjectAssemblers, targetProjectFolderAssemblers, sourceFileHeaderComment, this.cbUseDefaultNamespaceAssemblers.Checked, sourceNamespaceAssemblers, assemblersClassIdentifierUse, assemblersClassIdentifierWord, sourceFileGenerationTypeAssemblers, sourceFileNameAssemblers, this.cbServiceReadyDTOs.Checked, sourceNamespaceDTOs, targetProjectDTOs, entitySource); } #endregion Assemblers // Return the result generator parameters return new GeneratorManagerParams(dtosParams, assemblersParams, this.cbGenerateAssemblers.Checked); }
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 }