/// <summary>
/// Convierte los datos de un nodo a una cadena
/// </summary>
public string ConvertToString(MLNode objMLNode)
{
// Limpia el contenido
sbXML.Clear();
// Añade la información del nodo y sus hijos
Add(0, objMLNode);
// Devuelve la cadena
return sbXML.ToString();
}
/// <summary>
/// Depura un nodo
/// </summary>
private string Debug(MLNode objMLNode, int intIndent)
{
string strDebug = GetIndent(intIndent);
// Depura el nodo y sus atributos
strDebug += objMLNode.Name + " --> ";
if (!string.IsNullOrEmpty(objMLNode.Value))
strDebug += objMLNode.Value + " --> ";
foreach (MLAttribute objMLAttribute in objMLNode.Attributes)
strDebug += string.Format(" {0} = \"{1}\"", objMLAttribute.Name, Normalize(objMLAttribute.Value));
strDebug += Environment.NewLine;
// Depura los nodos hijo
if (objMLNode.Nodes.Count > 0)
strDebug += Debug(objMLNode.Nodes, intIndent + 1);
// Añade una separación
// strDebug += Environment.NewLine;
// Devuelve la cadena de depuración
return strDebug;
}
/// <summary>
/// Añade los datos de un nodo
/// </summary>
private void Add(int intIndent, MLNode objMLNode)
{
// Indentación
AddIndent(intIndent);
// Cabecera
sbXML.Append("<");
// Nombre
AddName(objMLNode);
// Espacios de nombres
Add(objMLNode.NameSpaces);
// Atributos
Add(objMLNode.Attributes);
// Final y datos del nodo (en su caso)
if (IsAutoClose(objMLNode))
sbXML.Append("/>" + Environment.NewLine);
else
{ // Cierre de la etiqueta de apertura
sbXML.Append(">");
// Datos
if (objMLNode.Nodes.Count > 0)
{ sbXML.Append(Environment.NewLine);
Add(intIndent + 1, objMLNode.Nodes);
}
else if (objMLNode.IsCData)
{ // Añade un salto de línea
sbXML.Append(Environment.NewLine);
// Añade el CData
if (objMLNode.Value.IndexOf("<![CDATA[") < 0) // ... si la cadena no tenía ya un CDATA
Add(intIndent + 1, "<![CDATA[" + objMLNode.Value + "]]>");
else
Add(intIndent + 1, objMLNode.Value);
// Prepara la línea para el cierre
sbXML.Append(Environment.NewLine);
AddIndent(intIndent);
}
else if (!string.IsNullOrEmpty(objMLNode.Value))
sbXML.Append(objMLNode.Value);
// Cierre
sbXML.Append("</");
AddName(objMLNode);
sbXML.Append(">" + Environment.NewLine);
}
}
/// <summary>
/// Interpreta un nodo
/// </summary>
private MLNode ParseNode(string strName, ParserTokenizer objTokenizer, bool blnSearchBracket)
{ MLNode objMLNode = new MLNode(strName);
// Captura el siguiente nodo
if (!objTokenizer.IsEof())
{ if (blnSearchBracket)
{ // Obtiene el siguiente token
GetNextToken(objTokenizer);
// Debería ser una llave de apertura
if (intIDActualType == TokenType.BraceOpen)
objMLNode.Nodes.Add(ParseNodesArray(objTokenizer));
else if (intIDActualType != TokenType.BracketOpen)
throw new ParserException("Se esperaba una llave de apertura");
else
ParseNodeAttributes(objTokenizer, objMLNode);
}
else
ParseNodeAttributes(objTokenizer, objMLNode);
}
// Devuelve el nodo interpretado
return objMLNode;
}
/// <summary>
/// Interpreta los nodos de un array
/// </summary>
private MLNode ParseNodesArray(string strNodeParent, ParserTokenizer objTokenizer)
{ MLNode objMLNode = new MLNode(strNodeParent);
bool blnEnd = false;
int intIndex = 0;
// Obtiene el siguiente token (puede que se trate de un array vacío)
while (!objTokenizer.IsEof() && !blnEnd)
{ // Obtiene el siguiente token
GetNextToken(objTokenizer);
// Interpreta el nodo
switch (intIDActualType)
{ case TokenType.BracketOpen:
objMLNode.Nodes.Add(ParseNode("Struct", objTokenizer, false));
break;
case TokenType.BraceOpen:
objMLNode.Nodes.Add(ParseNodesArray(objTokenizer));
break;
case TokenType.String:
case TokenType.Numeric:
case TokenType.True:
case TokenType.False:
case TokenType.Null:
objMLNode.Nodes.Add("Item", objActualToken.Lexema);
break;
case TokenType.Comma: // ... no hace nada, simplemente pasa al siguiente incrementando el índice
intIndex++;
break;
case TokenType.BraceClose: // ... corchete de cierre, indica que ha terminado
blnEnd = true;
break;
default:
throw new NotImplementedException("No se ha encontrado un token válido ('" + objActualToken.Lexema + "')");
}
}
// Si no se ha encontrado un corchete, lanza una excepción
if (!blnEnd)
throw new ParserException("No se ha encontrado el carácter de fin del array ']'");
// Devuelve la colección de nodos
return objMLNode;
}
/// <summary>
/// Obtiene el MLNode del valor devuelto
/// </summary>
private void GetMLReturn(MLNode objMLRoot, BaseMethodModel objMethod, TypedModel objReturnType)
{
objMLRoot.Nodes.Add("h3", "Valor devuelto");
objMLRoot.Nodes.Add("p", MLBuilderHelper.GetTypeName(objReturnType));
objMLRoot.Nodes.AddRange(MLBuilderHelper.GetTagsRemarksXml(objMethod.RemarksXml.Returns));
}
/// <summary>
/// Comprueba si un nodo está vacío
/// </summary>
public bool CheckIsEmpty(MLNode objMLNode)
{
return(objMLNode.Nodes.Count == 0 && objMLNode.Value.IsEmpty());
}
/// <summary>
/// Transforma los vínculos de búsqueda
/// </summary>
private void TransformSeachLinks(DocumentFileModel objDocument, Dictionary <string, DocumentFileModel> dctLinks, MLNode objMLNode, string strPathBase)
{
if (objMLNode.Name == cnstStrTagSearchLink)
{
string strTagLink = objMLNode.Attributes[cnstStrTagHref].Value;
DocumentFileModel objDocumentTarget;
// Obtiene la referencia
if (dctLinks.TryGetValue(strTagLink, out objDocumentTarget))
{
objMLNode.Name = cnstStrTagLink;
objMLNode.Attributes[cnstStrTagHref].Value = objDocumentTarget.GetUrl(strPathBase);
}
else
{
objMLNode.Name = cnstStrTagSpan;
}
}
else
{
foreach (MLNode objMLChild in objMLNode.Nodes)
{
TransformSeachLinks(objDocument, dctLinks, objMLChild, strPathBase);
}
}
}
/// <summary>
/// Añade una fecha formateada
/// </summary>
private void AddDate(MLNode node, string tag, DateTime dtmValue)
{
node.Nodes.Add(tag, DateTimeHelper.ToStringRfc822(dtmValue));
}
/// <summary> /// Función para interpretar un nodo /// </summary> internal abstract void Parse(MLNode node, FeedBase objFeed);
/// <summary>
/// Carga los datos de un proyecto
/// </summary>
private ProjectModel LoadProject(SolutionModel solution, ProjectDefinitionModelCollection definitions, MLNode nodeML)
{
return(new ProjectModel(solution,
definitions.Search(nodeML.Nodes[TagModule].Value,
nodeML.Nodes[TagType].Value),
LibCommonHelper.Files.HelperFiles.CombinePath(solution.PathBase, nodeML.Nodes[TagFileName].Value)));
}
/// <summary>
/// Indica que es un nodo que se debe autocerrar
/// </summary>
private bool IsAutoClose(MLNode nodeML)
{
return(string.IsNullOrEmpty(nodeML.Value) && (nodeML.Nodes == null || nodeML.Nodes.Count == 0));
}
/// <summary>
/// Asigna los datos de una sentencia asociada con un blob
/// </summary>
private void AssignBlobSentences(BaseBlobSentence sentence, MLNode rootML)
{
sentence.Enabled = rootML.Attributes[TagEnabled].Value.GetBool(true);
sentence.Timeout = GetTimeout(rootML, TimeSpan.FromMinutes(5));
}
/// <summary>
/// Interpreta los atributos de un nodo "id":"value","id":"value", ... ó "id":{object} ó "id":[array]
/// </summary>
private void ParseNodeAttributes(ParserTokenizer objTokenizer, MLNode objMLNodeParent)
{ bool blnEnd = false;
// Obtiene los nodos
while (!objTokenizer.IsEof() && !blnEnd)
{ // Lee el siguiente Token, debería ser un identificador
GetNextToken(objTokenizer);
// Comprueba que sea correcto
if (intIDActualType == TokenType.BracketClose) // ... es un objeto vacío
blnEnd = true;
else if (intIDActualType != TokenType.String) // ... no se ha encontrado el identificador
throw new ParserException("Se esperaba el identificador del elemento");
else
{ MLAttribute objMLAttribute = new MLAttribute();
// Asigna el código del atributo
objMLAttribute.Name = objActualToken.Lexema;
// Lee el siguiente token. Deberían ser dos puntos
GetNextToken(objTokenizer);
// Comprueba que sea correcto
if (intIDActualType != TokenType.Colon)
throw new ParserException("Se esperaban dos puntos (separador de identificador / valor)");
else
{ // Lee el siguiente token...
GetNextToken(objTokenizer);
// Interpreta el valor
switch (intIDActualType)
{ case TokenType.String:
case TokenType.True:
case TokenType.False:
case TokenType.Numeric:
case TokenType.Null:
// Asigna el valor al atributo
switch (intIDActualType)
{ case TokenType.Null:
objMLAttribute.Value = "";
break;
case TokenType.String:
objMLAttribute.Value = ParseUnicode(objActualToken.Lexema);
break;
default:
objMLAttribute.Value = objActualToken.Lexema;
break;
}
// Añade el atributo al nodo
objMLNodeParent.Attributes.Add(objMLAttribute);
break;
case TokenType.BracketOpen: // ... definición de objeto
MLNode objMLNode = ParseNode(objMLAttribute.Name, objTokenizer, false);
// Añade el nodo como objeto
objMLNodeParent.Nodes.Add(objMLNode);
break;
case TokenType.BraceOpen: // ... definición de array
objMLNodeParent.Nodes.Add(ParseNodesArray(objMLAttribute.Name, objTokenizer));
break;
default:
throw new ParserException("Cadena desconocida. " + objActualToken.Lexema);
}
}
// Lee el siguiente token
GetNextToken(objTokenizer);
// Si es una coma, seguir con el siguiente atributo del nodo, si es una llave de cierre, terminar
switch (intIDActualType)
{ case TokenType.Comma:
// ... no hace nada, simplemente pasa a la creación del siguiente nodo
break;
case TokenType.BracketClose:
blnEnd = true;
break;
default:
throw new ParserException("Cadena desconocida. " + objActualToken.Lexema);
}
}
}
}
/// <summary>
/// Comprueba si un nodo de span está definido como cursiva
/// </summary>
public bool CheckIsItalic(MLNode objMLNode)
{
return(objMLNode.Attributes[cnstStrTagItalic].Value.GetBool());
}
/// <summary>
/// Comprueba si un nodo de span está definido como negrita
/// </summary>
public bool CheckIsBold(MLNode objMLNode)
{
return(objMLNode.Attributes[cnstStrTagBold].Value.GetBool());
}
/// <summary>
/// Comprueba si es un nodo de span
/// </summary>
public bool CheckIsLinkNode(MLNode objMLNode)
{
return(objMLNode.Name == MLIntermedialBuilder.cnstStrTagLink);
}
/// <summary>
/// Comprueba si es un nodo de span
/// </summary>
public bool CheckIsSpanNode(MLNode objMLNode)
{
return(objMLNode.Name == MLIntermedialBuilder.cnstStrTagSpan);
}
/// <summary>
/// Comprueba si un nodo es complejo
/// </summary>
public bool CheckIsComplex(MLNode objMLNode)
{
return(objMLNode.Nodes.Count > 0);
}
/// <summary>
/// Carga los datos de una carpeta de proyecto
/// </summary>
private SolutionFolderModel LoadFolder(SolutionModel solution, ProjectDefinitionModelCollection definitions, MLNode nodeML)
{
SolutionFolderModel folder = new SolutionFolderModel(solution);
// Asigna las propiedades
folder.Name = nodeML.Nodes[TagName].Value;
// Carga los proyectos
foreach (MLNode childML in nodeML.Nodes)
{
if (childML.Name == TagProject)
{
folder.Projects.Add(LoadProject(solution, definitions, childML));
}
}
// Devuelve la carpeta
return(folder);
}
/// <summary>
/// Obtiene un origen de datos para una consulta SQL
/// </summary>
private DataSourceSqlModel LoadDataSourceSql(DataWarehouseModel dataWarehouse, MLNode rootML)
{
DataSourceSqlModel dataSource = new DataSourceSqlModel(dataWarehouse);
// Carga las propiedades
dataSource.Id = rootML.Attributes[TagId].Value.TrimIgnoreNull();
// Asigna la base de datos y la cadena SQL
dataSource.Sql = rootML.Nodes[TagSql].Value.TrimIgnoreNull();
// Carga las columnas
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagColumn)
{
dataSource.Columns.Add(LoadColumn(dataSource, nodeML));
}
}
// Carga los parámetros de consulta
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagParameter)
{
dataSource.Parameters.Add(LoadParameter(nodeML));
}
}
// Devuelve el origen de datos
return(dataSource);
}
public void InitTree(Dictionary <string, Block> dictOrigin, Dictionary <string, List <Block> > dictBlockList, MLNode <Step> parent)
{
int index = 0;
foreach (string key in dictBlockList.Keys)
{
List <Block> list = dictBlockList[key];
MLNode <Step> child = new MLNode <Step>(list.Count);
child.Data = new Step(key, list.Count > 1 ? list.Count * list.Count : 0, list[0].location.X, list[0].location.Y);
tree.Insert(child, parent, index);
index++;
if (list.Count == 1)
{//剩下一个节点无法删除
//parent.Childs = null;
continue;
}
else
{//继续扩展
dictOrigin = Destory(dictOrigin, list);
dictOrigin = Refresh(dictOrigin);
Dictionary <string, List <Block> > refresh = InitGroupList(dictOrigin);
Thread.Sleep(1000);
DrawGame(dictOrigin);
SendMessage(string.Format("===================================（{0},{1}）", list[0].location.X, list[0].location.Y));
InitTree(dictOrigin, refresh, child);
}
}
}
/// <summary>
/// Obtiene un origen de datos para una tabla
/// </summary>
private DataSourceTableModel LoadDataSourceTable(DataWarehouseModel dataWarehouse, MLNode rootML)
{
DataSourceTableModel dataSource = new DataSourceTableModel(dataWarehouse);
// Asigna el esquema y la tabla
dataSource.Schema = rootML.Attributes[TagSchema].Value.TrimIgnoreNull();
dataSource.Table = rootML.Attributes[TagTable].Value.TrimIgnoreNull();
// El Id del origen de datos es el nombre completo de la tabla
dataSource.Id = dataSource.FullName;
// Carga las columnas
foreach (MLNode nodeML in rootML.Nodes)
{
if (nodeML.Name == TagColumn)
{
dataSource.Columns.Add(LoadColumn(dataSource, nodeML));
}
}
// Devuelve el origen de datos
return(dataSource);
}
/// <summary>
/// Interpreta los atributos de un nodo "id":"value","id":"value", ... ó "id":{object} ó "id":[array]
/// </summary>
private void ParseNodeAttributes(ParserTokenizer tokenizer, MLNode nodeMLParent)
{
bool end = false;
// Obtiene los nodos
while (!tokenizer.IsEof() && !end)
{
// Lee el siguiente Token, debería ser un identificador
GetNextToken(tokenizer);
// Comprueba que sea correcto
if (_idActualType == TokenType.BracketClose) // ... es un objeto vacío
{
end = true;
}
else if (_idActualType != TokenType.String) // ... no se ha encontrado el identificador
{
throw new ParserException("Se esperaba el identificador del elemento");
}
else
{
MLAttribute attributeML = new MLAttribute();
// Asigna el código del atributo
attributeML.Name = _actualToken.Lexema;
// Lee el siguiente token. Deberían ser dos puntos
GetNextToken(tokenizer);
// Comprueba que sea correcto
if (_idActualType != TokenType.Colon)
{
throw new ParserException("Se esperaban dos puntos (separador de identificador / valor)");
}
else
{
// Lee el siguiente token...
GetNextToken(tokenizer);
// Interpreta el valor
switch (_idActualType)
{
case TokenType.String:
case TokenType.True:
case TokenType.False:
case TokenType.Numeric:
case TokenType.Null:
// Asigna el valor al atributo
switch (_idActualType)
{
case TokenType.Null:
attributeML.Value = "";
break;
case TokenType.String:
attributeML.Value = ParseUnicode(_actualToken.Lexema);
break;
default:
attributeML.Value = _actualToken.Lexema;
break;
}
// Añade el atributo al nodo
nodeMLParent.Attributes.Add(attributeML);
break;
case TokenType.BracketOpen: // ... definición de objeto
MLNode nodeML = ParseNode(attributeML.Name, tokenizer, false);
// Añade el nodo como objeto
nodeMLParent.Nodes.Add(nodeML);
break;
case TokenType.BraceOpen: // ... definición de array
nodeMLParent.Nodes.Add(ParseNodesArray(attributeML.Name, tokenizer));
break;
default:
throw new ParserException($"Cadena desconocida. {_actualToken.Lexema}");
}
}
// Lee el siguiente token
GetNextToken(tokenizer);
// Si es una coma, seguir con el siguiente atributo del nodo, si es una llave de cierre, terminar
switch (_idActualType)
{
case TokenType.Comma:
// ... no hace nada, simplemente pasa a la creación del siguiente nodo
break;
case TokenType.BracketClose:
end = true;
break;
default:
throw new ParserException("Cadena desconocida. " + _actualToken.Lexema);
}
}
}
}
/// <summary>
/// Interpreta una categoría de Atom
/// </summary>
private AtomCategory ParseCategory(MLNode node)
{
return(new AtomCategory(node.Attributes[AtomConstTags.cnstStrAttrTerm].Value));
}
/// <summary>
/// Obtiene la etiqueta de hipervínculo
/// </summary>
private string GetLinkTag(string strActualPath, MLNode objMLNode)
{
return(string.Format("<a href='{0}'>{1}</a>", GetHtmlFileName(strActualPath, objMLNode), objMLNode.Value));
}
/// <summary>
/// Indica que es un nodo que se debe autocerrar
/// </summary>
private bool IsAutoClose(MLNode objMLNode)
{
return string.IsNullOrEmpty(objMLNode.Value) && (objMLNode.Nodes == null || objMLNode.Nodes.Count == 0);
}
/// <summary>
/// Interpreta una entrada de un archivo Atom
/// </summary>
private AtomEntry ParseEntry(MLNode objMLEntry, AtomChannel channel)
{
AtomEntry entry = new AtomEntry();
// Recorre los nodos
foreach (MLNode node in objMLEntry.Nodes)
{
switch (node.Name)
{
case AtomConstTags.cnstStrItemID:
entry.ID = node.Value;
break;
case AtomConstTags.cnstStrItemTitle:
entry.Title = ParseText(node);
break;
case AtomConstTags.cnstStrItemContent:
entry.Content = ParseText(node);
break;
case AtomConstTags.cnstStrSummary:
entry.Summary = ParseText(node);
break;
case AtomConstTags.cnstStrItemIssued:
entry.DateIssued = node.Value.GetDateTime(DateTime.MinValue);
break;
case AtomConstTags.cnstStrItemModified:
entry.DateModified = node.Value.GetDateTime(DateTime.MinValue);
break;
case AtomConstTags.cnstStrItemCreated:
entry.DateCreated = node.Value.GetDateTime(DateTime.MinValue);
break;
case AtomConstTags.cnstStrItemUpdated:
entry.DateUpdated = node.Value.GetDateTime(DateTime.MinValue);
break;
case AtomConstTags.cnstStrItemPublished:
entry.DatePublished = node.Value.GetDateTime(DateTime.MinValue);
break;
case AtomConstTags.cnstStrItemLink:
entry.Links.Add(ParseLink(node));
break;
case AtomConstTags.cnstStrItemAuthor:
entry.Authors.Add(ParsePeople(node));
break;
case AtomConstTags.cnstStrItemContributor:
entry.Contributors.Add(ParsePeople(node));
break;
case AtomConstTags.cnstStrChannelCategory:
entry.Categories.Add(ParseCategory(node));
break;
case AtomConstTags.cnstsource:
entry.Source = ParseSource(node);
break;
case AtomConstTags.cnstStrRights:
entry.Rights = ParseRights(node);
break;
default:
entry.Extensions.Parse(node, entry, channel.Dictionary);
break;
}
}
// Actualiza la fecha de creación
if (entry.DateCreated.Date == DateTime.MinValue.Date)
{
entry.DateCreated = entry.DatePublished;
if (entry.DateCreated.Date == DateTime.MinValue.Date)
{
entry.DateCreated = DateTime.Now;
}
}
// Devuelve la entrada
return(entry);
}
/// <summary>
/// Limpia el constructor
/// </summary>
public void Clear()
{
Root = new MLNode(cnstStrTagRoot);
}
/// <summary>
/// Interpreta un nodo con derechos
/// </summary>
private AtomRights ParseRights(MLNode node)
{
return(new AtomRights(node.Attributes[AtomConstTags.cnstStrAttrType].Value, node.Value));
}
/// <summary>
/// Interpreta los datos del canal
/// </summary>
private void ParseChannel(MLNode node, AtomChannel channel)
{
foreach (MLNode child in node.Nodes)
{
switch (child.Name)
{
case AtomConstTags.cnstStrChannelId:
channel.ID = child.Value;
break;
case AtomConstTags.cnstStrChannelTitle:
channel.Title = ParseText(child);
break;
case AtomConstTags.cnstStrChannelTagline:
channel.TagLine = ParseText(child);
break;
case AtomConstTags.cnstsubTitle:
channel.Subtitle = ParseText(child);
break;
case AtomConstTags.cnsticon:
channel.Icon = child.Value;
break;
case AtomConstTags.cnstStrLogo:
channel.Logo = child.Value;
break;
case AtomConstTags.cnstStrRights:
channel.Rights = ParseRights(child);
break;
case AtomConstTags.cnstStrChannelGenerator:
channel.Generator = ParseGenerator(child);
break;
case AtomConstTags.cnstStrChannelConvertLineBreaks:
channel.ConvertLineBreaks = child.Value.GetBool(false);
break;
case AtomConstTags.cnstStrChannelInfo:
channel.Info = ParseText(child);
break;
case AtomConstTags.cnstStrItemLink:
channel.Links.Add(ParseLink(child));
break;
case AtomConstTags.cnstStrItemModified:
channel.LastUpdated = child.Value.GetDateTime(DateTime.Now);
break;
case AtomConstTags.cnstStrChannelCategory:
channel.Categories.Add(ParseCategory(child));
break;
case AtomConstTags.cnstStrItemRoot:
channel.Entries.Add(ParseEntry(child, channel));
break;
default:
channel.Extensions.Parse(child, channel, channel.Dictionary);
break;
}
}
}
/// <summary>
/// Carga los datos de un nodo
/// </summary>
private MLNode LoadNode(XmlNode objXMLNode)
{ MLNode objNode = new MLNode();
// Asigna los valores
objNode.Prefix = objXMLNode.Prefix;
objNode.Name = objXMLNode.LocalName;
objNode.Value = Decode(objXMLNode.InnerText);
// Asigna los atributos
objNode.Attributes.Add(LoadAttributes(objXMLNode.Attributes));
// Asigna los espacios de nombres
objNode.NameSpaces.AddRange(LoadNameSpaces(objXMLNode.Attributes));
// Carga los nodos
objNode.Nodes.Add(LoadNodes(objXMLNode.ChildNodes));
// Devuelve el nodo
return objNode;
}
/// <summary>
/// Obtiene el valor del atributo href de un hipervínculo
/// </summary>
public string GetHref(MLNode objMLNode)
{
return(objMLNode.Attributes[cnstStrTagHref].Value);
}
