/// <summary>
/// Carga los datos de un proyecto
/// </summary>
private void LoadProject(string fileName)
{
try
{
// Carga los datos del archivo
project = new NSharpDocManager().LoadProject(fileName);
// Muestra los datos del proyecto
cboDocumentType.SelectedID = (int)project.IDType;
pthTarget.PathName = project.OutputPath;
pthTemplates.PathName = project.TemplatePath;
if (pthTemplates.PathName.IsEmpty())
{
pthTemplates.PathName = System.IO.Path.Combine(Application.StartupPath, "Data\\Templates");
}
// Carga los parámetros de generación
chkShowPublic.Checked = project.GenerationParameters.ShowPublic;
chkShowInternal.Checked = project.GenerationParameters.ShowInternal;
chkShowProtected.Checked = project.GenerationParameters.ShowProtected;
chkShowPrivate.Checked = project.GenerationParameters.ShowPrivate;
// Carga los provedores
LoadListProviders();
// Cambia la configuración
SaveConfiguration();
}
catch (Exception exception)
{
Bau.Controls.Forms.Helper.ShowMessage(this, $"Error al cargar {fileName}. {Environment.NewLine} {exception.Message}");
}
}
/// <summary>
/// Genera la documentación a partir de estructuras de documentación
/// </summary>
private void Process(StructDocumentationModelCollection structDocs, ProjectDocumentationModel project)
{
// Copia el contenido del directorio de plantillas
CopyTemplates(project);
// Genera la documentación
new Processor.DocumentationGenerator(this, project).Process(structDocs);
}
/// <summary>
/// Asigna los parámetros del formulario al proyecto
/// </summary>
private void AssignParameters(ProjectDocumentationModel objProject)
{ // Recupera el tipo y los directorios
objProject.IDType = (ProjectDocumentationModel.DocumentationType)(cboDocumentType.SelectedID ?? 0);
objProject.OutputPath = pthTarget.PathName;
objProject.TemplatePath = pthTemplates.PathName;
// Recupera los parámetros de generación
objProject.GenerationParameters.ShowInternal = chkShowInternal.Checked;
objProject.GenerationParameters.ShowPrivate = chkShowPrivate.Checked;
objProject.GenerationParameters.ShowProtected = chkShowProtected.Checked;
objProject.GenerationParameters.ShowPublic = chkShowPublic.Checked;
}
internal TemplateDocumentGenerator(ProjectDocumentationModel project,
DocumentationGenerator documentationGenerator,
TemplateModel template, DocumentFileModel document,
string urlBase, DocumentFileModelCollection allDocuments)
{
Project = project;
Generator = documentationGenerator;
Template = template;
Document = document;
UrlBase = urlBase;
DocumentsGenerated = allDocuments;
}
/// <summary>
/// Limpia los datos
/// </summary>
private void Clear(bool loadLast)
{
// Crea un nuevo objeto de proyecto
project = new ProjectDocumentationModel();
// Inicializa la lista de proveedores
InitListProviders();
// Carga el objeto de proyecto si es necesario
if (loadLast && !Configuration.LastProject.IsEmpty() && System.IO.File.Exists(Configuration.LastProject))
{
LoadProject(Configuration.LastProject);
}
}
/// <summary>
/// Genera la documentación de un proyecto
/// </summary>
private void CompileProject(ProjectDocumentationModel project)
{
StructDocumentationModelCollection structsDoc = new StructDocumentationModelCollection();
// Genera las estructuras de documentación de los diferentes proveedores
foreach (ProviderModel provider in project.Providers)
{
try
{
switch (provider.Type.TrimIgnoreNull().ToUpper())
{
case "C#":
structsDoc.Add(new LibNetParser.ProgramParser().Parse(provider.Parameters));
break;
case "VISUALBASIC":
structsDoc.Add(new LibNetParser.ProgramParser().Parse(provider.Parameters));
break;
case "SQLSERVER":
structsDoc.Add(CompileDatabase(LibDataBaseDocumenter.StructDataBaseConversor.DataBaseType.SqlServer,
provider.Parameters));
break;
case "OLEDB":
structsDoc.Add(CompileDatabase(LibDataBaseDocumenter.StructDataBaseConversor.DataBaseType.SqlServer,
provider.Parameters));
break;
case "XMLSTRUCTS":
structsDoc.Add(new LibXMLStructs.Documenter.XMLStructsDocumenter().Parse(provider.Parameters));
break;
case "HELPPAGES":
structsDoc.Add(new LibHelpPages.Documenter.HelpPages().Parse(provider.Parameters));
break;
default:
Errors.Add($"No se reconoce el proveedor {provider.Type}");
break;
}
}
catch (Exception exception)
{
Errors.Add($"Error en la generación de {provider.Type}. {exception.Message}");
}
}
// Genera la documentación
Process(structsDoc, project);
}
/// <summary>
/// Genera la documentación a partir de los parámetros de un archivo XML
/// </summary>
public void Generate(ProjectDocumentationModel project, IDocumentWriter writer = null)
{
// Obtiene el generador
if (writer == null)
{
writer = GetDocumentWriter(project);
}
// Guarda el generador
Writer = writer;
// Borra el directorio destino
LibCommonHelper.Files.HelperFiles.KillPath(project.OutputPath);
// Genera la documentación de los distintos proveedores
CompileProject(project);
}
/// <summary>
/// Genera la documentación a partir de los parámetros de un archivo XML
/// </summary>
public void Generate(ProjectDocumentationModel objProject, IDocumentWriter objWriter = null)
{ // Obtiene el generador
if (objWriter == null)
{
objWriter = GetDocumentWriter(objProject);
}
// Guarda el generador
Writer = objWriter;
// Borra el directorio destino
foreach (ProviderModel objProvider in objProject.Providers)
{
LibHelper.Files.HelperFiles.KillPath(objProject.OutputPath);
}
// Genera la documentación de los distintos proveedores
CompileProject(objProject);
}
/// <summary>
/// Obtiene el interface para la generación de la documentación final
/// </summary>
private IDocumentWriter GetDocumentWriter(ProjectDocumentationModel objProject)
{
switch (objProject.IDType)
{
case ProjectDocumentationModel.DocumentationType.Nhtml:
return(new Processor.Writers.NHaml.NHamlWriter());
case ProjectDocumentationModel.DocumentationType.Html:
return(new Processor.Writers.Html.HtmlWriter());
case ProjectDocumentationModel.DocumentationType.Xml:
return(new Processor.Writers.Xml.XmlWriter());
default:
throw new NotImplementedException("No se reconoce el tipo de documentación: " + objProject.IDType.ToString());
}
}
/// <summary>
/// Genera la documentación de un proyecto
/// </summary>
private void CompileProject(ProjectDocumentationModel objProject)
{
StructDocumentationModelCollection objColStructs = new StructDocumentationModelCollection();
// Genera las estructuras de documentación de los diferentes proveedores
foreach (ProviderModel objProvider in objProject.Providers)
{
try
{ switch (objProvider.Type.TrimIgnoreNull().ToUpper())
{
case "C#":
objColStructs.Add(new LibCSharpParser.ProgramParser().Parse(objProvider.Parameters));
break;
case "VISUALBASIC":
objColStructs.Add(new LibVisualBasicParser.ProgramParser().Parse(objProvider.Parameters));
break;
case "SQLSERVER":
objColStructs.Add(new LibSqlServer.Documenter.SchemaDocumenter().Parse(objProvider.Parameters));
break;
case "OLEDB":
objColStructs.Add(new LibOleDB.Documenter.SchemaDocumenter().Parse(objProvider.Parameters));
break;
case "XMLSTRUCTS":
objColStructs.Add(new LibXMLStructs.Documenter.XMLStructsDocumenter().Parse(objProvider.Parameters));
break;
default:
Errors.Add($"No se reconoce el proveedor {objProvider.Type}");
break;
}
}
catch (Exception objException)
{ Errors.Add($"Error en la generación de {objProvider.Type}. {objException.Message}"); }
}
// Genera la documentación
Process(objColStructs, objProject);
}
/// <summary>
/// Copia los archivos del directorio donde se encuentran las plantillas
/// </summary>
private void CopyTemplates(ProjectDocumentationModel project)
{
string pathTemplate = project.TemplatePath;
if (!pathTemplate.IsEmpty() && System.IO.Directory.Exists(pathTemplate))
{
// Copia los directorios
foreach (string path in System.IO.Directory.GetDirectories(pathTemplate))
{
LibCommonHelper.Files.HelperFiles.CopyPath(path, System.IO.Path.Combine(project.OutputPath, System.IO.Path.GetFileName(path)));
}
// Copia los archivos (excepto las plantillas)
foreach (string file in System.IO.Directory.GetFiles(pathTemplate))
{
if (!file.EndsWith(".tpt", StringComparison.CurrentCultureIgnoreCase) && !file.StartsWith("_"))
{
LibCommonHelper.Files.HelperFiles.CopyFile(file, System.IO.Path.Combine(project.OutputPath, System.IO.Path.GetFileName(file)));
}
}
}
}
/// <summary>
/// Carga los datos de un proyecto
/// </summary>
private void LoadProject(string strFileName)
{ // Carga los datos del archivo
objProject = new NSharpDocManager().LoadProject(strFileName);
// Muestra los datos del proyecto
cboDocumentType.SelectedID = (int)objProject.IDType;
pthTarget.PathName = objProject.OutputPath;
pthTemplates.PathName = objProject.TemplatePath;
if (pthTemplates.PathName.IsEmpty())
{
pthTemplates.PathName = System.IO.Path.Combine(Application.StartupPath, "Data\\Templates");
}
// Carga los parámetros de generación
chkShowPublic.Checked = objProject.GenerationParameters.ShowPublic;
chkShowInternal.Checked = objProject.GenerationParameters.ShowInternal;
chkShowProtected.Checked = objProject.GenerationParameters.ShowProtected;
chkShowPrivate.Checked = objProject.GenerationParameters.ShowPrivate;
// Carga los provedores
LoadListProviders();
// Cambia la configuración
SaveConfiguration();
}
/// <summary>
/// Graba los datos de un mensaje
/// </summary>
internal void Save(string fileName, ProjectDocumentationModel project)
{
MLFile fileML = new MLFile();
MLNode nodeML = fileML.Nodes.Add(TagRoot);
// Añade los parámetros básicos
nodeML.Nodes.Add(TagDocumentationType, (int)project.IDType);
nodeML.Nodes.Add(TagOutputPath, project.OutputPath);
nodeML.Nodes.Add(TagTemplatePath, project.TemplatePath);
// Añade los parámetros de documentación
nodeML.Nodes.Add(TagShowPublic, project.GenerationParameters.ShowPublic);
nodeML.Nodes.Add(TagShowProtected, project.GenerationParameters.ShowProtected);
nodeML.Nodes.Add(TagShowInternal, project.GenerationParameters.ShowInternal);
nodeML.Nodes.Add(TagShowPrivate, project.GenerationParameters.ShowPrivate);
// Añade los nodos de proveedor
foreach (ProviderModel provider in project.Providers)
{
nodeML.Nodes.Add(GetNodeProvider(provider));
}
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(fileName, fileML);
}
/// <summary>
/// Graba los datos de un mensaje
/// </summary>
internal void Save(string strFileName, ProjectDocumentationModel objProject)
{
MLFile objMLFile = new MLFile();
MLNode objMLNode = objMLFile.Nodes.Add(cnstStrTagRoot);
// Añade los parámetros básicos
objMLNode.Nodes.Add(cnstStrTagDocumentationType, (int)objProject.IDType);
objMLNode.Nodes.Add(cnstStrTagProviderPath, objProject.OutputPath);
objMLNode.Nodes.Add(cnstStrTagProviderTemplatePath, objProject.TemplatePath);
// Añade los parámetros de documentación
objMLNode.Nodes.Add(cnstStrTagShowPublic, objProject.GenerationParameters.ShowPublic);
objMLNode.Nodes.Add(cnstStrTagShowProtected, objProject.GenerationParameters.ShowProtected);
objMLNode.Nodes.Add(cnstStrTagShowInternal, objProject.GenerationParameters.ShowInternal);
objMLNode.Nodes.Add(cnstStrTagShowPrivate, objProject.GenerationParameters.ShowPrivate);
// Añade los nodos de proveedor
foreach (ProviderModel objProvider in objProject.Providers)
{
objMLNode.Nodes.Add(GetNodeProvider(objProvider));
}
// Graba el archivo
new MLSerializer().Save(MLSerializer.SerializerType.XML, objMLFile, strFileName);
}
/// <summary>
/// Carga los datos de un archivo
/// </summary>
internal ProjectDocumentationModel Load(string fileName)
{
ProjectDocumentationModel project = new ProjectDocumentationModel();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
// Asigna el nombre de archivo
project.FileName = fileName;
// Carga los datos
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == TagRoot)
{
// Añade los parámetros básicos
project.IDType = (ProjectDocumentationModel.DocumentationType)nodeML.Nodes[TagDocumentationType].Value.GetInt(0);
project.OutputPath = nodeML.Nodes[TagOutputPath].Value;
project.TemplatePath = nodeML.Nodes[TagTemplatePath].Value;
project.GenerationParameters.ShowPublic = nodeML.Nodes[TagShowPublic].Value.GetBool();
project.GenerationParameters.ShowProtected = nodeML.Nodes[TagShowProtected].Value.GetBool();
project.GenerationParameters.ShowInternal = nodeML.Nodes[TagShowInternal].Value.GetBool();
project.GenerationParameters.ShowPrivate = nodeML.Nodes[TagShowPrivate].Value.GetBool();
// Añade los proveedores
foreach (MLNode childML in nodeML.Nodes)
{
if (childML.Name == TagProvider)
{
project.Providers.Add(LoadProvider(childML));
}
}
}
}
}
// Devuelve el proyecto
return(project);
}
/// <summary>
/// Carga los datos de un archivo
/// </summary>
internal ProjectDocumentationModel Load(string strFileName)
{
ProjectDocumentationModel objProject = new ProjectDocumentationModel();
// Asigna el nombre de archivo
objProject.FileName = strFileName;
// Carga los datos
if (System.IO.File.Exists(strFileName))
{
MLFile objMLFile = new MLSerializer().Parse(MLSerializer.SerializerType.XML, strFileName);
foreach (MLNode objMLNode in objMLFile.Nodes)
{
if (objMLNode.Name == cnstStrTagRoot)
{ // Añade los parámetros básicos
objProject.IDType = (ProjectDocumentationModel.DocumentationType)objMLNode.Nodes[cnstStrTagDocumentationType].Value.GetInt(0);
objProject.OutputPath = objMLNode.Nodes[cnstStrTagProviderPath].Value;
objProject.TemplatePath = objMLNode.Nodes[cnstStrTagProviderTemplatePath].Value;
objProject.GenerationParameters.ShowPublic = objMLNode.Nodes[cnstStrTagShowPublic].Value.GetBool();
objProject.GenerationParameters.ShowProtected = objMLNode.Nodes[cnstStrTagShowProtected].Value.GetBool();
objProject.GenerationParameters.ShowInternal = objMLNode.Nodes[cnstStrTagShowInternal].Value.GetBool();
objProject.GenerationParameters.ShowPrivate = objMLNode.Nodes[cnstStrTagShowPrivate].Value.GetBool();
// Añade los proveedores
foreach (MLNode objMLChild in objMLNode.Nodes)
{
if (objMLChild.Name == cnstStrTagProvider)
{
objProject.Providers.Add(LoadProvider(objMLChild));
}
}
}
}
}
// Devuelve el proyecto
return(objProject);
}
internal DocumentationGenerator(NSharpDocManager objGenerator, ProjectDocumentationModel project)
{
DocumentationProcessor = objGenerator;
Project = project;
}
/// <summary>
/// Graba los datos de un proyecto
/// </summary>
public void SaveProject(ProjectDocumentationModel objProject, string strFileName)
{
new Repository.Projects.ProjectRepository().Save(strFileName, objProject);
}
/// <summary>
/// Graba los datos de un proyecto
/// </summary>
public void SaveProject(ProjectDocumentationModel project, string fileName)
{
new Repository.Projects.ProjectRepository().Save(fileName, project);
}
