Beispiel #1
0
        private ValidacaoRiscoResponse ValidarPipeLineOrdem(ValidacaoRiscoRequest pParametros, string CodigoCarteiraRecomendada)
        {
            ValidacaoRiscoResponse PipeLineResponse = new ValidacaoRiscoResponse();

            if (pParametros.EnviarOrdemRequest.OrdemInfo.Side == RoteadorOrdens.Lib.Dados.OrdemDirecaoEnum.Compra)
            {
                PipeLineResponse = ComprarCarteiraRecomendada(pParametros, CodigoCarteiraRecomendada);
            }

            if (pParametros.EnviarOrdemRequest.OrdemInfo.Side == RoteadorOrdens.Lib.Dados.OrdemDirecaoEnum.Venda)
            {
                PipeLineResponse = VenderCarteiraRecomendada(pParametros, CodigoCarteiraRecomendada);
            }

            return(PipeLineResponse);
        }
Beispiel #2
0
        private ValidacaoRiscoResponse VenderCarteiraRecomendada(ValidacaoRiscoRequest pParametros, string CodigoCarteiraRecomendada)
        {
            ValidacaoRiscoResponse     PipeLineResponse      = new ValidacaoRiscoResponse();
            List <PipeLineCriticaInfo> CriticaInfoCollection = new List <PipeLineCriticaInfo>();
            PipeLineCriticaInfo        CriticaInfo           = null;


            logger.Info("Inicia Rotina de validação de compra de ações, cliente: " + pParametros.EnviarOrdemRequest.OrdemInfo.Account.ToString());

            logger.Info("Caracteristicas da ordem");
            logger.Info("Cliente             :" + pParametros.EnviarOrdemRequest.OrdemInfo.Account.ToString());
            logger.Info("Operação            : Compra");
            logger.Info("Instrumento         :" + pParametros.EnviarOrdemRequest.OrdemInfo.Symbol);
            logger.Info("Quantidade          :" + pParametros.EnviarOrdemRequest.OrdemInfo.OrderQty.ToString());
            logger.Info("Preco               : ORDEM A MERCADO ");
            logger.Info("DtVencimento        :" + pParametros.EnviarOrdemRequest.OrdemInfo.ExpireDate.ToString());
            logger.Info("ClasseCliente       : Institucional");


            CadastroPapeisRequest _CadastroPapeisRequest = new CadastroPapeisRequest();

            _CadastroPapeisRequest.Instrumento = pParametros.EnviarOrdemRequest.OrdemInfo.Symbol;

            CadastroPapeisResponse <CadastroPapelInfo> CadastroPapeis = new PersistenciaCarteiraRecomendada().ObterInformacoesPapeis(_CadastroPapeisRequest);


            int FatorCotacao = int.Parse(CadastroPapeis.Objeto.FatorCotacao);

            // TRATAMENTO [ FRACIONARIO / INTEGRAL ]
            int LoteNegociacao       = int.Parse(CadastroPapeis.Objeto.LoteNegociacao);
            int ModuloLoteNegociacao = pParametros.EnviarOrdemRequest.OrdemInfo.OrderQty % LoteNegociacao;

            if (pParametros.EnviarOrdemRequest.OrdemInfo.OrderQty >= LoteNegociacao)
            {
                // ENVIAR INTEGRAL
                pParametros.EnviarOrdemRequest.OrdemInfo.OrderQty -= ModuloLoteNegociacao;
                logger.Info("Inicia operação de compra de: " + pParametros.EnviarOrdemRequest.OrdemInfo.Symbol + " no mercado Integral");

                // Inseri a Ordem solicitada no banco de dados
                if (InserirOrdemCliente(pParametros.EnviarOrdemRequest))
                {
                    //TODO: COMPRA O PAPEL COM O SERVICO DE ORDENS
                    logger.Info("Compra de: " + pParametros.EnviarOrdemRequest.OrdemInfo.Symbol + " no mercado integral efetuada com sucesso.");

                    logger.Info("Envia a ordem para o roteador de ordens");

                    pParametros.EnviarOrdemRequest.OrdemInfo.Account = RetornaCodigoCliente(227, pParametros.EnviarOrdemRequest.OrdemInfo.Account);

                    ExecutarOrdemResponse RespostaRoteador = this.EnviarOrdemRoteador(pParametros.EnviarOrdemRequest.OrdemInfo);

                    pParametros.EnviarOrdemRequest.OrdemInfo.Account = int.Parse(pParametros.EnviarOrdemRequest.OrdemInfo.Account.ToString().Remove(pParametros.EnviarOrdemRequest.OrdemInfo.Account.ToString().Length - 1, 1));

                    // VERIFICA SE A ORDEM FOI ENVIADA COM SUCESSO PARA O ROTEADOR
                    if (RespostaRoteador.DadosRetorno.StatusResposta == StatusRoteamentoEnum.Sucesso)
                    {
                        logger.Info("Ordem institucional enviada com sucesso para o Roteador de Ordens");

                        PipeLineResponse.DataResposta      = DateTime.Now;
                        PipeLineResponse.DescricaoResposta = RespostaRoteador.DadosRetorno.Ocorrencias[0].Ocorrencia;
                        PipeLineResponse.StatusResposta    = OMS.Risco.Lib.Enum.CriticaRiscoEnum.Sucesso;
                    }
                    else
                    {
                        logger.Info("Ocorreu um erro ao enviar a ordem para o roteador de Ordens");

                        CriticaInfo                 = new PipeLineCriticaInfo();
                        CriticaInfo.Critica         = RespostaRoteador.DadosRetorno.Ocorrencias[0].Ocorrencia;
                        CriticaInfo.CriticaTipo     = OMS.Ordens.Lib.Enum.CriticaRiscoEnum.ErroRoteadorOrdem;
                        CriticaInfo.DataHoraCritica = DateTime.Now;

                        // Adiciona as criticas no pipeline de risco.
                        CriticaInfoCollection.Add(CriticaInfo);
                    }
                }

                if (ModuloLoteNegociacao > 0)
                {
                    // ENVIAR FRACIONARIO
                    logger.Info("Calcula restante a ser enviado para o mercado fracionário");

                    // ENVIAR FRACIONARIO
                    pParametros.EnviarOrdemRequest.OrdemInfo.OrderQty = ModuloLoteNegociacao;
                    pParametros.EnviarOrdemRequest.OrdemInfo.Symbol  += "F";
                    pParametros.EnviarOrdemRequest.OrdemInfo.ClOrdID  = this.CtrlNumber(CodigoCarteiraRecomendada);

                    logger.Info("Inicia compra de: " + pParametros.EnviarOrdemRequest.OrdemInfo.Symbol + " no mercado fracionário");

                    // Inseri a Ordem solicitada no banco de dados
                    if (InserirOrdemCliente(pParametros.EnviarOrdemRequest))
                    {
                        //TODO: COMPRA O PAPEL COM O SERVICO DE ORDENS
                        logger.Info("Compra de: " + pParametros.EnviarOrdemRequest.OrdemInfo.Symbol + " no mercado fracionario efetuada com sucesso.");

                        logger.Info("Envia a ordem para o roteador de ordens");

                        pParametros.EnviarOrdemRequest.OrdemInfo.Account = RetornaCodigoCliente(227, pParametros.EnviarOrdemRequest.OrdemInfo.Account);

                        ExecutarOrdemResponse RespostaRoteador = this.EnviarOrdemRoteador(pParametros.EnviarOrdemRequest.OrdemInfo);

                        pParametros.EnviarOrdemRequest.OrdemInfo.Account = int.Parse(pParametros.EnviarOrdemRequest.OrdemInfo.Account.ToString().Remove(pParametros.EnviarOrdemRequest.OrdemInfo.Account.ToString().Length - 1, 1));

                        // VERIFICA SE A ORDEM FOI ENVIADA COM SUCESSO PARA O ROTEADOR
                        if (RespostaRoteador.DadosRetorno.StatusResposta == StatusRoteamentoEnum.Sucesso)
                        {
                            logger.Info("Ordem enviada com sucesso para o Roteador de Ordens");

                            PipeLineResponse.DataResposta      = DateTime.Now;
                            PipeLineResponse.DescricaoResposta = RespostaRoteador.DadosRetorno.Ocorrencias[0].Ocorrencia;
                            PipeLineResponse.StatusResposta    = OMS.Risco.Lib.Enum.CriticaRiscoEnum.Sucesso;
                        }
                        else
                        {
                            logger.Info("Ocorreu um erro ao enviar a ordem para o roteador de Ordens");

                            CriticaInfo                 = new PipeLineCriticaInfo();
                            CriticaInfo.Critica         = RespostaRoteador.DadosRetorno.Ocorrencias[0].Ocorrencia;
                            CriticaInfo.CriticaTipo     = OMS.Ordens.Lib.Enum.CriticaRiscoEnum.ErroRoteadorOrdem;
                            CriticaInfo.DataHoraCritica = DateTime.Now;

                            // Adiciona as criticas no pipeline de risco.
                            CriticaInfoCollection.Add(CriticaInfo);
                        }
                    }
                }
            }
            else
            {
                //FRACIONARIO
                pParametros.EnviarOrdemRequest.OrdemInfo.Symbol += "F";

                logger.Info("Inicia compra de: " + pParametros.EnviarOrdemRequest.OrdemInfo.Symbol + " no mercado fracionário");

                // Inseri a Ordem solicitada no banco de dados
                if (InserirOrdemCliente(pParametros.EnviarOrdemRequest))
                {
                    //TODO: COMPRA O PAPEL COM O SERVICO DE ORDENS
                    logger.Info("Compra de: " + pParametros.EnviarOrdemRequest.OrdemInfo.Symbol + " no mercado fracionário efetuada com sucesso.");

                    //ENVIA ORDEM PARA O ROTEADOR
                    pParametros.EnviarOrdemRequest.OrdemInfo.Account = RetornaCodigoCliente(227, pParametros.EnviarOrdemRequest.OrdemInfo.Account);

                    logger.Info("Envia a ordem para o roteador de ordens");


                    var RespostaRoteador = this.EnviarOrdemRoteador(pParametros.EnviarOrdemRequest.OrdemInfo);

                    pParametros.EnviarOrdemRequest.OrdemInfo.Account = int.Parse(pParametros.EnviarOrdemRequest.OrdemInfo.Account.ToString().Remove(pParametros.EnviarOrdemRequest.OrdemInfo.Account.ToString().Length - 1, 1));

                    //// VERIFICA SE A ORDEM FOI ENVIADA COM SUCESSO PARA O ROTEADOR
                    if (RespostaRoteador.DadosRetorno.StatusResposta == StatusRoteamentoEnum.Sucesso)
                    {
                        logger.Info("Ordem enviada com sucesso para o Roteador de Ordens");

                        PipeLineResponse.DataResposta      = DateTime.Now;
                        PipeLineResponse.DescricaoResposta = RespostaRoteador.DadosRetorno.Ocorrencias[0].Ocorrencia;
                        PipeLineResponse.StatusResposta    = OMS.Risco.Lib.Enum.CriticaRiscoEnum.Sucesso;
                    }
                    else
                    {
                        logger.Info("Ocorreu um erro ao enviar a ordem para o roteador de Ordens");

                        CriticaInfo                 = new PipeLineCriticaInfo();
                        CriticaInfo.Critica         = RespostaRoteador.DadosRetorno.Ocorrencias[0].Ocorrencia;
                        CriticaInfo.CriticaTipo     = OMS.Ordens.Lib.Enum.CriticaRiscoEnum.ErroRoteadorOrdem;
                        CriticaInfo.DataHoraCritica = DateTime.Now;

                        // Adiciona as criticas no pipeline de risco.
                        CriticaInfoCollection.Add(CriticaInfo);
                    }
                }
            }

            return(PipeLineResponse);
        }
Beispiel #3
0
        public EnviarOrdemResponse EnviarOrdem(EnviarOrdemRequest pParametros, string CodigoCarteiraRecomendada)
        {
            EnviarOrdemResponse OrdemResposta = new EnviarOrdemResponse();

            OrdemFIXResponse <OrdemInfo> OrdemFixResponse = this.ParsearOrdemCliente(pParametros.ClienteOrdemInfo, CodigoCarteiraRecomendada);

            if (OrdemFixResponse.StatusResposta == OMS.Ordens.Lib.Enum.CriticaRiscoEnum.Sucesso)
            {
                EnviarOrdemRoteadorRequest OrdemRoteadorRequest = new EnviarOrdemRoteadorRequest();
                OrdemRoteadorRequest.OrdemInfo = OrdemFixResponse.Objeto;

                ValidacaoRiscoRequest RiscoRequisicao = new ValidacaoRiscoRequest();
                RiscoRequisicao.EnviarOrdemRequest = OrdemRoteadorRequest;

                ValidacaoRiscoResponse RiscoResposta = this.ValidarPipeLineOrdem(RiscoRequisicao, CodigoCarteiraRecomendada);

                if (RiscoResposta.CriticaInfo.Count >= 0)
                {
                    OrdemResposta.CriticaInfo = new List <PipeLineCriticaInfo>();

                    foreach (var RiscoItem in RiscoResposta.CriticaInfo)
                    {
                        PipeLineCriticaInfo _PipeLineCriticaInfo = new PipeLineCriticaInfo();

                        OrdemResposta.CriticaInfo.Add(
                            new PipeLineCriticaInfo()
                        {
                            Critica         = RiscoItem.Critica,
                            CriticaTipo     = (OMS.Ordens.Lib.Enum.CriticaRiscoEnum)RiscoItem.CriticaTipo,
                            DataHoraCritica = RiscoItem.DataHoraCritica
                        });
                    }

                    OrdemResposta.DataResposta      = RiscoResposta.DataResposta;
                    OrdemResposta.DescricaoResposta = RiscoResposta.DescricaoResposta;
                    OrdemResposta.StackTrace        = RiscoResposta.StackTrace;
                    OrdemResposta.StatusResposta    = (OMS.Ordens.Lib.Enum.CriticaRiscoEnum)RiscoResposta.StatusResposta;
                }
                else
                {
                    OrdemResposta.CriticaInfo = new List <PipeLineCriticaInfo>();

                    foreach (var RiscoItem in OrdemFixResponse.CriticaInfo)
                    {
                        PipeLineCriticaInfo _PipeLineCriticaInfo = new PipeLineCriticaInfo();

                        OrdemResposta.CriticaInfo.Add(
                            new PipeLineCriticaInfo()
                        {
                            Critica         = RiscoItem.Critica,
                            CriticaTipo     = (OMS.Ordens.Lib.Enum.CriticaRiscoEnum)RiscoItem.CriticaTipo,
                            DataHoraCritica = RiscoItem.DataHoraCritica
                        });
                    }

                    OrdemResposta.DataResposta      = OrdemResposta.DataResposta;
                    OrdemResposta.DescricaoResposta = OrdemResposta.DescricaoResposta;
                    OrdemResposta.StackTrace        = OrdemResposta.StackTrace;
                    OrdemResposta.StatusResposta    = (OMS.Ordens.Lib.Enum.CriticaRiscoEnum)OrdemResposta.StatusResposta;
                }
            }

            return(OrdemResposta);
        }
Beispiel #4
0
        /// <summary>
        /// Metodo responsável por invocar o pipeline de risco a verificar todos os parametros e permissões
        /// da ordem a ser enviada para o roteador de ordem. [ Efetua todo o controle pré-trading da ordem ]
        /// </summary>
        /// <param name="pParametros">Objeto de entidade da ordem do cliente</param>
        /// <returns> Resposta da requisição </returns>
        public EnviarOrdemResponse EnviarOrdem(EnviarOrdemRequest pParametros)
        {
            try
            {
                logger.Info("Solicitacao en envio de ordem acatada. Cliente: " + pParametros.ClienteOrdemInfo.CodigoCliente.ToString());

                logger.Info("Cliente.....             " + pParametros.ClienteOrdemInfo.CodigoCliente.ToString());
                logger.Info("CodigoStopStart.....     " + pParametros.ClienteOrdemInfo.CodigoStopStart.ToString());
                logger.Info("DataHoraSolicitacao..... " + pParametros.ClienteOrdemInfo.DataHoraSolicitacao.ToString());
                logger.Info("DataValidade.....        " + pParametros.ClienteOrdemInfo.DataValidade.ToString());
                logger.Info("DirecaoOrdem.....        " + pParametros.ClienteOrdemInfo.DirecaoOrdem.ToString());
                logger.Info("Instrumento.....         " + pParametros.ClienteOrdemInfo.Instrumento.ToString());
                logger.Info("Preco.....               " + pParametros.ClienteOrdemInfo.Preco.ToString());
                logger.Info("Quantidade.....          " + pParametros.ClienteOrdemInfo.Quantidade.ToString());
                logger.Info("TipoDeOrdem.....         " + pParametros.ClienteOrdemInfo.TipoDeOrdem.ToString());
                logger.Info("ValidadeOrdem.....       " + pParametros.ClienteOrdemInfo.ValidadeOrdem.ToString());
                logger.Info("QuantidadeMinima...      " + pParametros.ClienteOrdemInfo.QuantidadeMinima.ToString());
                logger.Info("QuantidadeAparente...    " + pParametros.ClienteOrdemInfo.QuantidadeAparente.ToString());

                EnviarOrdemResponse OrdemResposta = new EnviarOrdemResponse();

                #region  [ Validação do formato da mensagem enviada ]

                logger.Info("Verifica se todos os campos da solicitação foram preenchidos corretamente");

                // VALIDA SE OS ATRIBUTOS INFORMADOS PELO CLIENTE SÃO VALIDOS
                ValidarFormatoOrdemResponse ValidarFormatoOrdemResponse =
                    this.ValidarFormatoOrdemCliente(pParametros.ClienteOrdemInfo);

                //Obtem o numero da porta de controle a ser roteada pelo OMS

                #region Obter a porta de roteamento pelo perfil do cliente

                //logger.Info("Verifica a porta que a ordem sera roteada");
                //if (pParametros.ClienteOrdemInfo.PortaControleOrdem != CodigoPortaRepassadorOrdem.ToString())
                //{
                //    int GrupoAlavancagemCliente = new PersistenciaOrdens().ObterCodigoGrupoAlavancagem(pParametros.ClienteOrdemInfo.CodigoCliente);
                //    logger.Info("Codigo do grupo de alavancagem do cliente : " + GrupoAlavancagemCliente.ToString());

                //    if(GrupoAlavancagemCliente == CodigoGrupoAlavancagemHomeBroker)
                //    {
                //        logger.Info("Cliente HomeBroker");
                //        pParametros.ClienteOrdemInfo.PortaControleOrdem = CodigoPortaClienteHomeBroker.ToString();
                //    }

                //    if (GrupoAlavancagemCliente == CodigoGrupoAlavancagemDesktop)
                //    {
                //        logger.Info("Cliente Assessor");
                //        pParametros.ClienteOrdemInfo.PortaControleOrdem = CodigoPortaClienteAssessor.ToString();
                //    }

                //    if ((GrupoAlavancagemCliente != CodigoGrupoAlavancagemDesktop) && (GrupoAlavancagemCliente != CodigoGrupoAlavancagemHomeBroker))
                //    {
                //        // caso não encontre cobrar tabela mesa.
                //        pParametros.ClienteOrdemInfo.PortaControleOrdem = CodigoPortaClienteAssessor.ToString();
                //    }

                //    logger.Info("Numero da porta a ser roteado : " + pParametros.ClienteOrdemInfo.PortaControleOrdem);
                //}
                //else
                //{
                //    pParametros.ClienteOrdemInfo.PortaControleOrdem = CodigoPortaRepassadorOrdem.ToString();
                //    logger.Info("Numero da porta a ser roteado : " + pParametros.ClienteOrdemInfo.PortaControleOrdem);
                //}

                #endregion

                // VERIFICA SE A MENSAGEM ENVIADA PELO CLIENTE É VALIDA.
                if (ValidarFormatoOrdemResponse.StatusResposta == CriticaRiscoEnum.Sucesso)
                {
                    #region  [ Parseador de Mensagem FIX ]

                    logger.Info("Inicia composição da mensagem FIX");

                    // INICIA PARSEADOR DE MENSAGEM PARA O FORMATO FIX.
                    OrdemFIXResponse <OrdemInfo> OrdemFixResponse = this.ParsearOrdemCliente(pParametros.ClienteOrdemInfo);

                    if (OrdemFixResponse.StatusResposta == CriticaRiscoEnum.ErroNegocio)
                    {
                        logger.Info("Mensagem FIX contem com sucesso");
                        logger.Info("Descrição da critica    : Instrumento não encontrado");

                        //VERIFICA SE EXISTEM CRITICAS A SEREM OBSERVADAS
                        if (OrdemFixResponse.CriticaInfo.Count >= 0)
                        {
                            OrdemResposta.CriticaInfo =
                                new List <PipeLineCriticaInfo>();

                            // EFETUA O DE / PARA DOS OBJETOS PARA NÃO CRIAR VINCULO ALGUM ENTRE
                            // AS BIBLIOTECAS DE RISCO E ORDEM
                            foreach (var RiscoItem in OrdemFixResponse.CriticaInfo)
                            {
                                PipeLineCriticaInfo _PipeLineCriticaInfo
                                    = new PipeLineCriticaInfo();

                                OrdemResposta.CriticaInfo.Add(
                                    new PipeLineCriticaInfo()
                                {
                                    Critica         = RiscoItem.Critica,
                                    CriticaTipo     = (CriticaRiscoEnum)RiscoItem.CriticaTipo,
                                    DataHoraCritica = RiscoItem.DataHoraCritica
                                });
                            }

                            // FORMATA A MENSAGEM DE SAIDA
                            OrdemResposta.DataResposta      = OrdemFixResponse.DataResposta;
                            OrdemResposta.DescricaoResposta = OrdemFixResponse.DescricaoResposta;
                            OrdemResposta.StackTrace        = OrdemFixResponse.StackTrace;
                            OrdemResposta.StatusResposta    = (CriticaRiscoEnum)OrdemFixResponse.StatusResposta;

                            return(OrdemResposta);
                        }
                    }

                    #endregion

                    logger.Info("Mensagem FIX composta com sucesso");

                    // OBTEM A ORDEM JÁ PARSEADA NO FORMATO FIX.
                    EnviarOrdemRoteadorRequest OrdemRoteadorRequest = new EnviarOrdemRoteadorRequest()
                    {
                        OrdemInfo = OrdemFixResponse.Objeto
                    };

                    #endregion

                    #region [ Efetua chamada para as validações do sistema de risco ]

                    ValidacaoRiscoRequest RiscoRequisicao = new ValidacaoRiscoRequest()
                    {
                        EnviarOrdemRequest = OrdemRoteadorRequest
                    };

                    logger.Info("Inicia rotina de validação de risco: PipeLine Risco");

                    DateTime DataInicioExecucao = DateTime.Now;
                    logger.Info("Data inicial da solicitação:     " + DataInicioExecucao.ToString());

                    // EFETUA CHAMADA DO METODO VALIDAPIPEPINE RISCO PARA VALIDAR A ORDEM ENVIADA PELO CLIENTE.
                    ValidacaoRiscoResponse RiscoResposta =
                        new ServicoRisco().ValidarPipeLineRisco(RiscoRequisicao);

                    TimeSpan datafinal = (DateTime.Now - DataInicioExecucao);

                    #endregion

                    #region [ Tratamento da resposta da validação de risco ]

                    logger.Info("Prepara a resposta da solicitação");

                    //VERIFICA SE EXISTEM CRITICAS A SEREM OBSERVADAS
                    if (RiscoResposta.CriticaInfo.Count >= 0)
                    {
                        OrdemResposta.CriticaInfo =
                            new List <PipeLineCriticaInfo>();

                        // EFETUA O DE / PARA DOS OBJETOS PARA NÃO CRIAR VINCULO ALGUM ENTRE
                        // AS BIBLIOTECAS DE RISCO E ORDEM
                        foreach (var RiscoItem in RiscoResposta.CriticaInfo)
                        {
                            PipeLineCriticaInfo _PipeLineCriticaInfo
                                = new PipeLineCriticaInfo();

                            OrdemResposta.CriticaInfo.Add(
                                new PipeLineCriticaInfo()
                            {
                                Critica         = RiscoItem.Critica,
                                CriticaTipo     = (CriticaRiscoEnum)RiscoItem.CriticaTipo,
                                DataHoraCritica = RiscoItem.DataHoraCritica
                            });
                        }

                        // FORMATA A MENSAGEM DE SAIDA
                        OrdemResposta.DataResposta      = RiscoResposta.DataResposta;
                        OrdemResposta.DescricaoResposta = RiscoResposta.DescricaoResposta;
                        OrdemResposta.StackTrace        = RiscoResposta.StackTrace;
                        OrdemResposta.StatusResposta    = (CriticaRiscoEnum)RiscoResposta.StatusResposta;

                        logger.Info("Solicitação de resposta enviado ao solicitante com sucesso.");
                        logger.Info("Tempo Total de execução   :" + datafinal.ToString());
                    }

                    #endregion
                }
                else
                // ERRO NA FORMATACAO DA MENSAGEM
                if (ValidarFormatoOrdemResponse.StatusResposta == CriticaRiscoEnum.ErroFormatoMensagem)
                {
                    logger.Info("Ocorreu um erro ao formatar a mensagem de retorno.");

                    #region [ Efetua tratamento da resposta da validação da mensamgem ]

                    OrdemResposta.CriticaInfo =
                        new List <PipeLineCriticaInfo>();

                    // EFETUA O DE / PARA DOS OBJETOS PARA NÃO CRIAR VINCULO ALGUM ENTRE
                    // AS BIBLIOTECAS DE RISCO E ORDEM
                    foreach (var RiscoItem in ValidarFormatoOrdemResponse.CriticaInfo)
                    {
                        PipeLineCriticaInfo _PipeLineCriticaInfo
                            = new PipeLineCriticaInfo();

                        OrdemResposta.CriticaInfo.Add(
                            new PipeLineCriticaInfo()
                        {
                            Critica         = RiscoItem.Critica,
                            CriticaTipo     = (CriticaRiscoEnum)RiscoItem.CriticaTipo,
                            DataHoraCritica = RiscoItem.DataHoraCritica
                        });
                    }

                    // FORMATA A MENSAGEM DE SAIDA
                    OrdemResposta.DataResposta      = ValidarFormatoOrdemResponse.DataResposta;
                    OrdemResposta.DescricaoResposta = ValidarFormatoOrdemResponse.DescricaoResposta;
                    OrdemResposta.StackTrace        = ValidarFormatoOrdemResponse.StackTrace;
                    OrdemResposta.StatusResposta    = (CriticaRiscoEnum)ValidarFormatoOrdemResponse.StatusResposta;

                    logger.Info("Envia mensagem de retorno com o erro.");

                    #endregion
                }

                return(OrdemResposta);
            }
            catch (Exception ex)
            {
                logger.Error("Erro :" + ex.Message, ex);
                return(null);
            }
        }