/// <summary>
/// Obtiene los nodos XML de los nodos del árbol
/// </summary>
private MLNodesCollection GetContextTreeNodes(List <TreeNodeModel> nodes)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los nodos del árbol
foreach (TreeNodeModel node in nodes)
{
MLNode nodeML = nodesML.Add(node.Id);
// Añade los atributos
foreach (ParameterModel parameter in node.Attributes)
{
node.Attributes.Add(parameter.Id, parameter.Value);
}
// Añade los nodos hijo
if (node.Nodes.Count == 0)
{
nodeML.Value = node.Value?.ToString();
}
else
{
nodeML.Nodes.AddRange(GetContextTreeNodes(node.Nodes));
}
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Interpreta una cadena sustituyendo los parámetros {{xxxx}} por el valor de la estructura o argumento
/// </summary>
private MLNodesCollection Parse(string value, StructDocumentationModel structDoc)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Interpreta la cadena
while (!value.IsEmpty())
{
string first = value.Cut("{{", out value);
// Añade el nodo con la parte inicial de la cadena
if (!first.IsEmpty())
{
nodesML.Add(Document.MLBuilder.GetSpan(first));
}
// Si queda algo, recoge hasta el siguiente }}
if (!value.IsEmpty())
{
string name = value.Cut("}}", out value).TrimIgnoreNull();
// Procesa el valor
nodesML.Add(GetStructParameterValue(name, structDoc));
}
}
// Devuelve el valor
return(nodesML);
}
/// <summary>
/// Interpreta una cadena sustituyendo los parámetros {{xxxx}} por el valor de la estructura o argumento
/// </summary>
private MLNodesCollection Parse(string strValue, StructDocumentationModel objStruct)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Interpreta la cadena
while (!strValue.IsEmpty())
{
string strFirst = strValue.Cut("{{", out strValue);
// Añade el nodo con la parte inicial de la cadena
if (!strFirst.IsEmpty())
{
objColMLNodes.Add(Document.MLBuilder.GetSpan(strFirst));
}
// Si queda algo, recoge hasta el siguiente }}
if (!strValue.IsEmpty())
{
string strName = strValue.Cut("}}", out strValue).TrimIgnoreNull();
// Procesa el valor
objColMLNodes.Add(GetStructParameterValue(strName, objStruct));
}
}
// Devuelve el valor
return(objColMLNodes);
}
/// <summary>
/// Obtiene una lista de argumentos
/// </summary>
private MLNodesCollection GetListArguments(BaseMethodModel objMethod)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Añade los elementos a la lista
if (objMethod.Arguments != null && objMethod.Arguments.Count > 0)
{
MLNode objMLList;
// Cabecera
objColMLNodes.Add("h4", "Argumentos");
// Lista de elementos
objMLList = objColMLNodes.Add("ul");
foreach (ArgumentModel objArgument in objMethod.Arguments)
{
objMLList.Nodes.Add(MLBuilder.GetListItem(MLBuilder.GetSpan(objArgument.Name, true),
MLBuilder.GetSpan("(" + MLBuilderHelper.GetTypeName(objArgument.Type) + ")", false, true),
MLBuilder.GetSpan(":", true),
MLBuilder.GetSpan(objMethod.RemarksXml.GetParameterRemarks(objArgument.Name))));
}
}
else
{
objColMLNodes.Add("h4", "Sin argumentos");
}
// Devuelve la colección de nodos
return(objColMLNodes);
}
/// <summary>
/// Añade los nodos
/// </summary>
private void Add(int intIndent, MLNodesCollection objColMLNodes)
{
foreach (MLNode objMLNode in objColMLNodes)
{
Add(intIndent, objMLNode);
}
}
/// <summary>
/// Añade los nodos
/// </summary>
private void Add(int indent, MLNodesCollection nodesML)
{
foreach (MLNode nodeML in nodesML)
{
Add(indent, nodeML);
}
}
/// <summary>
/// Trata una serie de nodos
/// </summary>
private void TreatChilds(MLNodesCollection objColMLSource, MLNode objMLParentTarget, LanguageStructModel objStruct)
{
foreach (MLNode objMLSource in objColMLSource)
{
TreatNode(objMLSource, objMLParentTarget, objStruct);
}
}
/// <summary>
/// Obtiene los nodos para los datos de conexión de una solución
/// </summary>
private MLNodesCollection GetConnectionsNodes(SolutionModel solution)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los datos
foreach (ConnectionModel connection in solution.Connections)
{
MLNode nodeML = nodesML.Add(TagConnection);
// Añade los datos
nodeML.Attributes.Add(TagId, connection.GlobalId);
nodeML.Nodes.Add(TagName, connection.Name);
nodeML.Nodes.Add(TagDescription, connection.Description);
nodeML.Attributes.Add(TagType, connection.Type.ToString());
nodeML.Attributes.Add(TagTimeoutExecuteScript, connection.TimeoutExecuteScript.TotalMinutes);
// Añade los parámetros
foreach ((string key, string value) in connection.Parameters.Enumerate())
{
MLNode parameterML = nodeML.Nodes.Add(TagParameter);
// Añade los atributos
parameterML.Attributes.Add(TagName, key);
parameterML.Attributes.Add(TagValue, value);
}
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Interpreta las cabeceras de un archivo OPML
/// </summary>
private void ParseHead(MLNodesCollection nodes, OPMLChannel channel)
{
foreach (MLNode node in nodes)
{
switch (node.Name)
{
case OPMLConstTags.cnsttitle:
channel.Title = node.Value;
break;
case OPMLConstTags.cnstStrDateCreated:
channel.DateCreated = node.Value.GetDateTime(DateTime.Now);
break;
case OPMLConstTags.cnstStrDateModified:
channel.DateModified = node.Value.GetDateTime(DateTime.Now);
break;
case OPMLConstTags.cnstStrOwnerName:
channel.OwnerName = node.Value;
break;
case OPMLConstTags.cnstStrOwnerEMail:
channel.OwnerEMail = node.Value;
break;
}
}
}
/// <summary>
/// Trata una serie de nodos
/// </summary>
private void TreatChilds(MLNodesCollection sourcesML, MLNode parentTargetML, StructDocumentationModel structDoc)
{
foreach (MLNode sourceML in sourcesML)
{
TreatNode(sourceML, parentTargetML, structDoc);
}
}
/// <summary>
/// Obtiene los nodos de parámetros
/// </summary>
internal MLNodesCollection GetParametersNodes(NormalizedDictionary <JobParameterModel> parameters)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los parámetros
foreach ((string key, JobParameterModel parameter) in parameters.Enumerate())
{
MLNode nodeML = nodesML.Add(TagParameter);
// Añade las propiedades
nodeML.Attributes.Add(TagKey, key);
nodeML.Attributes.Add(TagType, parameter.Type.ToString());
nodeML.Attributes.Add(TagValue, parameter.Value?.ToString());
// Añade las propiedades de las fechas
if (parameter.Type == JobParameterModel.ParameterType.DateTime)
{
nodeML.Attributes.Add(TagComputeMode, parameter.DateMode.ToString());
nodeML.Attributes.Add(TagInterval, parameter.Interval.ToString());
nodeML.Attributes.Add(TagIncrement, parameter.Increment);
nodeML.Attributes.Add(TagMode, parameter.Mode.ToString());
}
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Convierte los datos de una colección de nodos en una cadena
/// </summary>
public string ConvertToString(MLNodesCollection objColMLNodes)
{
// Limpia el contenido
sbXML.Clear();
// Añade la información del nodo y sus hijos
Add(0, objColMLNodes);
// Devuelve la cadena
return sbXML.ToString();
}
/// <summary>
/// Convierte los datos de una colección de nodos en una cadena
/// </summary>
public string ConvertToString(MLNodesCollection nodesML)
{
// Limpia el contenido
_sbXML.Clear();
// Añade la información del nodo y sus hijos
Add(0, nodesML);
// Devuelve la cadena
return(_sbXML.ToString());
}
/// <summary>
/// Depura una colección de nodos
/// </summary>
private string Debug(MLNodesCollection objColMLNodes, int intIndent)
{
string strDebug = "";
// Depura los nodos
foreach (MLNode objMLNode in objColMLNodes)
strDebug += Debug(objMLNode, intIndent);
// Devuelve la cadena de depuración
return strDebug;
}
/// <summary>
/// Obtiene el prototipo de una función
/// </summary>
private MLNodesCollection GetMethodPrototype(BaseMethodModel objMethod, bool blnIsAsync = false, TypedModel objReturnType = null)
{
MLNodesCollection objColMLNodes = GetMethodPrototypeDefinition(objMethod, blnIsAsync, objReturnType);
// Añade los argumentos
objColMLNodes.Add(Document.MLBuilder.GetSpan("("));
objColMLNodes.AddRange(GetArgumentsPrototype(objMethod));
objColMLNodes.Add(Document.MLBuilder.GetSpan(")"));
// Devuelve el prototipo
return(objColMLNodes);
}
/// <summary>
/// Depura una colección de nodos
/// </summary>
private string Debug(MLNodesCollection nodesML, int indent)
{
string debug = "";
// Depura los nodos
foreach (MLNode nodeML in nodesML)
{
debug += Debug(nodeML, indent);
}
// Devuelve la cadena de depuración
return(debug);
}
/// <summary>
/// Obtiene los nodos de <see cref="JobStepModel"/>
/// </summary>
private MLNodesCollection GetStepNodes(BaseExtendedModelCollection <JobStepModel> steps)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Crea la colección de nodos con los pasos
foreach (JobStepModel step in steps)
{
nodesML.Add(GetStepNode(step));
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Obtiene los nodos con las carpetas de una solución
/// </summary>
private MLNodesCollection GetFoldersNodes(SolutionModel solution)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los datos
foreach (string folder in solution.Folders)
{
nodesML.Add(TagFolder, folder);
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Obtiene los nodos de archivo
/// </summary>
private MLNodesCollection GetFileNodes(string tag, Model.Solutions.FilesModelCollection files)
{
MLNodesCollection nodes = new MLNodesCollection();
// Añade los archivos a los nodos
foreach (Model.Solutions.FileModel file in files)
{
nodes.Add(tag, file.IDFileName);
}
// Devuelve la colección de nodos
return(nodes);
}
/// <summary>
/// Interpreta las entradas de un archivo XML
/// </summary>
private void ParseEntries(MLNodesCollection nodes, OPMLEntriesCollection entries)
{
foreach (MLNode node in nodes)
{
switch (node.Name)
{
case OPMLConstTags.cnstStrOutline:
entries.Add(ParseEntry(node));
break;
}
}
}
/// <summary>
/// Obtiene los nodos de los projectos
/// </summary>
internal MLNodesCollection GetXMLProjectNodes(SolutionModel solution, ProjectsModelCollection projects)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Rellena los nodos
foreach (ProjectModel project in projects)
{
nodesML.Add(SolutionRepository.TagFile, GetPathRelative(solution, project));
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Trata una serie de nodos para un argumento
/// </summary>
private void TreatChilds(MLNodesCollection objColMLSource, MLNode objMLParentTarget, LanguageStructModel objStruct, ArgumentModel objArgument)
{
foreach (MLNode objMLSource in objColMLSource)
{
MLNode objMLTarget = CloneNode(objMLSource, objStruct, objArgument);
// Añade el nodo
objMLParentTarget.Nodes.Add(objMLTarget);
// Trata los hijos
TreatChilds(objMLSource.Nodes, objMLTarget, objStruct, objArgument);
}
}
/// <summary>
/// Carga una colección de nodos
/// </summary>
private MLNodesCollection LoadNodes(XmlNodeList objColXMLNodes)
{
MLNodesCollection objColNodes = new MLNodesCollection();
// Lee los nodos
foreach (XmlNode objXMLNode in objColXMLNodes)
{
if (MustInclude(objXMLNode))
{
objColNodes.Add(LoadNode(objXMLNode));
}
}
// Devuelve la colección de nodos
return(objColNodes);
}
/// <summary>
/// Obtiene los nodos de la cola de parámetros de conexión
/// </summary>
private MLNodesCollection GetQueueConnectionsNodes(SolutionModel solution)
{
MLNodesCollection nodes = new MLNodesCollection();
// Añade los nodos con os parámetrosde la cola
foreach (string connectionParameters in solution.QueueConnectionParameters.Enumerate())
{
if (!string.IsNullOrWhiteSpace(connectionParameters))
{
nodes.Add(new MLNode(TagQueueJsonParameters, connectionParameters));
}
}
// Devuelve la colección de nodos
return(nodes);
}
/// <summary>
/// Obtiene los nodos de las conexiones
/// </summary>
internal MLNodesCollection GetMLConnections(ConnectionModelCollection connections)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Agrega los nodos
foreach (AbstractConnectionModel baseConnection in connections)
{
switch (baseConnection)
{
case DatabaseConnectionModel connection:
nodesML.Add(GetMLConnection(connection));
break;
}
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Obtiene los nodos de scripts
/// </summary>
private MLNodesCollection GetMLScripts(BaseModelCollection <ScriptModel> scripts)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los scripts
foreach (ScriptModel script in scripts)
{
MLNode nodeML = nodesML.Add(TagScript);
// Añade las propiedades
nodeML.Attributes.Add(TagFile, script.RelativeFileName);
// Añade los parámetros
nodeML.Nodes.AddRange(GetMLParameters(script.Parameters));
}
// Devuelve los nodos
return(nodesML);
}
/// <summary>
/// Obtiene los nodos de una serie de parámetros
/// </summary>
private MLNodesCollection GetNodesParameters(System.Collections.Generic.List <DataSourceSqlParameterModel> parameters)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los parámetros
foreach (DataSourceSqlParameterModel parameter in parameters)
{
MLNode nodeML = nodesML.Add(TagParameter);
// Asigna los atributos
nodeML.Attributes.Add(TagName, parameter.Name);
nodeML.Attributes.Add(TagType, parameter.Type.ToString());
nodeML.Attributes.Add(TagValue, parameter.DefaultValue);
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Obtiene los nodos de parámetros
/// </summary>
private MLNodesCollection GetMLParameters(BaseModelCollection <ParameterModel> parameters)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los parámetros
foreach (ParameterModel parameter in parameters)
{
MLNode nodeML = nodesML.Add(TagParameter);
// Añade las propiedades
nodeML.Attributes.Add(TagId, parameter.GlobalId);
nodeML.Attributes.Add(TagType, parameter.Type.ToString());
nodeML.Value = parameter.Value;
}
// Devuelve la colección de parámetros
return(nodesML);
}
/// <summary>
/// Obtiene el prototipo de un método Get o Set de una propiedad
/// </summary>
private MLNodesCollection GetPropertyMethodPrototype(LanguageStructModel.ModifierType intModifier, MethodModel objMethod, string strMethodName)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Añade los datos al prototipo
if (objMethod != null)
{ // Añade el modificador (si es distinto al de la propiedad, es decir: public Property { private set }
if (intModifier != objMethod.Modifier)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan(GetModifierText(objMethod.Modifier)));
}
// Añade el nombre
objColMLNodes.Add(Document.MLBuilder.GetSpan(strMethodName + ";"));
}
// Devuelve el prototipo
return(objColMLNodes);
}
/// <summary>
/// Obtiene los argumentos para un prototipo
/// </summary>
private MLNodesCollection GetArgumentsPrototype(BaseMethodModel objMethod)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Añade la cadena con los argumentos
for (int intIndex = 0; intIndex < objMethod.Arguments.Count; intIndex++)
{ // Añade los nodos de los argumentos
objColMLNodes.AddRange(GetArgumentData(objMethod.Arguments[intIndex]));
// Añade un nodo de separación
if (intIndex < objMethod.Arguments.Count - 1)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan(","));
}
}
// Devuelve los argumentos
return(objColMLNodes);
}
/// <summary>
/// Obtiene los nodos de storage
/// </summary>
private MLNodesCollection GetStoragesNodes(SolutionModel solution)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los nodos
foreach (Models.Cloud.StorageModel storage in solution.Storages)
{
MLNode nodeML = nodesML.Add(TagStorage);
// Añade las propiedades
nodeML.Attributes.Add(TagId, storage.GlobalId);
nodeML.Nodes.Add(TagName, storage.Name);
nodeML.Nodes.Add(TagDescription, storage.Description);
nodeML.Nodes.Add(TagConnectionSring, storage.StorageConnectionString);
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Obtiene los nodos de las categorías
/// </summary>
private MLNodesCollection GetCategoriesNodes(CategoryModelCollection categories)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Crea los nodos
foreach (CategoryModel category in categories)
{
MLNode nodeML = nodesML.Add(TagCategory);
// Asigna las propiedades
nodeML.Attributes.Add(TagId, category.Id);
nodeML.Nodes.Add(TagName, category.Title);
// Añade las entradas
nodeML.Nodes.AddRange(GetEntriesNodes(category.Entries));
}
// Devuelve la colección
return(nodesML);
}
/// <summary>
/// Carga una colección de nodos
/// </summary>
private MLNodesCollection LoadNodes(XmlNodeList objColXMLNodes)
{ MLNodesCollection objColNodes = new MLNodesCollection();
// Lee los nodos
foreach (XmlNode objXMLNode in objColXMLNodes)
if (MustInclude(objXMLNode))
objColNodes.Add(LoadNode(objXMLNode));
// Devuelve la colección de nodos
return objColNodes;
}
public MLNode(string strName, string strValue) : base(strName, strValue)
{ Attributes = new MLAttributesCollection();
Nodes = new MLNodesCollection();
NameSpaces = new MLNameSpacesCollection();
}
/// <summary>
/// Interpreta los usuarios de un nodo
/// </summary>
private static void ParseUsers(MLNodesCollection objMLColNodes, UsersCollection objColUsers)
{
foreach (MLNode objMLChild in objMLColNodes)
if (objMLChild.Name.Equals(cnstStrTagUser))
objColUsers.Add(Parse(objMLChild));
else if (objMLChild.Name.Equals(cnstStrTagNextCursor))
objColUsers.NextCursor = objMLChild.Value;
else if (objMLChild.Name.Equals(cnstStrTagPreviousCursor))
objColUsers.PreviousCursor = objMLChild.Value;
}
/// <summary>
/// Añade los nodos
/// </summary>
private void Add(int intIndent, MLNodesCollection objColMLNodes)
{
foreach (MLNode objMLNode in objColMLNodes)
Add(intIndent, objMLNode);
}
public MLFile()
{ Encoding = EncodingMode.UTF8;
Version = "1.0";
Nodes = new MLNodesCollection();
}