/// <summary>
/// Método responsável por tratar MensagensDto que possuem um vetor de usuários
/// (Mensagem Sintetizada)
/// </summary>
/// <param name="mensagemTemporaria">MensagemDto</param>
private void RnEnviarMensagensQuePossuemUsuarios(MensagemDto mensagemTemporaria)
{
//Caso seja nula não fazer nada
if (mensagemTemporaria == null)
{
return;
}
mensagemTemporaria = RemoverProprioUsuarioDoVetorUsuariosDaMensagemDto(mensagemTemporaria);
//Caso não contenha o indice usuários não fazer nada
if (!mensagemTemporaria.Propriedades.ContainsKey(Constantes.USUARIOS))
{
return;
}
string[] usuarios = (string[])mensagemTemporaria.Propriedades[Constantes.USUARIOS];
if (usuarios.Length > 0)
{
RnEnviarMensagemAoAccessClient(mensagemTemporaria);
}
else
{
LogDebug(string.Format("\nManager não enviou {2} - Client#{0} - Cronograma:{1}\nObs:não foi enviada por não conter usuários!", LoginCliente, OidCronograma, mensagemTemporaria.Tipo));
}
}
/// <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);
}
public void EntaoOServidorDeveSerComunicadoQueATarefaDoCronogramaEstaSendoEditadaPeloColaborador(string tarefa, string cronograma, string login)
{
string oidCronograma = StepCronograma.CronogramasDic[cronograma].Oid.ToString();
string oidTarefa = StepCronograma.CronogramaTarefasDic[cronograma][tarefa].Oid.ToString();
List <MensagemDto> mensagens = null;
MensagemDto mensagemFiltrada = null;
ControleDeEsperaUtil.AguardarAte(() =>
{
mensagens = new List <MensagemDto>(manager.ListaTodasMensagensProcessadas);
mensagemFiltrada = mensagens.FirstOrDefault
(o =>
o.Tipo == CsTipoMensagem.InicioEdicaoTarefa &&
o.Propriedades[Constantes.AUTOR_ACAO].ToString() == login &&
o.Propriedades[Constantes.OIDTAREFA].ToString() == oidTarefa
);
return(mensagemFiltrada != null);
});
Assert.IsNotNull(mensagemFiltrada, "Não deveria ter sido nula, colaborador deveria ter recebido a mensagem pesquisada");
Assert.AreEqual(login, mensagemFiltrada.Propriedades[Constantes.AUTOR_ACAO].ToString(), string.Format("O colaborador autor da mensagem deveria ser {0}", login));
Assert.AreEqual(oidTarefa, mensagemFiltrada.Propriedades[Constantes.OIDTAREFA].ToString(), string.Format("O Oid da tarefa editada deveria ser {0}", oidTarefa));
Assert.AreEqual(oidCronograma, mensagemFiltrada.Propriedades[Constantes.OIDCRONOGRAMA].ToString(),
string.Format("O Oid do Cronograma atual deveria ser {0}", oidCronograma));
}
public void RnProcessarEventosFinalizarEdicaoTarefa()
{
int contador = 0;
WexMultiAccessClientMock cliente = new WexMultiAccessClientMock()
{
TcpAdapterStubAtivo = true
};
TcpAdapterPool pool = new TcpAdapterPool();
#region Preenchendo informações do cliente
cliente.EnderecoIp = ipServidor;
cliente.OidCronograma = "C1";
cliente.Porta = porta;
cliente.Login = "******";
cliente.Conectar();
pool.AceitarConexao(cliente);
cliente.AoSerFinalizadaEdicaoTarefaPorOutroUsuario += (mensagem) => { contador++; };
cliente.AoServidorDesconectar += (mensagemDto) => { };
#endregion
//Criando a mensagem de fim de edição de uma tarefa por outro colaborador
MensagemDto mensagemFimDeEdicao = Mensagem.RnCriarMensagemFinalizarEdicaoTarefa("T1", "Marcos", "C1");
string mensagemJson = JsonConvert.SerializeObject(mensagemFimDeEdicao);
mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson);
pool.EnviarMensagemPara(cliente, mensagemJson);
ControleDeEsperaUtil.AguardarAte(() => { return(contador == 1); });
Assert.AreEqual(1, contador, "Deveria ter sido disparado o evento AoEdicaoTarefaSerRecusada");
cliente.RnDesconectar();
}
/// <summary>
/// Simulação do envio removendo o usuário dono da mensagem da propria mensagem utilizado no teste EfetuarCopiaDaMensagemDtoTest
/// </summary>
/// <param name="mensagem">Cópia de mensagem original</param>
/// <param name="login">Distinatário receptor da mensagem</param>
/// <param name="mensagens"> Dicionário de mensagens para armazenar o a mensagem alterada para comparação posterior no teste unitário</param>
public static void SimularModificacaoColecaoDaMensagem(MensagemDto mensagem, string login, Dictionary <string, MensagemDto> mensagens)
{
//removendo o próprio usuário da mensagem
if (mensagem.Propriedades.ContainsKey(login))
{
mensagem.Propriedades.Remove(login);
}
string msg;
//caso contenha mais de uma propriedade ou seja mais do que a propriedade "cronogramaOid" é reportado sobre o envio da mensagem
if (mensagem.Propriedades.Count > 1)
{
msg = String.Format("Mensagem do tipo{0} enviada para {1} Contendo:\n", mensagem.Tipo, login);
foreach (DictionaryEntry item in mensagem.Propriedades)
{
msg += String.Format("\"{0}\": \"{1}\"\n", item.Key, item.Value);
}
}
else
{
msg = "Não foi enviada mensagem para" + login;
}
Debug.WriteLine(msg);
//adicao da mensagem modificada para o devido usuário no dicionário de mensagens modificadas para utilização no teste unitário
mensagens.Add(login, mensagem);
}
public void RnComunicarInicioExclusaoTarefaTest()
{
const string ipServidor = "127.0.0.1";
const int porta = 8086;
TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta);
servidor.Start();
WexMultiAccessClientMock cliente = new WexMultiAccessClientMock()
{
EnderecoIp = ipServidor,
OidCronograma = "C1",
Porta = porta,
Login = "******"
};
cliente.AoServidorDesconectar += (mensagem) => { };
cliente.Conectar();
TcpClient tcpEmServidor = servidor.AcceptTcpClient();
//interceptando a mensagem de conexão
TcpUtil.ReceberMensagemTcp(tcpEmServidor);
cliente.RnComunicarInicioExclusaoTarefa(new string[] { "T1", "T2", "T3" });
string resposta = TcpUtil.ReceberMensagemTcp(tcpEmServidor);
resposta = TcpUtil.RemoverStringProtecaoDeIntegridade(resposta);
MensagemDto mensagemDto = Mensagem.DeserializarMensagemDto(resposta);
Assert.AreEqual(CsTipoMensagem.ExclusaoTarefaIniciada, mensagemDto.Tipo, "A mensagem recebida veio com tipo diferente do original");
Assert.IsTrue(mensagemDto.Propriedades.ContainsKey(Constantes.AUTOR_ACAO), "A mensagem deveria conter o usuário que solicitou a exclusão");
Assert.AreEqual("Joao", (string)mensagemDto.Propriedades[Constantes.AUTOR_ACAO], "O usuário deveria ser o Joao");
Assert.IsTrue(mensagemDto.Propriedades.ContainsKey(Constantes.TAREFAS), "A mensagem deveria conter tarefas");
CollectionAssert.AreEquivalent(new string[] { "T1", "T2", "T3" }, (string[])mensagemDto.Propriedades["tarefas"], "A mensagem recebida deveria possuir as mesmas tarefas que foram enviadas");
}
public void MultiAccessClientComunicarManagerSobreFimEdicaoTarefa()
{
const string ipServidor = "127.0.0.1";
const int porta = 8086;
TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta);
servidor.Start();
WexMultiAccessClientMock cliente = new WexMultiAccessClientMock()
{
EnderecoIp = ipServidor, Porta = porta, Login = "******", OidCronograma = "C1"
};
cliente.AoServidorDesconectar += (mensagemDto) => { };
cliente.Conectar();
TcpClient conexaoTcpEmServidor = servidor.AcceptTcpClient();
//efetuando a leitura da primeira mensagem do cliente mensagemd e autenticação
TcpUtil.ReceberMensagemTcp(conexaoTcpEmServidor);
///Comunicando o fim da tarefa
cliente.RnComunicarFimEdicaoTarefa("T2");
string mensagemJson = TcpUtil.ReceberMensagemTcp(conexaoTcpEmServidor);
mensagemJson = TcpUtil.RemoverStringProtecaoDeIntegridade(mensagemJson);
MensagemDto mensagem = Mensagem.DeserializarMensagemDto(mensagemJson);
Assert.AreEqual(cliente.OidCronograma, (string)mensagem.Propriedades[Constantes.OIDCRONOGRAMA], "Deveria ser o mesmo cronograma em que esta conectado o client");
Assert.IsTrue(mensagem.Propriedades.ContainsKey(Constantes.AUTOR_ACAO), "Deveria conter o login do colaborador que esta editou a tarefa");
Assert.AreEqual("T2", (string)mensagem.Propriedades[Constantes.OIDTAREFA], "Deveria ser a mesma tarefa comunicada na mensagem de fim de edição");
cliente.RnDesconectar();
servidor.Stop();
}
/// <summary>
/// Método responsável por comunicar ao MultiAccessManager de que uma tarefa persistida está sendo editada
/// </summary>
/// <param name="oidTarefa">guid da tarefa editada</param>
/// <param name="autoSalvarEdicao">boolean para informar se deve auto salvar a edição caso receba a resposta de autorização da edição da tarefa</param>
public void RnComunicarInicioEdicaoTarefa(string oidTarefa, string idRequisicao = "")
{
Debug.WriteLine(String.Format("Enviando Requisicao: {0} - OidTarefa: {1} - Autor: {2}", idRequisicao, oidTarefa, Login));
MensagemDto mensagem = Mensagem.RnCriarMensagemInicioEdicaoTarefa(oidTarefa, Login, OidCronograma, idRequisicao);
RnEnviarMensagem(mensagem);
}
public void EfetuarTratamentoExtracaoDicionarioDaMensagemQuandoReceberUmaMensagemDtoComODicionarioSerializadoEmHashtable()
{
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T2", 2);
tarefasImpactadas.Add("T3", 3);
tarefasImpactadas.Add("T4", 4);
tarefasImpactadas.Add("T5", 5);
tarefasImpactadas.Add("T6", 6);
tarefasImpactadas.Add("T7", 7);
tarefasImpactadas.Add("T8", 8);
tarefasImpactadas.Add("T9", 9);
DateUtil.CurrentDateTime = DateTime.Now;
MensagemDto mensagem = Mensagem.RnCriarMensagemMovimentacaoTarefa(1, 10, "T1", tarefasImpactadas, "Joao", "C1", DateUtil.CurrentDateTime);
string mensagemJson = JsonConvert.SerializeObject(mensagem);
MensagemDto mensagemEsperada = JsonConvert.DeserializeObject <MensagemDto>(mensagemJson);
mensagemEsperada = Mensagem.EfetuarTratamentoExtracaoDicionarioDaMensagem <string, Int16>(mensagemEsperada, Constantes.TAREFAS_IMPACTADAS);
CollectionAssert.AreEqual((Dictionary <string, Int16>)mensagem.Propriedades[Constantes.TAREFAS_IMPACTADAS], (Dictionary <string, Int16>)mensagemEsperada.Propriedades[Constantes.TAREFAS_IMPACTADAS]);
Assert.AreEqual(DateUtil.CurrentDateTime, mensagem.Propriedades[Constantes.DATAHORA_ACAO]);
}
public void RnComunicarAlteracaoNomeCronogramaTest()
{
//inicializar o Dicionário tarefasGrid
const string ipServidor = "127.0.0.1";
const int porta = 8093;
TcpListener servidor = new TcpListener(IPAddress.Parse(ipServidor), porta);
servidor.Start();
WexMultiAccessClientMock client = new WexMultiAccessClientMock();
client.Porta = porta;
client.EnderecoIp = ipServidor;
client.Login = "******";
client.OidCronograma = "C1";
client.Conectar();
client.AoServidorDesconectar += (mensagemDto) => { };
TcpClient conexaoClienteNoServidor = servidor.AcceptTcpClient();
//efetuar a leitura da autenticacao do client
TcpUtil.ReceberMensagemTcp(conexaoClienteNoServidor);
client.RnComunicarAlteracaoDadosCronograma();
ControleDeEsperaUtil.AguardarAte(() => { return(conexaoClienteNoServidor.Available > 0); });
string mensagemJson = TcpUtil.ReceberMensagemTcp(conexaoClienteNoServidor);
mensagemJson = TcpUtil.RemoverStringProtecaoDeIntegridade(mensagemJson);
MensagemDto mensagemRecebida = JsonConvert.DeserializeObject <MensagemDto>(mensagemJson);
Assert.AreEqual(client.Login, (string)mensagemRecebida.Propriedades[Constantes.AUTOR_ACAO], "O nome do autor da ação deveria corresponder ao nome esperado");
Assert.AreEqual(client.OidCronograma, (string)mensagemRecebida.Propriedades[Constantes.OIDCRONOGRAMA], "O oid do cronograma atual deveria corresponder ao oid atual");
}
public void RnProcessarEventosDispararEventoAoReceberMensagemDeServidorDesconectando()
{
int contador = 0;
string oidCronograma = Guid.NewGuid().ToString();
TcpAdapterPool poolTcp = new TcpAdapterPool();
//Criando a mensagem de desconexão do servidor
MensagemDto mensagemTemporaria = Mensagem.RnCriarMensagemServidorDesconectando("Servidor Efetuando Processo de Desligamento!");
string mensagemJson = JsonConvert.SerializeObject(mensagemTemporaria);
mensagemJson = TcpUtil.AdicionarStringProtecaoDeIntegridade(mensagemJson);
WexMultiAccessClientMock client = new WexMultiAccessClientMock()
{
EnderecoIp = ipServidor,
Porta = porta,
Login = "******",
OidCronograma = oidCronograma,
TcpAdapterStubAtivo = true
};
client.Conectar();
poolTcp.AceitarConexao(client);
client.AoServidorDesconectar += (mensagem) => { contador++; };
poolTcp.ServerBroadCast(mensagemJson);
ControleDeEsperaUtil.AguardarAte(() => { return(contador > 0); });
Assert.AreEqual(1, contador, "O contador adicionado ao Evento AoServidorDesconectar deveria ter sido contado 1 vez");
client.RnDesconectar();
}
/// <summary>
/// Método responsável por acionar evento de AoSerFinalizadaEdicaoTarefaPorOutroUsuario e validar
/// seu disparo
/// </summary>
/// <param name="mensagem">MensagemDto do Tipo FinalizarEdicaoTarefa</param>
public virtual void AcionarEventoAoSerFinalizadaEdicaoTarefaPorOutroUsuario(MensagemDto mensagem)
{
if (AoSerFinalizadaEdicaoTarefaPorOutroUsuario == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoSerFinalizadaEdicaoTarefaPorOutroUsuario");
}
AoSerFinalizadaEdicaoTarefaPorOutroUsuario(mensagem);
}
/// <summary>
/// Método responsável por disparar o evento ao ser criada uma nova tarefa
/// </summary>
/// <param name="mensagem">mensagem de CriacaoNovaTarefa</param>
public virtual void AcionarEventoAoNovaTarefaSerCriada(MensagemDto mensagem)
{
if (AoSerCriadaNovaTarefa == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoSerCriadaNovaTarefa");
}
AoSerCriadaNovaTarefa(mensagem);
}
/// <summary>
/// Método executado quando o servidor é desconectado
/// </summary>
/// <param name="mensagem">Mensagem de servidor desconectado</param>
protected virtual void AcionarEventoAoServidorDesconectar(MensagemDto mensagem)
{
if (AoServidorDesconectar == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoServidorDesconectar");
}
AoServidorDesconectar(mensagem);
}
/// <summary>
/// Método responsável por disparar o evento quando outro usuário se desconecta
/// </summary>
/// <param name="mensagem">MensagemDto do tipo UsuarioDesconectado</param>
public virtual void AcionarEventoAoUsuarioDesconectar(MensagemDto mensagem)
{
if (AoUsuarioDesconectar == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoUsuarioDesconectar");
}
AoUsuarioDesconectar(mensagem);
}
/// <summary>
/// Método responsável por disparar o evento de recusa de conexão
/// </summary>
/// <param name="mensagem">Motivo de recusa de conexão</param>
protected virtual void AcionarEventoAoServidorRecusarConexao(MensagemDto mensagem)
{
if (AoReceberConexaoRecusada == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoReceberConexaoRecusada");
}
AoReceberConexaoRecusada(mensagem);
}
/// <summary>
/// Método responsável por acionar evento de ExecutarExclusaoTarefa e validar
/// seu disparo
/// </summary>
/// <param name="mensagem">MensagemDto do Tipo PermitirExclusaoTarefa</param>
public virtual void AcionarEventoExecutarExclusaoTarefa(MensagemDto mensagem)
{
if (ExecutarExclusaoTarefa == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento ExecutarExclusaoTarefa");
}
ExecutarExclusaoTarefa(mensagem);
}
/// <summary>
/// Método responsável por acionar evento de UsuarioConectadoComSucesso e validar
/// seu disparo
/// </summary>
/// <param name="mensagem">MensagemDto do Tipo ConexaoEfetuadaComSucesso</param>
public virtual void AcionarEventoDeAutorizacaoEdicaoTarefa(MensagemDto mensagem)
{
if (AoSerAutorizadaEdicaoTarefa == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoSerAutorizadaEdicaoTarefa");
}
AoSerAutorizadaEdicaoTarefa(mensagem);
}
/// <summary>
/// Método utilizado para sinalizar a permissão de edição do nome do cronograma
/// </summary>
/// <param name="objetoMensagem"></param>
public virtual void AcionarEventoAoPermitirEdicaoNomeCronograma(MensagemDto objetoMensagem)
{
if (AoSerPermitidaEdicaoDadosCronograma == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoSerPermitidaEdicaoNomeCronograma");
}
AoSerPermitidaEdicaoDadosCronograma(objetoMensagem);
}
/// <summary>
/// Método responsável por acionar evento de UsuarioConectadoComSucesso e validar
/// seu disparo
/// </summary>
/// <param name="mensagem">MensagemDto do Tipo ConexaoEfetuadaComSucesso</param>
public virtual void AcionarEventoDeConexaoEfetuadaComSucesso(MensagemDto mensagem)
{
if (AoSerAutenticadoComSucesso == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoSerAutenticadoComSucesso");
}
AoSerAutenticadoComSucesso(mensagem);
}
/// <summary>
/// Método responsável por disparar o evento ao Conectar um Novo Usuário
/// </summary>
public virtual void AcionarEventoAoConectarNovoUsuario(MensagemDto mensagem, string login)
{
if (AoConectarNovoUsuario == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoConectarNovoUsuario");
}
AoConectarNovoUsuario(mensagem, login);
}
/// <summary>
/// Responsável por efetuar correção da serialização de um vetor contido em algum indice da hashtable
/// </summary>
/// <param name="mensagem">MensagemDto que possua uma Hashtable com um vetor armazenado</param>
/// /// <param name="indice">Indice da Hashtable que possui um vetor armazenado</param>
/// <returns>MensagemDto com serialização Corrigida</returns>
private static MensagemDto EfetuarTratamentoExtracaoVetorDaMensagem(MensagemDto mensagem, string indice)
{
if (mensagem.Propriedades.ContainsKey(indice) && mensagem.Propriedades[indice] != null)
{
mensagem.Propriedades[indice] = JsonConvert.DeserializeObject <string[]>(mensagem.Propriedades[indice].ToString());
}
return(mensagem);
}
public static void CorrigirDeserializacaoPropriedade <TResult>(MensagemDto mensagem, string nomePropriedade)
{
if (!mensagem.Propriedades.ContainsKey(nomePropriedade) || mensagem.Propriedades[nomePropriedade] == null)
{
return;
}
mensagem.Propriedades[nomePropriedade] = JsonConvert.DeserializeObject <TResult>(mensagem.Propriedades[nomePropriedade].ToString());
}
/// <summary>
/// Responsável por criar uma MensagemDto de recusa de Conexão com o servidor
/// </summary>
/// <param name="motivo">Motivo da falha na conexão</param>
/// <returns>Uma MensagemDto de Recusa de Conexão</returns>
public static MensagemDto RnCriarMensagemConexaoRecusada(string motivo)
{
objetoMensagem = new MensagemDto()
{
Tipo = CsTipoMensagem.ConexaoRecusadaServidor
};
objetoMensagem.Propriedades.Add(Constantes.MOTIVO, motivo);
return(objetoMensagem);
}
/// <summary>
/// Responsável por criar uma MensagemDto de aviso de que o servidor está desconectando
/// </summary>
/// <returns>MensagemDto do Tipo ServidorDesconectado</returns>
public static MensagemDto RnCriarMensagemServidorDesconectando(string motivo)
{
objetoMensagem = new MensagemDto()
{
Tipo = CsTipoMensagem.ServidorDesconectando
};
objetoMensagem.Propriedades.Add(Constantes.MOTIVO, motivo);
return(objetoMensagem);
}
/// <summary>
/// Método responsável por validar se ainda há autoresAcao nas mensagens de ações resumidas
/// </summary>
/// <param name="mensagem"></param>
/// <returns></returns>
public static bool AindaContemAutoresAcao(MensagemDto mensagem)
{
if (mensagem.Propriedades.ContainsKey(Constantes.AUTORES_ACAO) && mensagem.Propriedades[Constantes.AUTORES_ACAO] != null)
{
Dictionary <string, string> autoresAcao = (Dictionary <string, string>)mensagem.Propriedades[Constantes.AUTORES_ACAO];
return(autoresAcao.Count > 0);
}
return(false);
}
/// <summary>
/// Método de Auxilio em testes unitários sobrescrevendo o comportarmento atual
/// acrescentando a interceptação da MensagemDto Atual.
/// </summary>
/// <param name="mensagem">MensagemDto do Tipo Permitir</param>
public override void RnResponderSolicitacaoExclusaoTarefa(MensagemDto mensagem)
{
lock (ListaTodasMensagensProcessadas)
{
ListaTodasMensagensProcessadas.Add(mensagem);
}
ContadorMensagens[(int)mensagem.Tipo]++;
base.RnResponderSolicitacaoExclusaoTarefa(mensagem);
}
/// <summary>
/// Método responsável por acionar evento de MovimentacaoPosicaoTarefa e validar
/// seu disparo
/// </summary>
/// <param name="mensagem">MensagemDto do Tipo MovimentacaoPosicaoTarefa</param>
public virtual void AcionarEventoMovimentacaoPosicaoTarefa(MensagemDto mensagem)
{
if (AoOcorrerMovimentacaoPosicaoTarefa == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoOcorrerMovimentacaoPosicaoTarefa");
}
AoOcorrerMovimentacaoPosicaoTarefa(mensagem);
}
/// <summary>
/// Método responsável por acionar evento de MovimentacaoPosicaoTarefa e validar
/// seu disparo
/// </summary>
/// <param name="mensagem">MensagemDto do Tipo MovimentacaoPosicaoTarefa</param>
public virtual void AcionarEventoAoSerNotificadoModificacaoDadosCronograma(MensagemDto mensagem)
{
if (AoSerNotificadoAlteracaoDadosCronograma == null)
{
throw new EventoNuloException("Deve ser associado um comportamento ao evento AoSerNotificadoAlteracaoNomeCronograma");
}
AoSerNotificadoAlteracaoDadosCronograma(mensagem);
}
public void RnComunicarCriacaoNovaTarefaQuandoEnviarMensagemNovaTarefaTest()
{
int contador = 0;
TcpAdapterPool poolTcp = new TcpAdapterPool();
WexMultiAccessClientMock cliente = new WexMultiAccessClientMock()
{
EnderecoIp = ipServidor,
OidCronograma = "C1",
Porta = porta,
Login = "******",
TcpAdapterStubAtivo = true
};
WexMultiAccessClientMock cliente2 = new WexMultiAccessClientMock()
{
EnderecoIp = ipServidor,
OidCronograma = "C1",
Porta = porta,
Login = "******",
TcpAdapterStubAtivo = true
};
cliente.Conectar();
poolTcp.AceitarConexao(cliente);
cliente2.Conectar();
poolTcp.AceitarConexao(cliente2);
cliente.AoServidorDesconectar += (mensagemDto) => { };
cliente2.AoServidorDesconectar += (mensagemDto) => { };
Dictionary <string, Int16> tarefasImpactadas = new Dictionary <string, short>();
tarefasImpactadas.Add("T2", 3);
tarefasImpactadas.Add("T3", 4);
tarefasImpactadas.Add("T4", 5);
tarefasImpactadas.Add("T5", 6);
tarefasImpactadas.Add("T6", 7);
tarefasImpactadas.Add("T7", 8);
DateUtil.CurrentDateTime = DateTime.Now;
cliente.RnComunicarNovaTarefaCriada("T1", "C1", null, DateUtil.CurrentDateTime);
int codigoTipoMensagem = (int)CsTipoMensagem.NovaTarefaCriada;
ControleDeEsperaUtil.AguardarAte(() => { return(cliente2.contagemTiposMensagemDtoRecebidas.ContainsKey(codigoTipoMensagem) && cliente2.contagemTiposMensagemDtoRecebidas[codigoTipoMensagem] > 0); });
MensagemDto mensagemRecebida = cliente2.MensagensRecebidas.FirstOrDefault(o => o.Tipo.Equals(CsTipoMensagem.NovaTarefaCriada));
MensagemDto objetoMensagemEsperado = Mensagem.RnCriarMensagemNovaTarefaCriada("T1", cliente.Login, "C1", null, DateUtil.CurrentDateTime);
Assert.AreEqual(objetoMensagemEsperado.Propriedades[OIDTAREFA], mensagemRecebida.Propriedades[OIDTAREFA]);
Assert.AreEqual(objetoMensagemEsperado.Propriedades[LOGIN], mensagemRecebida.Propriedades[LOGIN]);
Assert.AreEqual(objetoMensagemEsperado.Propriedades[OIDCRONOGRAMA], mensagemRecebida.Propriedades[OIDCRONOGRAMA]);
Assert.AreEqual(objetoMensagemEsperado.Propriedades[DATAHORA_ACAO], mensagemRecebida.Propriedades[DATAHORA_ACAO]);
}
