/// <summary>
/// Graba los datos de un documento
/// </summary>
public void Save(DocumentModel document, string fileName)
{
MLFile fileML = new MLFile();
MLNode nodeML = fileML.Nodes.Add(TagRoot);
// Asigna los datos del nodo
nodeML.Attributes.Add(TagIsRecursive, document.IsRecursive);
nodeML.Nodes.Add(TagID, document.GlobalId);
nodeML.Nodes.Add(TagTitle, document.Title);
nodeML.Nodes.Add(TagDescription, document.Description);
nodeML.Nodes.Add(TagKeyWords, document.KeyWords);
nodeML.Nodes.Add(TagContent, document.Content);
nodeML.Nodes.Add(TagShowAtRSS, document.ShowAtRSS);
nodeML.Nodes.Add(TagURLImageSummary, document.URLImageSummary);
nodeML.Nodes.Add(TagShowChilds, (int)document.ModeShow);
nodeML.Nodes.Add(TagType, (int)document.File.FileType);
nodeML.Nodes.Add(TagScope, (int)document.IDScope);
nodeML.Nodes.Add(TagDateCreate, document.DateNew);
// Añade las plantillas
new TemplatesArrayRepository().AddNodes(document.Templates, nodeML);
// Añade los archivos asociados
nodeML.Nodes.AddRange(GetFileNodes(TagPageTag, document.Tags));
nodeML.Nodes.AddRange(GetFileNodes(TagPageChildPage, document.ChildPages));
// Graba el archivo
new XMLWriter().Save(fileName, fileML);
}
/// <summary>
/// Graba la documentación Nhaml en un archivo
/// </summary>
public void Save(DocumentFileModel document, MLIntermedialBuilder builderML, string fileNameTemplate, string path)
{
MLFile fileML = GetMLFile(document.Name, "", builderML.Root);
// Graba el archivo
Save(fileML, path, LibCommonHelper.Files.HelperFiles.Normalize(document.Name, false) + ".xml");
}
/// <summary>
/// Graba un archivo XML
/// </summary>
private void Save(MLFile fileML, string path, string fileName)
{
// Crea el directorio
LibCommonHelper.Files.HelperFiles.MakePath(path);
// Graba el archivo de documentación
new LibMarkupLanguage.Services.XML.XMLWriter().Save(System.IO.Path.Combine(path, fileName), fileML);
}
/// <summary>
/// Interpreta un archivo XML
/// </summary>
public MLFile Parse(string strFileName)
{
MLFile objMLFile = new MLFile();
// Lee los datos
using (XmlReader objReader = Open(strFileName))
{ XmlDocument objDocument = new XmlDocument();
// Carga los datos
if (objReader != null) // ... si hay algo en el archivo
try
{ // Carga el documento
objDocument.Load(objReader);
// Obtiene los nodos
objMLFile = Load(objDocument);
}
catch (Exception objException)
{ throw new ParserException("Error en la interpretación del archivo XML", objException);
}
// Cierra el reader
objReader.Close();
}
// Devuelve el nodo principal
return objMLFile;
}
/// <summary>
/// Interpreta los datos de un archivo XML
/// </summary>
public RSSChannel Parse(MLFile fileML)
{
RSSChannel rss = null;
// Recorre los nodos del documento
if (fileML != null)
{
foreach (MLNode node in fileML.Nodes)
{
if (node.Name.Equals(RSSConstTags.cnstStrRoot))
{
// Crea el objeto
rss = new RSSChannel();
// Lee los espacios de nombres de las extensiones
rss.Dictionary.LoadNameSpaces(node);
// Lee los datos
foreach (MLNode channel in node.Nodes)
{
if (channel.Name.Equals(RSSConstTags.cnstStrChannel))
{
ParseChannel(channel, rss);
}
}
}
}
}
// Devuelve el objeto RSS
return(rss);
}
/// <summary>
/// Carga los datos de un informe
/// </summary>
internal ReportModel Load(string fileName)
{
ReportModel report = new ReportModel();
MLFile fileML = LoadFile(fileName);
// Carga los datos
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name.Equals(TagRoot) || nodeML.Name.Equals(TagRootOld))
{
// Carga las propiedades
report.GlobalId = nodeML.Nodes[TagId].Value;
report.Name = nodeML.Nodes[TagName].Value;
report.Description = nodeML.Nodes[TagDescription].Value;
report.ReportDefinition = NormalizeContentLoad(nodeML.Nodes[TagReportDefinition].Value);
// Carga los parámetros de ejecución
report.Parameters.AddRange(LoadParameterList(nodeML, TagParameter));
report.FixedParameters.AddRange(LoadParameterList(nodeML, TagFixedParameter));
}
}
}
// Devuelve el informe
return(report);
}
/// <summary>
/// Graba un archivo de pruebas
/// </summary>
private void SaveTestFile(BlockLogModel block, string fileName, string provider, string pathVariable, string databaseVariable, string sufixTestTables)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add("DbScript");
// Log
block.Info($"Start generate file '{fileName}'");
// Crea los nodos de creación de los archivos de pruebas
foreach (ConnectionTableModel table in Connection.Tables)
{
if (!string.IsNullOrWhiteSpace(DataBase) && DataBase.Equals(table.Schema, StringComparison.CurrentCultureIgnoreCase))
{
MLNode blockML = rootML.Nodes.Add("Block");
MLNode nodeDropML = blockML.Nodes.Add("Execute");
MLNode nodeCreateML = blockML.Nodes.Add("Execute");
// Mensaje del bloque
blockML.Attributes.Add("Message", $"Test table {table.Name}");
// Crea el nodo para borrar la tabla
nodeDropML.Attributes.Add("Target", provider);
nodeDropML.Value = $"DROP TABLE IF EXISTS {table.Name}{sufixTestTables}";
// Crea el nodo de creación de la tabla
nodeCreateML.Attributes.Add("Target", provider);
nodeCreateML.Value = Environment.NewLine + $"\t\t\tCREATE EXTERNAL TABLE {table.Name}{sufixTestTables} STORED AS parquet";
nodeCreateML.Value += Environment.NewLine + "\t\t\t\tLOCATION '{{" + pathVariable + "}}" + $"/testing/{table.Name}{sufixTestTables}.parquet' AS ";
nodeCreateML.Value += Environment.NewLine + "\t\t\t\tSELECT * FROM {{" + databaseVariable + "}}" + $".{table.Name}";
nodeCreateML.Value += Environment.NewLine;
}
}
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(System.IO.Path.Combine(Path, fileName), fileML);
// Log
block.Info($"End generation file '{fileName}'");
}
/// <summary>
/// Convierte los datos de un MLFile en una cadena
/// </summary>
public string ConverToString(MLFile objMLFile)
{
// Crea el stringBuilder del archivo
Create(objMLFile);
// Devuelve la cadena
return sbXML.ToString();
}
/// <summary>
/// Graba el documento XML de la definición de la Web
/// </summary>
public void Save(ProjectModel project)
{
MLFile fileML = new MLFile();
MLNode nodeML = fileML.Nodes.Add(TagWebDefinition);
// Añade los datos básicos
nodeML.Nodes.Add(TagDescription, project.Description);
nodeML.Nodes.Add(TagTitle, project.Title);
nodeML.Nodes.Add(TagKeyWords, project.KeyWords);
nodeML.Nodes.Add(TagWebType, project.WebType.ToString());
nodeML.Nodes.Add(TagURLBase, project.URLBase);
// Página principal, elementos por categoría y por etiqueta y si se debe añadir el título de la Web al de la página
nodeML.Nodes.Add(TagPageMain, project.PageMain);
nodeML.Nodes.Add(TagItemsPerCategory, project.ItemsPerCategory);
nodeML.Nodes.Add(TagItemsPerSiteMap, project.ItemsPerSiteMap);
nodeML.Nodes.Add(TagMaxWidthImage, project.MaxWidthImage);
nodeML.Nodes.Add(TagThumbsWidth, project.ThumbsWidth);
nodeML.Nodes.Add(TagAddWebTitle, project.AddWebTitle);
nodeML.Nodes.Add(TagNumberParagraphsSummary, project.ParagraphsSummaryNumber);
// Párametros del sitio
nodeML.Nodes.Add(TagWebMaster, project.WebMaster);
nodeML.Nodes.Add(TagCopyright, project.Copyright);
nodeML.Nodes.Add(TagEditor, project.Editor);
nodeML.Nodes.Add(TagVariables, project.VariablesText);
// Comandos tras compilación
nodeML.Nodes.Add(TagCommands, project.PostCompileCommands);
// Graba las plantillas
new Documents.TemplatesArrayRepository().AddNodes(project.Templates, nodeML);
// Graba el archivo
new XMLWriter().Save(project.File.FullFileName, fileML);
}
/// <summary>
/// Graba las entradas de un blog
/// </summary>
internal void SaveToFile(BlogModel blog, string fileName)
{
MLFile fileML = new MLFile();
MLNode objMLRoot = fileML.Nodes.Add(TagRoot);
// Elimina los borrados antiguos
blog.Entries.DeleteOldData();
// Añade las entradas
foreach (EntryModel entry in blog.Entries)
{
MLNode nodeML = objMLRoot.Nodes.Add(TagEntry);
// Añade los datos
nodeML.Attributes.Add(TagDatePublish, entry.DatePublish);
nodeML.Attributes.Add(TagStatus, (int)entry.Status);
nodeML.Nodes.Add(TagName, entry.Name);
nodeML.Nodes.Add(TagUrl, entry.URL);
nodeML.Nodes.Add(TagUrlEnclosure, entry.UrlEnclosure);
nodeML.Nodes.Add(TagDownloadFileName, entry.DownloadFileName);
if (entry.Status != EntryModel.StatusEntry.Deleted)
{
nodeML.Nodes.Add(TagContent, entry.Content);
}
nodeML.Nodes.Add(TagAuthor, entry.Author);
}
// Graba el archivo
new XMLWriter().Save(fileName, fileML);
}
/// <summary>
/// Obtiene el builder XML de un objeto Atom
/// </summary>
private MLFile GetFile(AtomChannel channel)
{
MLFile file = new MLFile();
MLNode node;
// Añade la cabecera
node = file.Nodes.Add(AtomConstTags.cnstStrChannelRoot);
node.Attributes.Add("xmlns", "http://purl.org/atom/ns#");
node.NameSpaces.AddRange(channel.Extensions.GetNameSpaces(channel));
node.Attributes.Add("version", "0.3");
// Obtiene el XML de los datos
node.Nodes.Add(AtomConstTags.cnstStrChannelId, channel.ID);
AddText(node, AtomConstTags.cnstStrChannelTitle, channel.Title);
AddText(node, AtomConstTags.cnstStrChannelTagline, channel.TagLine);
AddText(node, AtomConstTags.cnstsubTitle, channel.Subtitle);
node.Nodes.Add(AtomConstTags.cnsticon, channel.Icon);
node.Nodes.Add(AtomConstTags.cnstStrLogo, channel.Logo);
AddRights(node, channel.Rights);
AddGenerator(node, channel.Generator);
node.Nodes.Add(AtomConstTags.cnstStrChannelConvertLineBreaks, channel.ConvertLineBreaks);
AddText(node, AtomConstTags.cnstStrChannelInfo, channel.Info);
AddLinks(node, channel.Links);
AddDate(node, AtomConstTags.cnstStrItemModified, channel.LastUpdated);
AddCategories(node, channel.Categories);
// Obtiene el XML de las extensiones
channel.Extensions.AddNodesExtension(node);
// Obtiene el XML de los elementos
AddItems(node, channel.Entries);
// Devuelve los datos
return(file);
}
/// <summary>
/// Obtiene el XML de una colección de canales
/// </summary>
internal string GetXml(TrackModelCollection tracks)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add(TagRoot);
// Obtiene los nodos del archivo
foreach (TrackModel track in tracks)
{
MLNode trackML = rootML.Nodes.Add(TagTrack);
// Añade las propiedades
trackML.Nodes.Add(TagName, track.Title);
trackML.Nodes.Add(TagDescription, track.Description);
trackML.Nodes.Add(TagUrl, track.Url);
trackML.Attributes.Add(TagEnabled, track.Enabled);
trackML.Attributes.Add(TagDateLastDownload, track.DateLastDownload);
// trackML.Attributes.Add(TagDateLastError, track.DateLastError);
// Añade los canales
foreach (CategoryModel category in track.Categories)
{
MLNode categoryML = trackML.Nodes.Add(TagCategory);
// Añade las propiedades
categoryML.Attributes.Add(TagId, category.Id);
categoryML.Attributes.Add(TagDeleted, category.IsDeleted);
categoryML.Nodes.Add(TagName, category.Title);
}
}
// Obtiene la cadena XML
return(new LibMarkupLanguage.Services.XML.XMLWriter().ConvertToString(fileML));
}
/// <summary>
/// Graba el archivo de comparación de tablas
/// </summary>
private void SaveAssertFile(BlockLogModel block, string fileName, string provider, string pathVariable, string databaseVariable, string sufixTestTables)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add("DbScript");
// Log
block.Info($"Start generate file '{fileName}'");
// Crea los nodos de creación de los archivos de pruebas
foreach (ConnectionTableModel table in Connection.Tables)
{
if (!string.IsNullOrWhiteSpace(DataBase) && DataBase.Equals(table.Schema, StringComparison.CurrentCultureIgnoreCase))
{
MLNode blockML = rootML.Nodes.Add("Block");
MLNode nodeAssertML = blockML.Nodes.Add("AssertScalar");
// Mensaje del bloque
blockML.Attributes.Add("Message", $"Assert table {table.Name}");
// Añade los atributos de la sentencia de comparación
nodeAssertML.Attributes.Add("Target", provider);
nodeAssertML.Attributes.Add("Message", $"Assert table {table.Name}");
nodeAssertML.Attributes.Add("Result", 0);
// Añade la cadena de consulta
nodeAssertML.Value = GetSqlCompare(table, pathVariable, databaseVariable, sufixTestTables);
}
}
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(System.IO.Path.Combine(Path, fileName), fileML);
// Log
block.Info($"End generation file '{fileName}'");
}
/// <summary>
/// Interpreta un archivo XML
/// </summary>
public MLFile Parse(string strFileName)
{
MLFile objMLFile = new MLFile();
// Lee los datos
using (XmlReader objReader = Open(strFileName))
{ XmlDocument objDocument = new XmlDocument();
// Carga los datos
if (objReader != null) // ... si hay algo en el archivo
{
try
{ // Carga el documento
objDocument.Load(objReader);
// Obtiene los nodos
objMLFile = Load(objDocument);
}
catch (Exception objException)
{ throw new ParserException("Error en la interpretación del archivo XML " + strFileName, objException); }
}
// Cierra el reader
objReader.Close(); }
// Devuelve el nodo principal
return(objMLFile);
}
/// <summary>
/// Convierte los datos de un MLFile en una cadena
/// </summary>
public string ConvertToString(MLFile objMLFile, bool blnAddHeader = true)
{
// Crea el stringBuilder del archivo
Create(objMLFile, blnAddHeader);
// Devuelve la cadena
return sbXML.ToString();
}
/// <summary>
/// Obtiene el builder XML de un objeto RSS
/// </summary>
private MLFile GetFile(RSSChannel rss)
{
MLFile file = new MLFile();
MLNode node = file.Nodes.Add(RSSConstTags.cnstStrRoot);
// Añade los atributos de la cabecera
node.NameSpaces.AddRange(rss.Extensions.GetNameSpaces(rss));
node.Attributes.Add("version", "2.0");
// Añade los datos del canal
node = node.Nodes.Add(RSSConstTags.cnstStrChannel);
// Obtiene el XML de los datos
node.Nodes.Add(RSSConstTags.cnstStrChannelTitle, rss.Title);
node.Nodes.Add(RSSConstTags.cnstStrChannelLink, rss.Link);
node.Nodes.Add(RSSConstTags.cnstStrChannelLanguage, rss.Language);
node.Nodes.Add(RSSConstTags.cnstStrChannelCopyright, rss.Copyright);
node.Nodes.Add(RSSConstTags.cnstStrChannelDescription, rss.Description);
node.Nodes.Add(RSSConstTags.cnstStrChannelLastBuildDate,
DateTimeHelper.ToStringRfc822(rss.LastBuildDate));
// Obtiene el XML de la imagen
AddImage(node, rss.Logo);
// Obtiene el XML de las extensiones
rss.Extensions.AddNodesExtension(node);
// Obtiene el XML de los elementos
AddItems(node, rss.Entries);
// Devuelve los datos
return(file);
}
/// <summary>
/// Convierte los datos de un MLFile en una cadena
/// </summary>
public string ConvertToString(MLFile fileML, bool addHeader = true)
{
// Crea el stringBuilder del archivo
Create(fileML, addHeader);
// Devuelve la cadena
return(_sbXML.ToString());
}
/// <summary>
/// Carga los datos de un proyecto
/// </summary>
internal ProjectModel Load(string fileName)
{
ProjectModel project = new ProjectModel();
MLFile fileML = LoadFile(fileName);
// Asigna el nombre de proyecto (aunque no haya cargado nada)
project.Name = System.IO.Path.GetFileName(System.IO.Path.GetDirectoryName(fileName));
// Carga los datos del proyecto
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
// Carga los datos básicos del proyecto
LoadBase(rootML, project);
// Carga las conexiones y modelos de distribución
project.Connections.AddRange(new ConnectionRepository().LoadConnections(rootML));
project.Deployments.AddRange(new DeploymentRepository().Load(project, rootML));
}
}
}
// Devuelve el proyecto cargado
return(project);
}
/// <summary>
/// Graba las conexiones
/// </summary>
public void Save(JabberManager manager, string fileName)
{
MLFile fileML = new MLFile();
MLNode nodeML = fileML.Nodes.Add(TagRoot);
// Asigna los nodos de las conexión
foreach (JabberConnection connection in manager.Connections)
{
MLNode connectionML = nodeML.Nodes.Add(TagConnection);
MLNode serverML = connectionML.Nodes.Add(TagServer);
MLNode userML = connectionML.Nodes.Add(TagUser);
// Añade los datos del servidor
serverML.Attributes.Add(TagAddress, connection.Host.Address);
serverML.Attributes.Add(TagPort, connection.Host.Port);
serverML.Attributes.Add(TagUseSsl, connection.Host.UseTls);
// Añade los datos del usuario
userML.Attributes.Add(TagAddress, connection.User.Host);
userML.Attributes.Add(TagLogin, connection.User.Login);
userML.Attributes.Add(TagPassword, connection.User.Password);
userML.Attributes.Add(TagServer, connection.User.Status.Status.ToString());
}
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(fileName, fileML);
}
/// <summary>
/// Graba la documentación Nhaml a partir de los datos pasados como parámetros
/// </summary>
public void Save(string strTitle, string strDescription, MLIntermedialBuilder objMLBuilder,
string strFileNameTemplate, string strPath)
{
MLFile objMLFile = GetMLFile(strTitle, strDescription, objMLBuilder.Root);
// Graba el archivo
Save(objMLFile, strPath, LibHelper.Files.HelperFiles.Normalize(strTitle, false) + ".xml");
}
/// <summary>
/// Graba los datos de un MLFile en un archivo
/// </summary>
public void Save(MLFile objMLFile, string strFileName)
{ using (System.IO.StreamWriter stmFile = new System.IO.StreamWriter(strFileName, false, System.Text.Encoding.UTF8))
{ // Escribe la cadena
stmFile.Write(ConverToString(objMLFile));
// Cierra el stream
stmFile.Close();
}
}
/// <summary>
/// Graba la documentación Nhaml en un archivo
/// </summary>
public void Save(DocumentFileModel objDocument, MLIntermedialBuilder objMLBuilder,
string strFileNameTemplate, string strPath)
{
MLFile objMLFile = GetMLFile(objDocument.Name, "", objMLBuilder.Root);
// Graba el archivo
Save(objMLFile, strPath, LibHelper.Files.HelperFiles.Normalize(objDocument.Name, false) + ".xml");
}
/// <summary>
/// Carga los nodos de un archivo XML
/// </summary>
public MLFile Load(XmlDocument objXMLDocument)
{
MLFile objMLFile = new MLFile();
// Carga los nodos
objMLFile.Nodes.Add(LoadNodes(objXMLDocument.ChildNodes));
// Devuelve el archivo
return(objMLFile);
}
/// <summary>
/// Graba los datos de un MLFile en un archivo
/// </summary>
public void Save(MLFile objMLFile, string strFileName)
{
using (System.IO.StreamWriter stmFile = new System.IO.StreamWriter(strFileName, false, System.Text.Encoding.UTF8))
{ // Escribe la cadena
stmFile.Write(ConverToString(objMLFile));
// Cierra el stream
stmFile.Close();
}
}
/// <summary>
/// Graba en un archivo XML una estructura de documentación
/// </summary>
public void Save(string strFileName, StructDocumentationModel objStruct)
{
MLFile objMLFile = new MLFile();
// Añade el nodo de la structura
objMLFile.Nodes.Add(GetStructNode(objStruct));
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(objMLFile, strFileName);
}
/// <summary>
/// Graba un archivo XML
/// </summary>
private void Save(MLFile objMLFile, string strPath)
{
string strFileName = System.IO.Path.Combine(strPath, "Document.dcx");
// Crea el directorio
LibHelper.Files.HelperFiles.MakePath(strPath);
// Graba el archivo de documentación
new LibMarkupLanguage.Services.XML.XMLWriter().Save(objMLFile, strFileName);
}
/// <summary>
/// Carga los nodos de un archivo XML
/// </summary>
public MLFile Load(XmlDocument objXMLDocument)
{
MLFile objMLFile = new MLFile();
// Carga los nodos
objMLFile.Nodes.Add(LoadNodes(objXMLDocument.ChildNodes));
// Devuelve el archivo
return objMLFile;
}
/// <summary>
/// Crea el texto de un archivo
/// </summary>
private void Create(MLFile objFile, bool blnAddHeader)
{ // Limpia el contenido
sbXML = new StringBuilder();
// Añade la cabecera
if (blnAddHeader)
sbXML.Append("<?xml version='1.0' encoding='utf-8'?>" + Environment.NewLine);
// Añade los nodos
Add(0, objFile.Nodes);
}
/// <summary>
/// Graba en un archivo XML una estructura de documentación
/// </summary>
public void Save(string fileName, StructDocumentationModel structDoc)
{
MLFile fileML = new MLFile();
// Añade el nodo de la structura
fileML.Nodes.Add(GetStructNode(structDoc));
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(fileName, fileML);
}
/// <summary>
/// Graba un archivo con los datos de contexto
/// </summary>
internal void Save(List <JobContextModel> contexts, string fileName)
{
MLFile fileML = new MLFile();
MLNode rootML = fileML.Nodes.Add(TagRoot);
// Añade los nodos de contexto
rootML.Nodes.AddRange(GetContextNodes(contexts));
// Graba el archivo
new LibMarkupLanguage.Services.XML.XMLWriter().Save(fileName, fileML);
}
/// <summary>
/// Interpreta un texto
/// </summary>
public MLFile ParseText(string strText)
{ ParserTokenizer objTokenizer = InitTokenizer();
MLFile objMLFile = new MLFile();
// Inicializa el contenido
objTokenizer.Init(strText);
// Interpreta el archivo
objMLFile.Nodes.Add(ParseNode("Root", objTokenizer, true));
// Devuelve el archivo
return objMLFile;
}
/// <summary>
/// Graba los datos de una referencia
/// </summary>
public void Save(ReferenceModel reference)
{
MLFile fileML = new MLFile();
MLNode nodeML = fileML.Nodes.Add(TagRoot);
// Añade el nombre de archivo
nodeML.Nodes.Add(TagPathProject, reference.ProjectName);
nodeML.Nodes.Add(TagFileName, reference.FileNameReference);
// Graba el archivo
new XMLWriter().Save(reference.File.FullFileName, fileML);
}
/// <summary>
/// Crea el texto de un archivo
/// </summary>
private void Create(MLFile objFile, bool blnAddHeader)
{ // Limpia el contenido
sbXML = new StringBuilder();
// Añade la cabecera
if (blnAddHeader)
{
sbXML.Append("<?xml version='1.0' encoding='utf-8'?>" + Environment.NewLine);
}
// Añade los nodos
Add(0, objFile.Nodes);
}
/// <summary>
/// Graba los datos de una solución
/// </summary>
internal void Save(SolutionModel solution)
{
MLFile fileML = new MLFile();
MLNode nodeML = fileML.Nodes.Add(TagSolution);
// Añade las carpetas
nodeML.Nodes.AddRange(GetNodesFolder(solution, solution.Folders));
// Añade los proyectos
nodeML.Nodes.AddRange(GetNodesProject(solution, solution.Projects));
// Graba el archivo XML
new XMLWriter().Save(solution.FullFileName, fileML);
}
/// <summary>
/// Interpreta un texto
/// </summary>
public MLFile ParseText(string text)
{
ParserTokenizer tokenizer = InitTokenizer();
MLFile fileML = new MLFile();
// Inicializa el contenido
tokenizer.Init(text);
// Interpreta el archivo
fileML.Nodes.Add(ParseNode("Root", tokenizer, true));
// Devuelve el archivo
return(fileML);
}
/// <summary>
/// Graba los datos de una solución
/// </summary>
public void Save(SolutionModel solution)
{
MLFile fileML = new MLFile();
MLNode nodeML = fileML.Nodes.Add(TagFilesRoot);
// Añade las carpetas
nodeML.Nodes.AddRange(GetXMLFolderNodes(solution, solution.Folders));
// Añade los proyectos
nodeML.Nodes.AddRange(GetXMLProjectNodes(solution, solution.Projects));
// Graba el archivo
new XMLWriter().Save(solution.FullFileName, fileML);
}
/// <summary>
/// Crea el texto de un archivo
/// </summary>
private void Create(MLFile file, bool addHeader)
{
// Limpia el contenido
_sbXML.Clear();
// Añade la cabecera
if (addHeader)
{
_sbXML.Append("<?xml version='1.0' encoding='utf-8'?>" + Environment.NewLine);
}
// Añade los nodos
Add(0, file.Nodes);
}
/// <summary>
/// Interpreta un texto XML
/// </summary>
public MLFile ParseText(string strText)
{ MLFile objMLFile = new MLFile();
XmlDocument objDocument = new XmlDocument();
// Carga los datos
try
{ // Carga el documento
objDocument.LoadXml(strText);
// Obtiene los nodos
objMLFile = Load(objDocument);
}
catch (Exception objException)
{ throw new ParserException("Error en la interpretación del texto XML", objException);
}
// Devuelve el nodo principal
return objMLFile;
}
/// <summary>
/// Depura un archivo de nodos
/// </summary>
public string Debug(MLFile objMLFile)
{
return Debug(objMLFile.Nodes, 0);
}
