/// <summary>
/// Graba las conexiones
/// </summary>
public void Save(JabberManager objManager, string strFileName)
{
MLFile objMLFile = new MLFile();
MLNode objMLNode = objMLFile.Nodes.Add(cnstStrTagRoot);
// Asigna los nodos de las conexión
foreach (JabberConnection objConnection in objManager.Connections)
{ MLNode objMLConnection = objMLNode.Nodes.Add(cnstStrTagConnection);
MLNode objMLServer = objMLConnection.Nodes.Add(cnstStrTagServer);
MLNode objMLUser = objMLConnection.Nodes.Add(cnstStrTagUser);
// Añade los datos del servidor
objMLServer.Attributes.Add(cnstStrTagAddress, objConnection.Host.Address);
objMLServer.Attributes.Add(cnstStrTagPort, objConnection.Host.Port);
objMLServer.Attributes.Add(cnstStrTagUseSsl, objConnection.Host.UseTls);
// Añade los datos del usuario
objMLUser.Attributes.Add(cnstStrTagAddress, objConnection.User.Host);
objMLUser.Attributes.Add(cnstStrTagLogin, objConnection.User.Login);
objMLUser.Attributes.Add(cnstStrTagPassword, objConnection.User.Password);
objMLUser.Attributes.Add(cnstStrTagServer, (int) objConnection.User.Status.Status);
}
// Crea el directorio
Bau.Libraries.LibHelper.Files.HelperFiles.MakePath(System.IO.Path.GetDirectoryName(strFileName));
// Graba el archivo
new Bau.Libraries.LibMarkupLanguage.Services.XML.XMLWriter().Save(objMLFile, strFileName);
}
/// <summary>
/// Obtiene el error
/// </summary>
private static MLFile GetError(string strError)
{
MLFile objMLFile = new MLFile();
MLNode objMLNode = objMLFile.Nodes.Add(Commands.Parser.ErrorParser.cnstStrTagRoot);
// Añade el mensaje de error
objMLNode.Nodes.Add(Commands.Parser.ErrorParser.cnstStrTagMessage, strError);
// Devuelve el documento
return objMLFile;
}
/// <summary>
/// Interpreta un documento XML con datos de un mensaje
/// </summary>
internal static DirectMessage Parse(MLFile objMLFile)
{
DirectMessage objMessage = new DirectMessage();
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals(cnstStrTagMessage))
objMessage = Parse(objMLNode);
// Devuelve el mensaje
return objMessage;
}
/// <summary>
/// Interpreta un documento XML con datos de tendencia
/// </summary>
internal static Trend Parse(MLFile objMLFile)
{
Trend objTrend = null;
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals(cnstStrTagUser))
objTrend = Parse(objMLNode);
// Devuelve la tendencia
return objTrend;
}
/// <summary>
/// Interpreta un estado
/// </summary>
internal static Status Parse(MLFile objMLFile)
{
Status objStatus = new Status();
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals(cnstStrTagStatus))
objStatus = Parse(objMLNode);
// Devuelve el estado
return objStatus;
}
/// <summary>
/// Interpreta un documento XML con datos de usuario
/// </summary>
internal static User Parse(MLFile objMLFile)
{
User objUser = null;
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals("Root"))
objUser = Parse(objMLNode);
// Devuelve el usuario
return objUser;
}
/// <summary>
/// Interpreta un documento XML para obtener una colección de datos de tendencias
/// </summary>
internal static TrendsCollection ParseCollection(MLFile objMLFile)
{
TrendsCollection objColTrends = new TrendsCollection();
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals(cnstStrTagUsers))
foreach (MLNode objMLChild in objMLNode.Nodes)
if (objMLChild.Name.Equals(cnstStrTagUser))
objColTrends.Add(Parse(objMLChild));
// Devuelve las tendencias
return objColTrends;
}
/// <summary>
/// Interpreta los datos de un error
/// </summary>
internal static Core.Error Parse(MLFile objMLFile)
{
Core.Error objError = new Core.Error();
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals(cnstStrTagRoot))
foreach (MLNode objMLMessage in objMLNode.Nodes)
if (objMLMessage.Name.Equals(cnstStrTagMessage))
objError.Message = objMLMessage.Value;
// Devuelve el objeto de error
return objError;
}
/// <summary>
/// Interpreta un documento XML con datos de un mensaje
/// </summary>
internal static DirectMessagesCollection ParseCollection(MLFile objMLFile)
{
DirectMessagesCollection objColMessages = new DirectMessagesCollection();
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals(cnstStrTagRoot))
foreach (MLNode objMLMessage in objMLNode.Nodes)
if (objMLMessage.Name.Equals(cnstStrTagMessage))
objColMessages.Add(Parse(objMLMessage));
// Devuelve los mensajes
return objColMessages;
}
/// <summary>
/// Graba las cuentas en un archivo
/// </summary>
public static void Save(TwitterAccountsCollection objColAccounts, string strFileName)
{
MLFile objMLFile = new MLFile();
MLNode objMLNode = objMLFile.Nodes.Add(cnstStrTagRoot);
// Asigna los nodos de las cuentas
foreach (TwitterAccount objAccount in objColAccounts)
{ MLNode objMLAccount = objMLNode.Nodes.Add(cnstStrTagAccount);
// Añade el resto de nodos
objMLAccount.Nodes.Add(cnstStrTagID, objAccount.ID);
objMLAccount.Nodes.Add(cnstStrTagUser, objAccount.ScreenName);
objMLAccount.Nodes.Add(cnstStrTagOAuthToken, objAccount.OAuthToken);
objMLAccount.Nodes.Add(cnstStrTagOAuthTokenSecret, objAccount.OAuthTokenSecret);
}
// Graba el archivo
new MLSerializer().Save(MLSerializer.SerializerType.XML, objMLFile, strFileName);
}
/// <summary>
/// Interpreta una serie de estados
/// </summary>
internal static StatusesCollection ParseCollection(MLFile objMLFile)
{
StatusesCollection objColStatus = new StatusesCollection();
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals("Root"))
foreach (MLNode objMLArray in objMLNode.Nodes)
if (objMLArray.Name == "Array")
foreach (MLNode objMLStatus in objMLArray.Nodes)
if (objMLStatus.Name == "Struct")
{ Status objStatus = Parse(objMLStatus);
// Añade el estado a la colección
if (!string.IsNullOrEmpty(objStatus.Text))
objColStatus.Add(objStatus);
}
// Devuelve la colección
return objColStatus;
}
/// <summary>
/// Convierte los datos de un archivo a una cadena
/// </summary>
public string ConvertToString(SerializerType intType, MLFile objMLFile)
{
return(GetWriter(intType).ConverToString(objMLFile));
}
/// <summary>
/// Graba los datos en un archivo
/// </summary>
public void Save(SerializerType intType, MLFile objMLFile, string strFileName)
{
GetWriter(intType).Save(objMLFile, strFileName);
}
/// <summary>
/// Interpreta un documento XML para obtener una colección de datos de usuario
/// </summary>
internal static UsersCollection ParseCollection(MLFile objMLFile)
{
UsersCollection objColUsers = new UsersCollection();
// Interpreta los datos
foreach (MLNode objMLNode in objMLFile.Nodes)
if (objMLNode.Name.Equals("Root"))
{ objColUsers.NextCursor = objMLNode.Attributes[cnstStrTagNextCursor].Value;
objColUsers.PreviousCursor = objMLNode.Attributes[cnstStrTagPreviousCursor].Value;
foreach (MLNode objMLChild in objMLNode.Nodes)
if (objMLChild.Name.Equals(cnststrTagUsersList))
{ foreach (MLNode objMLUser in objMLChild.Nodes)
if (objMLUser.Name.Equals(cnstStrTagUsers))
ParseUsers(objMLUser.Nodes, objColUsers);
}
else if (objMLChild.Name.Equals(cnstStrTagUsers))
foreach (MLNode objMLStruct in objMLChild.Nodes)
if (objMLStruct.Name == "Struct")
objColUsers.Add(Parse(objMLStruct));
}
// Devuelve los usuarios
return objColUsers;
}
/// <summary>
/// Graba los datos en un archivo
/// </summary>
public void Save(SerializerType intType, MLFile objMLFile, string strFileName)
{
GetWriter(intType).Save(objMLFile, strFileName);
}
/// <summary>
/// Convierte los datos de un archivo a una cadena
/// </summary>
public string ConvertToString(SerializerType intType, MLFile objMLFile)
{
return GetWriter(intType).ConvertToString(objMLFile);
}
/// <summary>
/// Graba el vínculo
/// </summary>
private static void Save()
{
MLFile objMLFile = new MLFile();
// Añade los nodos
objMLFile.Nodes.Add(LastLinks.GetXML());
// Graba el archivo
new MLSerializer().Save(MLSerializer.SerializerType.XML, objMLFile, GetFileNameLastLinks());
}
/// <summary>
/// Graba los datos de un mensaje
/// </summary>
public void Save(string strFileName, Project objProject)
{
MLFile objMLFile = new MLFile();
MLNode objMLNode = objMLFile.Nodes.Add(cnstStrTagRoot);
// Añade los nodos de contexto
AddNodesContext(objMLNode, objProject.Context);
// Añade los nodos de las instrucciones
foreach (Instruction objInstruction in objProject.Instructions)
AddNodesMessage(objMLNode, objInstruction);
// Añade los nodos de autentificación
AddNodesAuthentification(objMLNode, objProject.Authenticator);
// Graba el archivo
new MLSerializer().Save(MLSerializer.SerializerType.XML, objMLFile, strFileName);
}
