Exemple #1
0
        private bool InserirOrdemCliente(EnviarOrdemRoteadorRequest pParametros)
        {
            pParametros.OrdemInfo.OrderQtyRemmaining = pParametros.OrdemInfo.OrderQty;

            // Inseri a Ordem solicitada no banco de dados
            return(new PersistenciaOrdens().InserirOrdemCliente(pParametros.OrdemInfo));
        }
Exemple #2
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);
        }
Exemple #3
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);
            }
        }