/// <summary>
/// Exports the User Configuration to the specified file path.
/// </summary>
/// <param name="generatorParams">GeneratorManagerParams containing necessary information.</param>
/// <param name="filePath">File path to export.</param>
public static void Export(GeneratorManagerParams generatorParams, string filePath)
{
if (filePath.EndsWith(Resources.GenConfigFileExtension) == false)
{
filePath += Resources.GenConfigFileExtension;
}
var exportDoc = new XDocument();
exportDoc.Add(
new XElement(ConfigNodes.Root,
new XElement(ConfigNodes.GenerateAssemblers, generatorParams.GenerateAssemblers),
new XElement(ConfigNodes.DTOsConfig,
new XElement(ConfigNodes.Target,
new XAttribute(ConfigNodes.TargetAttrProject, generatorParams.DTOsParams.TargetProject.Name),
new XAttribute(ConfigNodes.TargetAttrName, ConfigurationHelper.GetTargetName(generatorParams.DTOsParams)),
new XAttribute(ConfigNodes.TargetAttrType, generatorParams.DTOsParams.TargetType.ToString())),
new XElement(ConfigNodes.EDMXName, generatorParams.DTOsParams.EDMXProjectItem.Name),
new XElement(ConfigNodes.GenerateFilter,
new XAttribute(ConfigNodes.GenerateFilterAttrAll, generatorParams.DTOsParams.GenerateAllTypes),
new XAttribute(ConfigNodes.GenerateFilterAttrComplex, generatorParams.DTOsParams.GenerateAllComplexTypes),
new XAttribute(ConfigNodes.GenerateFilterAttrEntities, generatorParams.DTOsParams.GenerateAllEntityTypes)),
new XElement(ConfigNodes.SourceFileHeaderComment, generatorParams.DTOsParams.SourceFileHeaderComment),
new XElement(ConfigNodes.UseProjectDefaultNamespace, generatorParams.DTOsParams.UseProjectDefaultNamespace),
new XElement(ConfigNodes.SourceNamespace, generatorParams.DTOsParams.SourceNamespace),
new XElement(ConfigNodes.DTOsServiceReady, generatorParams.DTOsParams.DTOsServiceReady),
new XElement(ConfigNodes.SourceFileGenerationType, generatorParams.DTOsParams.SourceFileGenerationType.ToString()),
new XElement(ConfigNodes.SourceFileName, generatorParams.DTOsParams.SourceFileName),
new XElement(ConfigNodes.AssociationType, generatorParams.DTOsParams.AssociationType.ToString()),
new XElement(ConfigNodes.GenerateDTOConstructors, generatorParams.DTOsParams.GenerateDTOConstructors),
new XElement(ConfigNodes.ClassIdentifier,
new XAttribute(ConfigNodes.ClassIdentifierAttrUse, generatorParams.DTOsParams.ClassIdentifierUse.ToString()),
new XAttribute(ConfigNodes.ClassIdentifierAttrWord, generatorParams.DTOsParams.ClassIdentifierWord)))));
XElement generateFilterNode = exportDoc.Descendants(ConfigNodes.GenerateFilter).First();
foreach (string typeName in generatorParams.DTOsParams.TypesToGenerateFilter)
{
generateFilterNode.Add(new XElement(ConfigNodes.GenerateType,
new XAttribute(ConfigNodes.GenerateTypeAttrName, typeName))
);
}
if (generatorParams.GenerateAssemblers)
{
exportDoc.Descendants(ConfigNodes.Root).First().Add(
new XElement(ConfigNodes.AssemblersConfig,
new XElement(ConfigNodes.Target,
new XAttribute(ConfigNodes.TargetAttrProject, generatorParams.AssemblersParams.TargetProject.Name),
new XAttribute(ConfigNodes.TargetAttrName, ConfigurationHelper.GetTargetName(generatorParams.AssemblersParams)),
new XAttribute(ConfigNodes.TargetAttrType, generatorParams.AssemblersParams.TargetType.ToString())),
new XElement(ConfigNodes.SourceFileHeaderComment, generatorParams.AssemblersParams.SourceFileHeaderComment),
new XElement(ConfigNodes.UseProjectDefaultNamespace, generatorParams.AssemblersParams.UseProjectDefaultNamespace),
new XElement(ConfigNodes.SourceNamespace, generatorParams.AssemblersParams.SourceNamespace),
new XElement(ConfigNodes.SourceFileGenerationType, generatorParams.AssemblersParams.SourceFileGenerationType.ToString()),
new XElement(ConfigNodes.SourceFileName, generatorParams.AssemblersParams.SourceFileName),
new XElement(ConfigNodes.IsServiceReady, generatorParams.AssemblersParams.IsServiceReady),
new XElement(ConfigNodes.ClassIdentifier,
new XAttribute(ConfigNodes.ClassIdentifierAttrUse, generatorParams.AssemblersParams.ClassIdentifierUse.ToString()),
new XAttribute(ConfigNodes.ClassIdentifierAttrWord, generatorParams.AssemblersParams.ClassIdentifierWord))));
}
exportDoc.Save(filePath);
}
/// <summary>
/// Imports a User Configuration from the specified file path.
/// </summary>
/// <param name="filePath">File path from where to read the User Configuration.</param>
/// <returns></returns>
public static GeneratorManagerParams Import(string filePath)
{
// Prepare result
var result = new GeneratorManagerParams();
result.DTOsParams = new GenerateDTOsParams();
result.AssemblersParams = new GenerateAssemblersParams();
// Load the config file
var configXML = XDocument.Load(filePath);
// Get general config
result.GenerateAssemblers = (configXML.Descendants(ConfigNodes.GenerateAssemblers).First().Value == Resources.XmlBoolTrue);
#region DTOs
// Get the DTOs config node
XElement dtosConfigNode = configXML.Descendants(ConfigNodes.DTOsConfig).First();
result.DTOsParams.EDMXName = dtosConfigNode.Descendants(ConfigNodes.EDMXName).First().Value;
result.DTOsParams.SourceFileHeaderComment = dtosConfigNode.Descendants(ConfigNodes.SourceFileHeaderComment).First().Value;
result.DTOsParams.UseProjectDefaultNamespace = (dtosConfigNode.Descendants(ConfigNodes.UseProjectDefaultNamespace).First().Value == Resources.XmlBoolTrue);
result.DTOsParams.SourceNamespace = dtosConfigNode.Descendants(ConfigNodes.SourceNamespace).First().Value;
result.DTOsParams.DTOsServiceReady = (dtosConfigNode.Descendants(ConfigNodes.DTOsServiceReady).First().Value == Resources.XmlBoolTrue);
result.DTOsParams.SourceFileName = dtosConfigNode.Descendants(ConfigNodes.SourceFileName).First().Value;
result.DTOsParams.GenerateDTOConstructors = (dtosConfigNode.Descendants(ConfigNodes.GenerateDTOConstructors).First().Value == Resources.XmlBoolTrue);
// Source file generation type
XElement sourceFileGenerationTypeNodeDTOs = dtosConfigNode.Descendants(ConfigNodes.SourceFileGenerationType).First();
if (sourceFileGenerationTypeNodeDTOs.Value == SourceFileGenerationType.SourceFilePerClass.ToString())
{
result.DTOsParams.SourceFileGenerationType = SourceFileGenerationType.SourceFilePerClass;
}
else
{
result.DTOsParams.SourceFileGenerationType = SourceFileGenerationType.OneSourceFile;
}
// Association type
XElement associationTypeNode = dtosConfigNode.Descendants(ConfigNodes.AssociationType).First();
if (associationTypeNode.Value == AssociationType.KeyProperty.ToString())
{
result.DTOsParams.AssociationType = AssociationType.KeyProperty;
}
else
{
result.DTOsParams.AssociationType = AssociationType.ClassType;
}
// Set generate filter defaults
result.DTOsParams.GenerateAllTypes = true;
result.DTOsParams.GenerateAllComplexTypes = true;
result.DTOsParams.GenerateAllEntityTypes = true;
result.DTOsParams.TypesToGenerateFilter = new List<string>();
// Generate filter node exists?
XElement genFilterNode = dtosConfigNode.Descendants(ConfigNodes.GenerateFilter).FirstOrDefault();
if (genFilterNode != null)
{
// Get generation flags
result.DTOsParams.GenerateAllTypes =
(genFilterNode.Attribute(ConfigNodes.GenerateFilterAttrAll).Value == Resources.XmlBoolTrue);
result.DTOsParams.GenerateAllComplexTypes =
(genFilterNode.Attribute(ConfigNodes.GenerateFilterAttrComplex).Value == Resources.XmlBoolTrue);
result.DTOsParams.GenerateAllEntityTypes =
(genFilterNode.Attribute(ConfigNodes.GenerateFilterAttrEntities).Value == Resources.XmlBoolTrue);
// Get filter types
foreach (XElement generateTypeNode in genFilterNode.Descendants(ConfigNodes.GenerateType))
{
result.DTOsParams.TypesToGenerateFilter.Add(
generateTypeNode.Attribute(ConfigNodes.GenerateTypeAttrName).Value
);
}
}
// Set DTOs identifier defaults
result.DTOsParams.ClassIdentifierUse = ClassIdentifierUse.Suffix;
result.DTOsParams.ClassIdentifierWord = "DTO";
// DTO identifier node exists?
XElement dtosIdentifierNode = dtosConfigNode.Descendants(ConfigNodes.ClassIdentifier).FirstOrDefault();
if (dtosIdentifierNode != null)
{
string dtoIdentifierUseValue = dtosIdentifierNode.Attribute(ConfigNodes.ClassIdentifierAttrUse).Value;
if (dtoIdentifierUseValue == ClassIdentifierUse.None.ToString())
{
result.DTOsParams.ClassIdentifierUse = ClassIdentifierUse.None;
}
else if (dtoIdentifierUseValue == ClassIdentifierUse.Prefix.ToString())
{
result.DTOsParams.ClassIdentifierUse = ClassIdentifierUse.Prefix;
}
result.DTOsParams.ClassIdentifierWord = dtosIdentifierNode.Attribute(ConfigNodes.ClassIdentifierAttrWord).Value;
}
// Get target info
XElement targetNodeDTOs = dtosConfigNode.Descendants(ConfigNodes.Target).FirstOrDefault();
if (targetNodeDTOs == null)
{
// Legacy config (v2.* and older)
targetNodeDTOs = dtosConfigNode.Descendants(ConfigNodes.TargetProjectName).First();
result.DTOsParams.TargetType = TargetType.Project;
result.DTOsParams.TargetProjectName = targetNodeDTOs.Value;
result.DTOsParams.TargetName = targetNodeDTOs.Value;
}
else
{
if (targetNodeDTOs.Attribute(ConfigNodes.TargetAttrType).Value == TargetType.Project.ToString())
{
result.DTOsParams.TargetType = TargetType.Project;
}
else
{
result.DTOsParams.TargetType = TargetType.ProjectFolder;
}
result.DTOsParams.TargetProjectName = targetNodeDTOs.Attribute(ConfigNodes.TargetAttrProject).Value;
result.DTOsParams.TargetName = targetNodeDTOs.Attribute(ConfigNodes.TargetAttrName).Value;
}
#endregion DTOs
#region Assemblers
if (result.GenerateAssemblers)
{
// Get the Assemblers config node
XElement assemblersConfigNode = configXML.Descendants(ConfigNodes.AssemblersConfig).First();
result.AssemblersParams.SourceFileHeaderComment = assemblersConfigNode.Descendants(ConfigNodes.SourceFileHeaderComment).First().Value;
result.AssemblersParams.UseProjectDefaultNamespace = (assemblersConfigNode.Descendants(ConfigNodes.UseProjectDefaultNamespace).First().Value == Resources.XmlBoolTrue);
result.AssemblersParams.SourceNamespace = assemblersConfigNode.Descendants(ConfigNodes.SourceNamespace).First().Value;
result.AssemblersParams.SourceFileName = assemblersConfigNode.Descendants(ConfigNodes.SourceFileName).First().Value;
result.AssemblersParams.IsServiceReady = (assemblersConfigNode.Descendants(ConfigNodes.IsServiceReady).First().Value == Resources.XmlBoolTrue);
// Source file generation type
XElement sourceFileGenerationTypeNodeAssemblers = assemblersConfigNode.Descendants(ConfigNodes.SourceFileGenerationType).First();
if (sourceFileGenerationTypeNodeAssemblers.Value == SourceFileGenerationType.SourceFilePerClass.ToString())
{
result.AssemblersParams.SourceFileGenerationType = SourceFileGenerationType.SourceFilePerClass;
}
else
{
result.AssemblersParams.SourceFileGenerationType = SourceFileGenerationType.OneSourceFile;
}
// Set Assemblers identifier defaults
result.AssemblersParams.ClassIdentifierUse = ClassIdentifierUse.Suffix;
result.AssemblersParams.ClassIdentifierWord = "Assembler";
// Assembler identifier node exists?
XElement assemblersIdentifierNode = assemblersConfigNode.Descendants(ConfigNodes.ClassIdentifier).FirstOrDefault();
if (assemblersIdentifierNode != null)
{
string assemblersIdentifierUseValue = assemblersIdentifierNode.Attribute(ConfigNodes.ClassIdentifierAttrUse).Value;
if (assemblersIdentifierUseValue == ClassIdentifierUse.None.ToString())
{
result.AssemblersParams.ClassIdentifierUse = ClassIdentifierUse.None;
}
else if (assemblersIdentifierUseValue == ClassIdentifierUse.Prefix.ToString())
{
result.AssemblersParams.ClassIdentifierUse = ClassIdentifierUse.Prefix;
}
result.AssemblersParams.ClassIdentifierWord = assemblersIdentifierNode.Attribute(ConfigNodes.ClassIdentifierAttrWord).Value;
}
// Get target info
XElement targetNodeAssemblers = assemblersConfigNode.Descendants(ConfigNodes.Target).FirstOrDefault();
if (targetNodeAssemblers == null)
{
// Legacy config (v2.* and older)
targetNodeAssemblers = assemblersConfigNode.Descendants(ConfigNodes.TargetProjectName).First();
result.AssemblersParams.TargetType = TargetType.Project;
result.AssemblersParams.TargetProjectName = targetNodeAssemblers.Value;
result.AssemblersParams.TargetName = targetNodeAssemblers.Value;
}
else
{
if (targetNodeAssemblers.Attribute(ConfigNodes.TargetAttrType).Value == TargetType.Project.ToString())
{
result.AssemblersParams.TargetType = TargetType.Project;
}
else
{
result.AssemblersParams.TargetType = TargetType.ProjectFolder;
}
result.AssemblersParams.TargetProjectName = targetNodeAssemblers.Attribute(ConfigNodes.TargetAttrProject).Value;
result.AssemblersParams.TargetName = targetNodeAssemblers.Attribute(ConfigNodes.TargetAttrName).Value;
}
}
#endregion Assemblers
// Return the configuration
return result;
}
