public string abreAnexo(string nomeArq, int id)
{
try
{
string sql = "select loginusuario, tipo from mensagem where id = " + id + ";";
DataTable data = retornaDataTableSql(sql);
string login = data.Rows[0][data.Columns[0]].ToString();
string tipo = data.Rows[0][data.Columns[1]].ToString();
string caminho = CAMINHO_SERVER + "\\" + login + "\\" + tipo + "\\" + id + ".msg";
string xml = manipulaArquivo.leArquivoTexto(caminho);
mensagem msg = serial.Deserializar(xml, typeof(mensagem)) as mensagem;
anexo anexoFinal = new anexo();
foreach (anexo a in msg.anexos)
{
if (a.getNome().Equals(nomeArq))
{
anexoFinal = a;
}
}
return(serial.serializarObjeto(anexoFinal));
}
catch (excecao.excecao except)
{
throw except;
}
}
/*
* ///<summary>
* ///
* /// Método que retorna a assinatura da mensagem
* ///
* ///</summary>
* private static String assinaMensagem(string caminho, string mensagem) {
*
* return assimetrica.assinaTexto(caminho, mensagem);
*
* }
*/
///<summary>
///
/// Método que retorna o conteudo do anexo da mensagem cifrado ou não
///
///</summary>
private static anexo retornaConteudoAnexo(string s, bool cripto, string destinatario)
{
byte[] conteudoByte = manipulaArquivo.arquivoLeOriginal(s);
string conteudo = serial.serializarObjeto(conteudoByte);
string nome = manipulaString.retornaNomeArquivo(s).Trim();
string nomeCodificado;
string chave = "";
anexo next;
string caminhoChave = CAMINHO_TEMP + destinatario + EXTENSAO;
nome = uniformizaAnexos(nome);
if (cripto)
{
nomeCodificado = manipulaString.mudaExtensaoArquivo(nome);
string conteudocifrado = simetrica.cifraAnexos(conteudo);
string conteudoHexa = simetrica.convertToHexa(conteudocifrado);
chave = simetrica.getChave();
string chaveDestinatario = WService.retornaChavePublica(destinatario);
manipulaArquivo.criaArquivoTexto(caminhoChave, chaveDestinatario);
string conteudoChaveCifrada = assimetrica.cifraAssimetrica(caminhoChave, chave);
string chaveHexa = simetrica.convertToHexa(conteudoChaveCifrada);
next = new anexo(nomeCodificado, cripto, chaveHexa, conteudoHexa);
}
else
{
string conteudoHexa = simetrica.convertToHexa(conteudo);
next = new anexo(nome, cripto, chave, conteudoHexa);
}
return(next);
}
///<summary>
///
/// Método que abre o arquivo através do nome passado.
///
///</summary>
public static void abreArquivo(string nomeArq, int id, string caminhoChave)
{
string xml = WService.abreAnexo(nomeArq, id);
anexo anexos = serial.Deserializar(xml, typeof(anexo)) as anexo;
string nome;
string conteudo;
if (anexos.getCripto())
{
nome = manipulaString.recuperaNomeOriginalArquivo(anexos.getNome());
string chaveCifrada = simetrica.convertToString(anexos.getChave());
string chaveDecifrada = assimetrica.decifraAssimetrica(caminhoChave, chaveCifrada);
string conteudoCifrado = simetrica.convertToString(anexos.getConteudo());
conteudo = simetrica.decifraAnexos(chaveDecifrada, conteudoCifrado);
}
else
{
nome = anexos.getNome();
string conteudoOriginal = simetrica.convertToString(anexos.getConteudo());
conteudo = conteudoOriginal;
}
byte[] conteudoByte = serial.Deserializar(conteudo, typeof(byte[])) as byte[];
manipulaArquivo.arquivoCriaOriginal(CAMINHO_TEMP + nome, conteudoByte);
System.Diagnostics.Process.Start(CAMINHO_TEMP + nome);
}
///<summary>
///
/// Método que cria mensagem a ser enviada a partir da pre-mensagem passada retornando
/// verdadeiro caso o envio seja feito com sucesso.
///
/// Retorna excecao.
///
///</summary>
public static List <string> criaMensagem(preMensagem msg, string caminhoChave)
{
try
{
string destinatarios = msg.getPara() + msg.getDe() + EMAIL;
string[] para = manipulaString.retornaLoginsContatos(destinatarios);
string de = msg.getDe();
string assunto = msg.getAssunto();
string body = "";
string assinatura = "";
bool cripto = msg.getCriptografar();
bool sign = msg.getAssinar();
List <anexo> arquivosPlain = new List <anexo>();
List <anexo> arquivosCripto = new List <anexo>();
List <string> destinatarioInexistentes = new List <string>();
// trazendo os arquivos que nao serao criptografados para a lista
foreach (string s in msg.getArquivoPlain())
{
bool cript = false;
anexo next = retornaConteudoAnexo(s, cript, "");
arquivosPlain.Add(next);
}
// criando a mensagem para enviar a cada destinatario
foreach (string destinatario in para)
{
if (WService.verificaUsuario(destinatario))
{
body = msg.getTexto();
arquivosCripto.Clear();
foreach (string s in msg.getArquivoCripto())
{
string nome = s;
bool cript = true;
if (s.Contains(EXTENSAO_SAC))
{
nome = manipulaString.recuperaNomeOriginalArquivo(s);
}
anexo next = retornaConteudoAnexo(nome, cript, destinatario);
arquivosCripto.Add(next);
}
foreach (anexo ap in arquivosPlain)
{
arquivosCripto.Add(ap);
}
if (sign)
{
assinatura = assimetrica.assinaTexto(caminhoChave, body);
}
if (cripto)
{
string chaveCertificada = WService.retornaChavePublica(destinatario);
string caminhoChaveCert = CAMINHO_TEMP + destinatario + EXTENSAO;
manipulaArquivo.criaArquivoTexto(caminhoChaveCert, chaveCertificada);
body = simetrica.cifraMensagem(body, caminhoChaveCert);
body = simetrica.convertToHexa(body);
}
mensagem mensagem = new mensagem(de, destinatario, assunto, body, assinatura, cripto, sign, arquivosCripto, msg.getPara());
string xml = serial.serializarObjeto(mensagem);
WService.enviaMensagem(xml);
excluiArquivos();
}
else
{
destinatarioInexistentes.Add(destinatario);
}
}
return(destinatarioInexistentes);
}
catch (excecao except)
{
throw except;
}
}
