/// <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>
/// 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>
/// 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>
/// 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>
/// 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>
/// 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>
/// 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>
/// 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 el prototipo de una propiedad
/// </summary>
private MLNodesCollection GetPropertyPrototype(PropertyModel objProperty)
{
MLNodesCollection objColMLNodes = GetMethodPrototypeDefinition(objProperty, false, objProperty.GetMethod.ReturnType);
// Argumentos
if (objProperty.Arguments.Count > 0)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("["));
objColMLNodes.AddRange(GetArgumentsPrototype(objProperty));
objColMLNodes.Add(Document.MLBuilder.GetSpan("]"));
}
// Get y set
objColMLNodes.Add(Document.MLBuilder.GetSpan("{"));
objColMLNodes.AddRange(GetPropertyMethodPrototype(objProperty.Modifier, objProperty.GetMethod, "get"));
objColMLNodes.AddRange(GetPropertyMethodPrototype(objProperty.Modifier, objProperty.SetMethod, "set"));
objColMLNodes.Add(Document.MLBuilder.GetSpan("}"));
// Devuelve el prototipo
return(objColMLNodes);
}
/// <summary>
/// Obtiene los nodos de un contexto
/// </summary>
internal MLNodesCollection GetContextNodes(List <JobContextModel> contexts)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Obtiene los nodos
foreach (JobContextModel context in contexts)
{
if (context.ProcessorKey.Equals(JobProjectModel.GlobalContext, StringComparison.CurrentCultureIgnoreCase))
{
nodesML.Add(GetContextNode(TagGlobalContext, string.Empty, context));
}
else
{
nodesML.Add(GetContextNode(TagContext, context.ProcessorKey, context));
}
}
// Devuelve los nodos
return(nodesML);
}
/// <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 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>
/// 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 una cadena sustituyendo los parámetros {{xxxx}} por el valor de la estructura o argumento
/// </summary>
private MLNodesCollection Parse(string strValue, LanguageStructModel objStruct, ArgumentModel objArgument)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Interpreta la cadena
while (!strValue.IsEmpty())
{ // Quita hasta el primer {{ que se encuentra
objColMLNodes.Add(Document.MLBuilder.GetSpan(strValue.Cut("{{", out strValue)));
// Si queda algo, recoge hasta el siguiente }}
if (!strValue.IsEmpty())
{
string strName = strValue.Cut("}}", out strValue).TrimIgnoreNull();
bool blnIsLink = false;
// Comprueba si es un vínculo
if (!strName.IsEmpty() && strName.EndsWith("|Link", StringComparison.CurrentCultureIgnoreCase))
{
string strFiller;
// Indica que es un vínculo
blnIsLink = true;
// Quita el vínculo (|Link) del nombre
strName = strName.Cut("|", out strFiller);
}
// Procesa el valor
if (objArgument == null)
{
objColMLNodes.Add(GetStructValue(strName, blnIsLink, objStruct as LanguageStructModel));
}
else
{
objColMLNodes.Add(GetArgumentValue(strName, blnIsLink, objStruct, objArgument));
}
}
}
// Devuelve el valor
return(objColMLNodes);
}
/// <summary>
/// Obtiene la definición (el prefijo) de un prototipo de un método
/// </summary>
private MLNodesCollection GetMethodPrototypeDefinition(BaseMethodModel objMethod, bool blnIsAsync, TypedModel objReturnType)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Añade los modificadores
objColMLNodes.Add(Document.MLBuilder.GetSpan(GetModifierText(objMethod.Modifier)));
if (blnIsAsync)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("async"));
}
if (objMethod.IsAbstract)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("abstract"));
}
if (objMethod.IsOverride)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("override"));
}
if (objMethod.IsSealed)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("sealed"));
}
if (objMethod.IsStatic)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("static"));
}
if (objMethod.IsVirtual)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan("virtual"));
}
// Añade el valor de retorno
if (objReturnType != null)
{
objColMLNodes.Add(GetLinkTypeName(objReturnType));
}
// Añade el nombre del método
objColMLNodes.Add(Document.MLBuilder.GetSpan(objMethod.Name));
// Añade los genéricos
objColMLNodes.AddRange(GetMethodPrototypeGenerics(objMethod.TypeParameters));
// Devuelve la definición de prototipo
return(objColMLNodes);
}
/// <summary>
/// Obtiene las definiciones de genéricos
/// </summary>
private MLNodesCollection GetMethodPrototypeGenerics(List <TypeParameterModel> objColTypeParameters)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Añade las definiciones de parámetros
if (objColTypeParameters != null && objColTypeParameters.Count > 0)
{ // Apertura
objColMLNodes.Add(Document.MLBuilder.GetSpan("<"));
// Añade los parámetros
for (int intIndex = 0; intIndex < objColTypeParameters.Count; intIndex++)
{ // Añade el nombre
objColMLNodes.Add(Document.MLBuilder.GetSpan(objColTypeParameters[intIndex].Name));
// Añade el separador
if (intIndex < objColTypeParameters.Count - 1)
{
objColMLNodes.Add(Document.MLBuilder.GetSpan(","));
}
}
// Cierre
objColMLNodes.Add(Document.MLBuilder.GetSpan(">"));
}
// Devuelve los parámetros
return(objColMLNodes);
}
/// <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 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 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 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 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 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 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>
/// Obtiene los nodos de los parámetros
/// </summary>
private MLNodesCollection GetParametersNodes(StructDocumentationModel objStruct)
{
MLNodesCollection objColMLNodes = new MLNodesCollection();
// Añade los parámetros
foreach (System.Collections.Generic.KeyValuePair <string, StructParameterModel> objParameter in objStruct.Parameters.Parameters)
{
MLNode objMLNode = new MLNode(cnstStrTagParameter, objParameter.Value.Value?.ToString());
// Añade los atributos
objMLNode.Attributes.Add(cnstStrTagKey, objParameter.Value.Key);
objMLNode.Attributes.Add(cnstStrTagReference, objParameter.Value.ReferenceKey);
// Añade el nodo a la colección
objColMLNodes.Add(objMLNode);
}
// Devuelve la colección de nodos
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 los parámetros
/// </summary>
private MLNodesCollection GetParametersNodes(StructDocumentationModel structDoc)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los parámetros
foreach (System.Collections.Generic.KeyValuePair <string, StructParameterModel> parameter in structDoc.Parameters.Parameters)
{
MLNode nodeML = new MLNode(TagParameter, parameter.Value.Value?.ToString());
// Añade los atributos
nodeML.Attributes.Add(TagKey, parameter.Value.Key);
nodeML.Attributes.Add(TagReference, parameter.Value.ReferenceKey);
// Añade el nodo a la colección
nodesML.Add(nodeML);
}
// Devuelve la colección de nodos
return(nodesML);
}
/// <summary>
/// Obtiene los nodos de los parámetros
/// </summary>
private MLNodesCollection GetParameterNodes(ParameterModelCollection parameters, string tag)
{
MLNodesCollection parametersML = new MLNodesCollection();
// Crea la colección de nodos
foreach (ParameterModel parameter in parameters)
{
MLNode parameterML = new MLNode(tag);
// Crea los valores del nodo
parameterML.Nodes.Add(TagParameterName, parameter.ID);
parameterML.Nodes.Add(TagParameterValue, parameter.Value?.ToString());
// Añade el parámetro
parametersML.Add(parameterML);
}
// Devuelve la colección de nodos
return(parametersML);
}
/// <summary>
/// Añade los nodos de proyecto
/// </summary>
private MLNodesCollection GetNodesProject(ProjectsModelCollection projects)
{
MLNodesCollection nodesML = new MLNodesCollection();
// Añade los nodos
foreach (ProjectModel project in projects)
{
MLNode nodeML = new MLNode(TagProject);
// Asigna las propiedades
nodeML.Nodes.Add(TagFileName, project.FullFileName);
nodeML.Nodes.Add(TagModule, project.Definition.Module);
nodeML.Nodes.Add(TagType, project.Definition.Type);
// Añade el nodo
nodesML.Add(nodeML);
}
// Devuelve los nodos
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;
}