/// <summary>
/// Método responsável pelo envio da mensagem ao WexMultiAccessClient
/// </summary>
/// <param name="mensagemTemporaria">Mensagem a ser comunicada ao AccessClient</param>
private void RnEnviarMensagemAoAccessClient(MensagemDto mensagemTemporaria)
{
string autorAcao;
if (mensagemTemporaria.Propriedades.ContainsKey(Constantes.AUTOR_ACAO))
{
autorAcao = mensagemTemporaria.Propriedades[Constantes.AUTOR_ACAO] as string;
}
else
{
autorAcao = "-";
}
if (mensagemTemporaria == null || !TcpUtil.ConexaoTcpValida(TcpCliente))
{
if (mensagemTemporaria != null)
{
LogDebug(string.Format("\n{4} não enviou {0} - Client#{1} - Cronograma {2} - Autor Mensagem:{3} \nObs.: conexão tcp inválida ou encerrada!", mensagemTemporaria.Tipo, LoginCliente, OidCronograma, autorAcao, Thread.CurrentThread.Name));
}
else
{
LogDebug(string.Format("\n{4} não comunicou mensagem - Client#{0} Cronograma:{1} - Autor:{2},\nObs.: mensagem nula!", LoginCliente, OidCronograma, autorAcao, Thread.CurrentThread.Name));
}
return;
}
string mensagemJson = JsonConvert.SerializeObject(mensagemTemporaria);
LogDebug(string.Format("\n{4} enviou {0}(Enum - {1}) - Client#{2} - Autor - {3}\nMensagem Json:{5}", mensagemTemporaria.Tipo, (int)mensagemTemporaria.Tipo, LoginCliente, autorAcao, Thread.CurrentThread.Name, mensagemJson));
mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson);
TcpUtil.EnviarMensagemTcp(mensagemJson, TcpCliente);
LogarEnvio(mensagemTemporaria);
}
/// <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>
/// 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));
}