/// <summary>
/// Carga los archivos asociados al proyecto
/// </summary>
internal void LoadFiles()
{ if (File.Exists(FullFileNameSource))
{ MLFile objMLFile = new LibMarkupLanguage.Services.XML.XMLParser().Load(FullFileNameSource);
// Carga los datos
foreach (MLNode objMLRoot in objMLFile.Nodes)
if (objMLRoot.Name == "Project")
foreach (MLNode objMLNode in objMLRoot.Nodes)
if (objMLNode.Name == "ItemGroup")
foreach (MLNode objMLChild in objMLNode.Nodes)
if (objMLChild.Name == "Compile")
{ string strFile = objMLChild.Attributes["Include"].Value;
if (!strFile.IsEmpty())
{ FileVisualStudioModel objFile = new FileVisualStudioModel();
// Asigna el archivo
objFile.FileName = strFile;
objFile.FullFileName = Path.Combine(Path.GetDirectoryName(FullFileNameSource), strFile);
// Añade el archivo a la colección
Files.Add(objFile);
}
}
}
}
/// <summary>
/// Carga un archivo
/// </summary>
internal void Load(string fileName)
{
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
if (fileML != null)
{
// Carga los archivos
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagFile)
{
string file = nodeML.Value.TrimIgnoreNull();
if (!string.IsNullOrWhiteSpace(fileName) && System.IO.File.Exists(file))
{
Manager.ReportingSolution.Files.Add(file);
}
}
}
}
}
}
}
}
/// <summary>
/// Carga el archivo de definición de plantillas
/// </summary>
internal TemplateModelCollection Load(string strFileName)
{
TemplateModelCollection objColTemplates = new TemplateModelCollection(System.IO.Path.GetDirectoryName(strFileName));
// Carga las plantillas
if (System.IO.File.Exists(strFileName))
{
MLFile objMLFile = new LibMarkupLanguage.Services.XML.XMLParser().Load(strFileName);
foreach (MLNode objMLRoot in objMLFile.Nodes)
{
if (objMLRoot.Name == "Templates")
{
foreach (MLNode objMLTemplate in objMLRoot.Nodes)
{
if (objMLTemplate.Name == "Page")
{
LanguageStructModel.StructType intIDType = GetLanguageStruct(objMLTemplate.Attributes["StructType"].Value);
string strRelativeFileName = objMLTemplate.Attributes["File"].Value;
string strRootTemplate = objMLTemplate.Attributes["RootTemplate"].Value;
if (intIDType != LanguageStructModel.StructType.Unknown && !strRelativeFileName.IsEmpty())
{
objColTemplates.Add(intIDType, strRelativeFileName, strRootTemplate);
}
}
}
}
}
}
// Devuelve la colección de plantillas
return(objColTemplates);
}
/// <summary>
/// Carga un archivo
/// </summary>
internal List <string> Load(string fileName)
{
List <string> folders = new List <string>();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
// Carga el archivo
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode nodeML in rootML.Nodes)
{
switch (nodeML.Name)
{
case TagFolder:
string folder = nodeML.Attributes[TagPath].Value.TrimIgnoreNull();
if (!string.IsNullOrWhiteSpace(folder))
{
folders.Add(folder);
}
break;
}
}
}
}
}
// Devuelve las carpetas leidas
return(folders);
}
/// <summary>
/// Carga un archivo de canales
/// </summary>
public TrackModelCollection LoadTracks(string xml)
{
TrackModelCollection tracks = new TrackModelCollection();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().ParseText(xml);
// Carga el archivo
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode trackML in rootML.Nodes)
{
if (trackML.Name == TagTrack)
{
TrackModel track = new TrackModel();
// Carga los datos
track.Title = trackML.Nodes[TagName].Value;
track.Description = trackML.Nodes[TagDescription].Value;
track.Url = trackML.Nodes[TagUrl].Value;
// Añade el canal al nodo
if (!track.Url.IsEmpty())
{
tracks.Add(track);
}
}
}
}
}
}
// Devuelve los canales
return(tracks);
}
/// <summary>
/// Carga las entradas de una categoría
/// </summary>
internal EntryModelCollection LoadCategoryEntries(string xml)
{
EntryModelCollection entries = new EntryModelCollection();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().ParseText(xml);
// Carga el archivo
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagConference)
{
EntryModel entry = LoadEntry(nodeML);
// Añade el artículo a la colección
if (!entry.Title.IsEmpty())
{
entries.Add(entry);
}
}
}
}
}
}
// Devuelve la colección de artículos
return(entries);
}
/// <summary>
/// Carga las entradas de un archivo
/// </summary>
internal List <TrackManagerModel> Load(string fileName)
{
List <TrackManagerModel> trackManagers = new List <TrackManagerModel>();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
// Carga las entradas
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagTrackManager)
{
TrackManagerModel manager = new TrackManagerModel();
// Carga los datos
manager.Id = nodeML.Attributes[TagId].Value;
manager.Title = nodeML.Nodes[TagName].Value;
manager.Path = nodeML.Nodes[TagPath].Value;
// Carga los canales
manager.Tracks.AddRange(LoadTracks(nodeML));
// Añade el manager a la colección
trackManagers.Add(manager);
}
}
}
}
}
// Devuelve los objetos
return(trackManagers);
}
/// <summary>
/// Carga los datos de una solución
/// </summary>
internal SolutionModel Load(string fileName)
{
SolutionModel solution = new SolutionModel();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
// Carga los datos de la solución
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
// Asigna las propiedades
solution.FileName = fileName;
solution.GlobalId = rootML.Attributes[TagId].Value;
solution.Name = rootML.Nodes[TagName].Value.TrimIgnoreNull();
solution.Description = rootML.Nodes[TagDescription].Value.TrimIgnoreNull();
solution.LastParametersFileName = rootML.Nodes[TagFileParameters].Value.TrimIgnoreNull();
// Carga los objetos
LoadConnections(solution, rootML);
LoadDeployments(solution, rootML);
LoadStorages(solution, rootML);
LoadFolders(solution, rootML);
}
}
}
// Devuelve la solución
return(solution);
}
/// <summary>
/// Carga el archivo de parámetros
/// </summary>
internal (List <DatabaseConnectionModel> connections, string parameters) Load(string fileName)
{
(List <DatabaseConnectionModel> connections, string parameters)result = (new List <DatabaseConnectionModel>(), string.Empty);
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
// Lee los datos
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode nodeML in rootML.Nodes)
{
switch (nodeML.Name)
{
case TagDataBaseConnection:
result.connections.Add(LoadConnection(nodeML));
break;
case TagParameters:
result.parameters = nodeML.Value;
break;
}
}
}
}
}
// Devuelve el resultado
return(result);
}
/// <summary>
/// Carga las estructuras de documentación de un archivo
/// </summary>
public StructDocumentationModel Load(string fileName)
{
StructDocumentationModel structDoc = new StructDocumentationModel(null, StructDocumentationModel.ScopeType.Global, "", "", 0);
// Carga el archivo XML
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == TagStruct)
{
// Interpreta el elemento
LoadStruct(nodeML, structDoc);
// Interpreta los hijos
LoadChilds(nodeML, structDoc);
// Interpreta los parámetros
LoadParameters(nodeML, structDoc);
}
}
}
// Devuelve la estructura
return(structDoc);
}
/// <summary>
/// Carga una serie de canales de una cadena XML
/// </summary>
public TrackModelCollection LoadTracks(string xml)
{
TrackModelCollection tracks = new TrackModelCollection();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().ParseText(xml);
// Carga los datos
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == TagRoot)
{
foreach (MLNode trackML in nodeML.Nodes)
{
if (trackML.Name == TagTrack)
{
TrackModel track = new TrackModel();
// Carga los datos de la carpeta
track.Title = trackML.Nodes[TagName].Value;
track.Description = trackML.Nodes[TagDescription].Value;
track.Url = trackML.Nodes[TagUrl].Value;
track.DateLastDownload = trackML.Attributes[TagDateLastDownload].Value.GetDateTime(DateTime.Now.AddDays(-2));
track.DateLastError = trackML.Attributes[TagDateLastError].Value.GetDateTime();
track.Enabled = trackML.Attributes[TagEnabled].Value.GetBool(true);
track.IsLoaded = false;
// Carga las categorías del canal
foreach (MLNode channelML in trackML.Nodes)
{
if (channelML.Name == TagCategory)
{
CategoryModel category = new CategoryModel(track);
// Carga los datos
category.Id = channelML.Attributes[TagId].Value;
category.IsDeleted = channelML.Attributes[TagDeleted].Value.GetBool();
category.Title = channelML.Nodes[TagName].Value;
// Añade el canal a la categoría
track.Categories.Add(category);
}
}
// Añade las categorías a la colección
if (!track.Url.IsEmpty())
{
tracks.Add(track);
}
}
}
}
}
}
// Devuelve las categorías
return(tracks);
}
/// <summary>
/// Carga las conexiones
/// </summary>
public void Load(JabberManager manager, string fileName)
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
// Carga los datos
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == TagRoot)
{
foreach (MLNode connectionML in nodeML.Nodes)
{
if (connectionML.Name == TagConnection)
{
JabberServer server = null;
JabberUser user = null;
// Carga los datos del servidor
foreach (MLNode serverML in connectionML.Nodes)
{
if (serverML.Name == TagServer)
{
server = new JabberServer(serverML.Attributes[TagAddress].Value,
serverML.Attributes[TagPort].Value.GetInt(5222),
serverML.Attributes[TagUseSsl].Value.GetBool(true));
}
}
// Carga los datos del usuario
foreach (MLNode userML in connectionML.Nodes)
{
if (userML.Name == TagUser)
{
// Crea el usuario
user = new JabberUser(userML.Attributes[TagAddress].Value,
userML.Attributes[TagLogin].Value,
userML.Attributes[TagPassword].Value);
// Y le asigna el estado
user.Status.Status = userML.Attributes[TagStatus].Value.GetEnum(JabberContactStatus.Availability.Offline);
}
}
// Añade la conexión
if (server != null && user != null)
{
manager.AddConnection(server, user);
}
}
}
}
}
}
}
/// <summary>
/// Carga un archivo de recursos
/// </summary>
private void LoadFileResource(string fileName, ComicModel comic)
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == ComicRepositoryConstants.TagResources)
{
LoadResources(nodeML, comic);
}
}
}
}
/// <summary>
/// Carga los datos de un <see cref="DataWarehouseModel"/>
/// </summary>
internal DataWarehouseModel Load(ReportingSchemaModel schema, string fileName)
{
DataWarehouseModel dataWarehouse = new DataWarehouseModel(schema);
// Carga los datos
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
// Asigna las propiedades
dataWarehouse.Id = rootML.Attributes[TagId].Value.TrimIgnoreNull();
dataWarehouse.Name = rootML.Nodes[TagName].Value.TrimIgnoreNull();
dataWarehouse.Description = rootML.Nodes[TagDescription].Value.TrimIgnoreNull();
// Carga las dimensiones y orígenes de datos
foreach (MLNode nodeML in rootML.Nodes)
{
switch (nodeML.Name)
{
case TagDataSourceTable:
dataWarehouse.DataSources.Add(LoadDataSourceTable(dataWarehouse, nodeML));
break;
case TagDataSourceSql:
dataWarehouse.DataSources.Add(LoadDataSourceSql(dataWarehouse, nodeML));
break;
case TagDimension:
dataWarehouse.Dimensions.Add(LoadDimension(nodeML, dataWarehouse));
break;
case TagReport:
dataWarehouse.Reports.Add(LoadReport(nodeML, dataWarehouse));
break;
}
}
}
}
}
}
// Devuelve los datos del almacén de datos
return(dataWarehouse);
}
/// <summary>
/// Carga los datos de un cómic
/// </summary>
internal ComicModel Load(string path, string fileName, bool loadFull)
{
ComicModel comic = new ComicModel(path);
string strFullFileName = System.IO.Path.Combine(path, fileName);
ComicReaderMediator mediator = new ComicReaderMediator();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(strFullFileName);
// Recorre los nodos
if (fileML != null)
{
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == ComicRepositoryConstants.TagRoot)
{
// Obtiene el ancho y el alto
comic.Width = nodeML.Attributes[ComicRepositoryConstants.TagWidth].Value.GetInt(1000);
comic.Height = nodeML.Attributes[ComicRepositoryConstants.TagHeight].Value.GetInt(1000);
// Asigna las propiedades básicas del cómic
comic.Title = nodeML.Nodes[ComicRepositoryConstants.TagTitle].Value.TrimIgnoreNull();
comic.Summary = nodeML.Nodes[ComicRepositoryConstants.TagSummary].Value.TrimIgnoreNull();
comic.ThumbFileName = nodeML.Nodes[ComicRepositoryConstants.TagThumbFileName].Value.TrimIgnoreNull();
// Obtiene los componentes del cómic
if (loadFull)
{
foreach (MLNode childML in nodeML.Nodes)
{
switch (childML.Name)
{
case ComicRepositoryConstants.TagInclude:
case ComicRepositoryConstants.TagResources:
mediator.ResourcesRepository.LoadResources(path, childML, comic);
break;
case ComicRepositoryConstants.TagPage:
mediator.PagesRepository.LoadPage(childML, comic);
break;
}
}
}
// Carga los idiomas (aunque no sea una carga completa)
LoadLanguage(comic, nodeML);
}
}
}
// Devuelve el cómic cargado
return(comic);
}
/// <summary>
/// Procesa el documento
/// </summary>
internal void Process()
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(Template.FullFileName);
// Limpia el generador
Document.MLBuilder.Clear();
// Añade la estructura a la colección de estructuras generadas
Document.StructsReferenced.Add(Document.LanguageStruct);
// Recorre los datos del archivo generando la salida
foreach (MLNode sourceML in fileML.Nodes)
{
if (sourceML.Name == Document.MLBuilder.Root.Name)
{
TreatChilds(sourceML.Nodes, Document.MLBuilder.Root, Document.LanguageStruct);
}
}
}
/// <summary>
/// Carga un archivo
/// </summary>
protected MLFile LoadFile(string fileName)
{
MLFile fileML = null;
// Carga el archivo
if (System.IO.File.Exists(fileName))
{
try
{
fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
}
catch (Exception exception)
{
System.Diagnostics.Trace.TraceError($"Error al cargar el archivo {fileName}. {exception.Message}");
}
}
// Devuelve el archivo cargado
return(fileML);
}
/// <summary>
/// Carga los datos de un trabajo
/// </summary>
internal JobModel Load(string fileName)
{
JobModel job = new JobModel();
// Carga los datos del archivo
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
// Carga los parámetros básicos
job.Name = rootML.Nodes[TagName].Value;
job.Description = rootML.Nodes[TagDescription].Value;
// Carga el resto de parámetros
foreach (MLNode nodeML in rootML.Nodes)
{
switch (nodeML.Name)
{
case TagBlock:
job.Steps.Add(LoadBlock(job, nodeML));
break;
case TagStep:
job.Steps.Add(LoadStep(job, nodeML));
break;
case TagParameter:
LoadParameter(nodeML, job.Parameters);
break;
}
}
}
}
}
}
// Devuelve los datos del trabajo
return(job);
}
/// <summary>
/// Carga el archivo de definición de plantillas
/// </summary>
internal TemplateModelCollection Load(string strPathTemplates)
{
TemplateModelCollection objColTemplates = new TemplateModelCollection(strPathTemplates);
string strFileName = System.IO.Path.Combine(strPathTemplates, "Templates.tpt");
// Carga las plantillas
if (System.IO.File.Exists(strFileName))
{
MLFile objMLFile = new LibMarkupLanguage.Services.XML.XMLParser().Load(strFileName);
foreach (MLNode objMLRoot in objMLFile.Nodes)
{
if (objMLRoot.Name == "Templates")
{
foreach (MLNode objMLTemplate in objMLRoot.Nodes)
{
if (objMLTemplate.Name == "Page" || objMLTemplate.Name == "Index")
{
TemplateModel.TemplateType intIDType = TemplateModel.TemplateType.Page;
string strName = objMLTemplate.Attributes["Name"].Value;
string strStructType = objMLTemplate.Attributes["StructType"].Value;
string strRelativeFileName = objMLTemplate.Attributes["File"].Value;
string strRootTemplate = objMLTemplate.Attributes["RootTemplate"].Value;
// Asigna el tipo de plantilla de los índices
if (objMLTemplate.Name == "Index")
{
intIDType = TemplateModel.TemplateType.Index;
}
// Devuelve el tipo de plantilla
if ((intIDType == TemplateModel.TemplateType.Index || !strStructType.IsEmpty()) && !strRelativeFileName.IsEmpty())
{
objColTemplates.Add(intIDType, strName, strStructType, strRelativeFileName, strRootTemplate);
}
}
}
}
}
}
// Devuelve la colección de plantillas
return(objColTemplates);
}
/// <summary>
/// Carga el archivo de definición de plantillas
/// </summary>
internal TemplateModelCollection Load(string pathTemplates)
{
TemplateModelCollection templates = new TemplateModelCollection(pathTemplates);
string fileName = System.IO.Path.Combine(pathTemplates, "Templates.tpt");
// Carga las plantillas
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == "Templates")
{
foreach (MLNode templateML in rootML.Nodes)
{
if (templateML.Name == "Page" || templateML.Name == "Index")
{
TemplateModel.TemplateType type = TemplateModel.TemplateType.Page;
string name = templateML.Attributes["Name"].Value;
string structType = templateML.Attributes["StructType"].Value;
string relativeFileName = templateML.Attributes["File"].Value;
string rootTemplate = templateML.Attributes["RootTemplate"].Value;
// Asigna el tipo de plantilla de los índices
if (templateML.Name == "Index")
{
type = TemplateModel.TemplateType.Index;
}
// Devuelve el tipo de plantilla
if ((type == TemplateModel.TemplateType.Index || !structType.IsEmpty()) && !relativeFileName.IsEmpty())
{
templates.Add(type, name, structType, relativeFileName, rootTemplate);
}
}
}
}
}
}
// Devuelve la colección de plantillas
return(templates);
}
/// <summary>
/// Carga los datos de un <see cref="JobProjectModel"/>
/// </summary>
internal JobProjectModel Load(string fileName)
{
JobProjectModel project = new JobProjectModel(System.IO.Path.GetDirectoryName(fileName));
// Carga los datos del archivo
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
// Obtiene los nodos
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
// Asigna el nombre del proyecto
project.Name = rootML.Nodes[TagName].Value.TrimIgnoreNull();
project.Description = rootML.Nodes[TagDescription].Value.TrimIgnoreNull();
// Carga los contextos
project.Contexts.AddRange(new JobContextRepository().LoadContexts(rootML));
// Carga los trabajos
foreach (MLNode nodeML in rootML.Nodes)
{
switch (nodeML.Name)
{
case TagStep:
project.Jobs.Add(LoadStep(nodeML, project, null));
break;
}
}
}
}
}
}
// Asigna el directorio de trabajo del contexto
project.ContextWorkPath = project.ProjectWorkPath;
// Devuelve los datos del proyecto
return(project);
}
/// <summary>
/// Carga las categorías de un canal
/// </summary>
internal CategoryModelCollection LoadCategories(TrackModel track, string xml)
{
CategoryModelCollection categories = new CategoryModelCollection();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().ParseText(xml);
// Carga el archivo
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode categoryML in rootML.Nodes)
{
if (categoryML.Name == TagCategory)
{
CategoryModel category = new CategoryModel(track);
// Asigna las propiedades
category.Id = categoryML.Attributes[TagId].Value;
category.Title = categoryML.Nodes[TagName].Value;
// Carga las entradas
foreach (MLNode nodeML in categoryML.Nodes)
{
if (nodeML.Name == EntriesRepository.TagConference)
{
category.Entries.Add(new EntriesRepository().LoadEntry(nodeML));
}
}
// Añade la categoría a la colección
categories.Add(category);
}
}
}
}
}
// Devuelve la colección de categorías
return(categories);
}
/// <summary>
/// Carga los archivos de proyecto (en Net Framework, los archivos de proyecto están bajo el nodo ItemGroup)
/// </summary>
private FileVisualStudioModelCollection LoadFilesProject(string projectFileName)
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(projectFileName);
FileVisualStudioModelCollection files = new FileVisualStudioModelCollection();
// Carga los datos
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == "Project")
{
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == "ItemGroup")
{
foreach (MLNode childML in nodeML.Nodes)
{
if (childML.Name == "Compile")
{
string fileName = childML.Attributes["Include"].Value;
if (!fileName.IsEmpty())
{
FileVisualStudioModel file = new FileVisualStudioModel();
// Asigna el archivo
file.FileName = fileName;
file.FullFileName = Path.Combine(Path.GetDirectoryName(FullFileNameSource), fileName);
// Añade el archivo a la colección
files.Add(file);
}
}
}
}
}
}
}
// Devuelve la colección de archivos
return(files);
}
/// <summary>
/// Carga el texto de una plantilla raíz
/// </summary>
internal string LoadTextRootTemplate(string strFileName)
{
string strText = "";
// Carga los datos de la plantilla
if (System.IO.File.Exists(strFileName))
{
try
{ MLFile objMLFile = new LibMarkupLanguage.Services.XML.XMLParser().Load(strFileName);
foreach (MLNode objMLNode in objMLFile.Nodes)
{
if (objMLNode.Name == "Page")
{
strText = objMLNode.Value;
}
}
}
catch {}
}
// Devuelve el texto
return(strText);
}
/// <summary>
/// Carga los datos del proceso
/// </summary>
internal List <BaseSentence> Load(string fileName)
{
List <BaseSentence> program = new List <BaseSentence>();
// Carga los datos
if (!string.IsNullOrWhiteSpace(fileName) && System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
program.AddRange(LoadSentences(rootML));
}
}
}
}
// Devuelve las instrucciones
return(program);
}
/// <summary>
/// Carga los datos de una serie de <see cref="JobContextModel"/>
/// </summary>
internal List <JobContextModel> Load(string fileName)
{
List <JobContextModel> contexts = new List <JobContextModel>();
// Carga los datos del archivo
if (System.IO.File.Exists(fileName))
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
contexts.AddRange(LoadContexts(rootML));
}
}
}
}
// Devuelve los datos de contexto
return(contexts);
}
/// <summary>
/// Carga las entradas de un archivo
/// </summary>
internal EntryModelCollection Load(string fileName)
{
EntryModelCollection entries = new EntryModelCollection();
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
// Carga las entradas
if (fileML != null)
{
foreach (MLNode rootML in fileML.Nodes)
{
if (rootML.Name == TagRoot)
{
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagEntry)
{
EntryModel entry = new EntryModel();
// Carga los datos
entry.PublishedAt = nodeML.Attributes[TagPublish].Value.GetDateTime(DateTime.Now);
entry.Title = nodeML.Nodes[TagTitle].Value;
entry.UrlVideo = nodeML.Nodes[TagUrl].Value;
entry.Summary = nodeML.Nodes[TagSummary].Value;
entry.Authors = nodeML.Nodes[TagAuthor].Value;
// Añade la entrada a la colección
if (!string.IsNullOrWhiteSpace(entry.UrlVideo))
{
entries.Add(entry);
}
}
}
}
}
}
// Devuelve los objetos
return(entries);
}
/// <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 el texto de una plantilla raíz
/// </summary>
internal string LoadTextRootTemplate(string fileName)
{
string text = string.Empty;
// Carga los datos de la plantilla
if (System.IO.File.Exists(fileName))
{
try
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(fileName);
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == "Page")
{
text = nodeML.Value;
}
}
}
catch { }
}
// Devuelve el texto
return(text);
}
/// <summary>
/// Interpreta el contenido de una página
/// </summary>
private StructDocumentationModel ParseFile(StructDocumentationModel parent, string file)
{
StructDocumentationModel structDoc = new StructDocumentationModel(parent, StructDocumentationModel.ScopeType.Public,
System.IO.Path.GetFileNameWithoutExtension(file),
StructType, 0);
// Carga la página
try
{
MLFile fileML = new LibMarkupLanguage.Services.XML.XMLParser().Load(file);
foreach (MLNode nodeML in fileML.Nodes)
{
if (nodeML.Name == "Page")
{
foreach (MLNode childML in nodeML.Nodes)
{
if (childML.Name == "Title")
{
structDoc.Name = childML.Value;
}
else
{
structDoc.Parameters.Add(CreateParameter(structDoc, childML.Name, childML));
}
}
}
}
}
catch (Exception exception)
{
structDoc.Parameters.Add("Content", $"Excepción al documentar {file}. Excepción: {exception.Message}");
}
// Devuelve la estructura
return(structDoc);
}
