/// <summary>
/// Encerra a execucao dos processos de leitura e escrita da Conexao do cliente.
/// </summary>
public void Desconectar()
{
statusEscrita = false;
statusLeitura = false;
if (TcpUtil.ConexaoTcpValida(TcpCliente))
{
lock (TcpCliente)
{
TcpCliente.Client.Shutdown(SocketShutdown.Both);
TcpCliente.Client.Dispose();
TcpCliente.Close();
}
}
}
/// <summary>
/// Efetua a leitura de uma mensagem via tcp
/// </summary>
/// <returns></returns>
public string EfetuarLeitura()
{
return(TcpUtil.ReceberMensagemTcp(tcp));
}
/// <summary>
/// Efetua o envio de uma mensagem via a instância de tcp atual
/// </summary>
/// <param name="mensagem"></param>
public void EnviarMensagem(string mensagem)
{
TcpUtil.EnviarMensagemTcp(mensagem, tcp);
}
/// <summary>
/// Verifica se a conexão tcp atual é valida
/// </summary>
/// <returns></returns>
public bool ValidarConexao()
{
return(TcpUtil.ConexaoTcpValida(tcp));
}
/// <summary>
/// Retorna verdadeiro se existir dados para leitura
/// </summary>
/// <returns></returns>
public bool PossuiDadosParaLeitura()
{
return(TcpUtil.ConexaoTcpValida(tcp) && tcp.GetStream().DataAvailable);
}
/// <summary>
/// Efetuar o envio das mensagens para o respectivo cliente
/// </summary>
public void RnProcessarFilaEscrita()
{
lock (lockerProcessarEscrita)
{
if (executandoEnvioMensagens)
{
return;
}
executandoEnvioMensagens = true;
MensagemDto mensagemTemporaria;
while (TcpUtil.ConexaoTcpValida(TcpCliente) && FilaEscrita.Count > 0)
{
//Desenfileirar uma mensagemDto efetuando um clone da mensagem
mensagemTemporaria = FilaEscrita.Dequeue();
if (mensagemTemporaria == null)
{
break;
}
mensagemTemporaria = mensagemTemporaria.Clone();
mensagemTemporaria.Dump(string.Format("Clone para processamento(ConexaoCliente-{0}|Mensagem-{1}):", LoginCliente, ConverterTipoMensagemParaString(mensagemTemporaria)));
switch (mensagemTemporaria.Tipo)
{
case CsTipoMensagem.NovosUsuariosConectados:
case CsTipoMensagem.UsuarioDesconectado:
RnEnviarMensagensQuePossuemUsuarios(mensagemTemporaria);
break;
case CsTipoMensagem.EdicaoTarefaAutorizada:
if (SeMensagemForUmaAutoNotificacao(mensagemTemporaria))
{
RnEnviarMensagemAoAccessClient(mensagemTemporaria);
}
else
if (AoReceberMensagemErrada != null)
{
AoReceberMensagemErrada(mensagemTemporaria);
}
break;
case CsTipoMensagem.EdicaoTarefaRecusada:
case CsTipoMensagem.ConexaoRecusadaServidor:
case CsTipoMensagem.ServidorDesconectando:
case CsTipoMensagem.ExclusaoTarefaPermitida:
case CsTipoMensagem.EdicaoNomeCronogramaPermitida:
case CsTipoMensagem.EdicaoNomeCronogramaRecusada:
RnEnviarMensagemAoAccessClient(mensagemTemporaria);
break;
case CsTipoMensagem.NovaTarefaCriada:
case CsTipoMensagem.ExclusaoTarefaFinalizada:
case CsTipoMensagem.MovimentacaoPosicaoTarefa:
case CsTipoMensagem.DadosCronogramaAlterados:
case CsTipoMensagem.InicioEdicaoNomeCronograma:
case CsTipoMensagem.InicioEdicaoTarefa:
case CsTipoMensagem.EdicaoTarefaFinalizada:
if (!SeMensagemForUmaAutoNotificacao(mensagemTemporaria))
{
RnEnviarMensagemAoAccessClient(mensagemTemporaria);
}
break;
}
}
executandoEnvioMensagens = false;
}
}
/// <summary>
/// Responsável por processar a chegada e envio de mensagens
/// (enfileirar novas mensagens e processar mensagens de escrita).
/// </summary>
protected virtual void RnProcessarLeitura()
{
LogDebug(string.Format("\nManager iniciou comunicação com {0} - Cronograma:{1} | {2} iniciou... ", LoginCliente, OidCronograma, Thread.CurrentThread.Name));
String mensagemJson = "";
MensagemDto m;
List <string> mensagens;
string msgAtual = "";
while (statusLeitura)
{
try
{
//validar caso de perda de conexão com o WexMultiAccessClient
if (!TcpUtil.ConexaoTcpValida(TcpCliente))
{
if (AoOcorrerDesconexaoInesperada != null)
{
AoOcorrerDesconexaoInesperada(this, new DesconexaoInesperadaEventArgs(LoginCliente, OidCronograma));
}
statusLeitura = false;
continue;
}
if (!statusLeitura)
{
continue;
}
if (!TcpCliente.GetStream().DataAvailable)
{
Thread.Sleep(15);
continue;
}
mensagemJson = TcpUtil.ReceberMensagemTcp(TcpCliente);
if (mensagemJson.Trim() == "")
{
continue;
}
if (mensagemJson.Contains("\n"))
{
mensagens = mensagemJson.Split('\n').ToList();
foreach (string msg in mensagens)
{
if (String.IsNullOrEmpty(msg))
{
continue;
}
msgAtual = msg.Trim();
if (Buffer != "")
{
msgAtual = Buffer + msgAtual;
Buffer = "";
}
m = Mensagem.DeserializarMensagemDto(TcpUtil.RemoverStringProtecaoDeIntegridade(msgAtual));
LogDebug(String.Format("\nManager recebeu a mensagem {0} | Autor: {1} | Cronograma: {2}\nMensagem Json:{3}", m.Tipo, LoginCliente, OidCronograma, msgAtual));
FilaLeitura.Enqueue(m);
msgAtual = "";
}
}
else
{
Buffer += mensagemJson;
}
}
catch (JsonException ex)
{
LogInfo(String.Format("Exception: {0}" + Environment.NewLine + " StackTrace: {1}", ex.Message, ex.StackTrace));
LogDebug(string.Format("\nConexaoCliente do {3} (Leitura) - Mensagem Json:{2}Excessão:{0}\nCallStack{1} Categoria: JsonConvert", ex.Message, ex.StackTrace, msgAtual, LoginCliente));
continue;
}
catch (InvalidOperationException ex)
{
LogInfo(String.Format("Exception: {0}" + Environment.NewLine + " StackTrace: {1}", ex.Message, ex.StackTrace));
LogDebug(string.Format("\nOcorreu a excessão:{0}\nLocal:{1} Thread: {2}", ex.Message, ex.StackTrace, Thread.CurrentThread.Name), ex);
Desconectar();
}
catch (Exception ex)
{
LogInfo(String.Format("Exception: {0}" + Environment.NewLine + " StackTrace: {1}", ex.Message, ex.StackTrace));
LogDebug(string.Format("\nOcorreu a excessão:{0}\nLocal:{1} Thread: {2}", ex.Message, ex.StackTrace, Thread.CurrentThread.Name));
Desconectar();
}
Thread.Sleep(10);
}
LogDebug(string.Format("\nManager finalizou comunicação com {0} - Cronograma:{1} | {2} finalizou... ", LoginCliente, OidCronograma, Thread.CurrentThread.Name));
}