Exemplo n.º 1
0
        /// <summary>
        /// Consulta na memória Efetuando um query de Linq dentro de uma hashtable que está na memória
        /// </summary>
        /// <param name="pRequest">Request do papel negociado</param>
        /// <returns>Retorna uma lista dos papeis que estão em na memória</returns>
        public ConsultarPapelNegociadoResponse ConsultarPapelNegociado(ConsultarPapelNegociadoRequest pRequest)
        {
            ConsultarPapelNegociadoResponse lResposta = new ConsultarPapelNegociadoResponse(pRequest.CodigoMensagem);

            PapelNegociadoBmfDbLib lPapelBmfDb = new PapelNegociadoBmfDbLib();

            PapelNegociadoBovespaDbLib lPapelBovespaDb = new PapelNegociadoBovespaDbLib();

            bool lPapelEncontrado = false;

            string lAtivosParaLog = "";

            List <string> lstAtivosTemp = new List <string>();

            foreach (string lAtivo in pRequest.LstAtivos)
            {
                lAtivosParaLog += string.Format("{0}, ", lAtivo);

                if (lAtivo.ToLower().Substring(lAtivo.Length - 1).Equals("f"))
                {
                    lstAtivosTemp.Add(lAtivo.Remove(lAtivo.Length - 1));
                }
                else
                {
                    lstAtivosTemp.Add(lAtivo);
                }
            }

            lAtivosParaLog = lAtivosParaLog.TrimEnd(", ".ToCharArray());

            logger.InfoFormat("> Chamada ConsultarPapelNegociado [{0}]", lAtivosParaLog);

            try
            {
                //Se ainda não estiver carregado, pedimos para carregar novamente os dados na
                //hashtable chamando o método ListarPapeisNegociadosBovespaBmf
                if (ListaPapeisNegociados == null)
                {
                    ListarPapeisNegociadosBovespaBmf(null);

                    logger.InfoFormat("HashTable de Papéis negociados preenchida com [{0}] entradas", ListaPapeisNegociados.Count);
                }

                //lock (ListaPapeisNegociados)
                //{
                var lPapeis = from a in ListaPapeisNegociados.Cast <DictionaryEntry>()
                              select a;

                logger.InfoFormat("[{0}] Papéis selecionados depois do cast", lPapeis.Count());

                if (lPapeis.Count() > 0)
                {
                    ///Filtro de ativos
                    if (pRequest.LstAtivos.Count > 0)
                    {
                        if (pRequest.LstAtivos.Count == 1)
                        {
                            string lBusca = pRequest.LstAtivos[0];

                            if (lBusca.ToLower().Substring(lBusca.Length - 1).Equals("f"))
                            {
                                lBusca = lBusca.Remove(lBusca.Length - 1);
                            }

                            lPapeis = from a in ListaPapeisNegociados.Cast <DictionaryEntry>()
                                      where a.Key.ToString().Contains(lBusca)
                                      select a;
                        }
                        else
                        {
                            lPapeis = from a in ListaPapeisNegociados.Cast <DictionaryEntry>()
                                      where lstAtivosTemp.Contains(a.Key.ToString())
                                      select a;
                        }
                    }

                    //filtro com a data de vencimento no resultado
                    if (pRequest.DataVencimento != null)
                    {
                        lPapeis = lPapeis.Where(delegate(DictionaryEntry dic)
                        {
                            bool lReturn = false;

                            string lNameType = dic.Value.GetType().Name;

                            if (lNameType.Equals("PapelNegociadoBovespaInfo"))
                            {
                                lReturn = (((PapelNegociadoBovespaInfo)dic.Value).DataVencimento != null && ((PapelNegociadoBovespaInfo)dic.Value).DataVencimento.Value.ToString("dd/MM/yyyy").Equals(pRequest.DataVencimento.Value.ToString("dd/MM/yyyy")));
                            }

                            else if (lNameType.Equals("PapelNegociadoBmfInfo"))
                            {
                                lReturn = (((PapelNegociadoBmfInfo)dic.Value).DataVencimento != null && ((PapelNegociadoBmfInfo)dic.Value).DataVencimento.Value.ToString("dd/MM/yyyy").Equals(pRequest.DataVencimento.Value.ToString("dd/MM/yyyy")));
                            }

                            else
                            {
                                return(lReturn);
                            }

                            return(lReturn);
                        });
                    }

                    ///Filtro com o tipo de mercado no resultado
                    if (!pRequest.TipoMercado.Equals(0))
                    {
                        lPapeis = lPapeis.Where(delegate(DictionaryEntry dic)
                        {
                            string lNameType = dic.Value.GetType().Name;

                            if (lNameType.Equals("PapelNegociadoBovespaInfo"))
                            {
                                return(((PapelNegociadoBovespaInfo)dic.Value).TipoMercado == pRequest.TipoMercado);
                            }
                            else
                            {
                                return(false);
                            }
                        });
                    }

                    ///Filtro de Tipo Segmento de mercado: Se for BMF efetua o filtro
                    if (pRequest.DescTipoMercado != null && pRequest.DescTipoMercado.Equals("BMF"))
                    {
                        lPapeis = lPapeis.Where(delegate(DictionaryEntry dic)
                        {
                            string lNameType = dic.Value.GetType().Name;

                            if (lNameType.Equals("PapelNegociadoBmfInfo"))
                            {
                                return(pRequest.DescTipoMercado.Equals("BMF"));
                            }
                            else
                            {
                                return(false);
                            }
                        });
                    }

                    if (pRequest.DescTipoMercado != null && pRequest.DescTipoMercado.Equals("BOV"))
                    {
                        lPapeis = lPapeis.Where(delegate(DictionaryEntry dic)
                        {
                            string lNameType = dic.Value.GetType().Name;

                            if (lNameType.Equals("PapelNegociadoBovespaInfo"))
                            {
                                return(pRequest.DescTipoMercado.Equals("BOV"));
                            }
                            else
                            {
                                return(false);
                            }
                        });
                    }

                    foreach (var item in lPapeis)
                    {
                        var lItem = item.Value;

                        string lNameType = item.Value.GetType().Name;

                        if (lNameType.Equals("PapelNegociadoBmfInfo"))
                        {
                            lResposta.LstPapelBmfInfo.Add((PapelNegociadoBmfInfo)item.Value);
                        }

                        if (lNameType.Equals("PapelNegociadoBovespaInfo"))
                        {
                            lResposta.LstPapelBovespaInfo.Add((PapelNegociadoBovespaInfo)item.Value);
                        }

                        if (!lResposta.LstPapelInfo.Contains(item.Key))
                        {
                            lResposta.LstPapelInfo.Add(item.Key, item.Value);
                        }
                    }

                    lPapelEncontrado = true;

                    string lAtivo = "n/e";

                    if (pRequest.LstAtivos.Count > 0)
                    {
                        lAtivo = pRequest.LstAtivos[0];
                    }

                    logger.InfoFormat("< Papel [{0}] encontrado com sucesso. LstPapelBmfInfo.Count: [{1}], LstPapelBovespaInfo.Count: [{2}], LstPapelInfo.Count: [{3}]"
                                      , lAtivo
                                      , lResposta.LstPapelBmfInfo.Count
                                      , lResposta.LstPapelBovespaInfo.Count
                                      , lResposta.LstPapelInfo.Count);
                }

                if (lPapelEncontrado)
                {
                    lResposta.DescricaoResposta = "Ativo(s) encontrado(s) com sucesso.";
                    lResposta.StatusResposta    = MensagemResponseStatusEnum.OK;
                }
                else
                {
                    lResposta.DescricaoResposta = "Ativo(s) não encontrado(s)";
                    lResposta.StatusResposta    = MensagemResponseStatusEnum.ErroValidacao;
                }
                //}
            }
            catch (Exception ex)
            {
                lResposta.DescricaoResposta = ex.Message;
                lResposta.StatusResposta    = MensagemResponseStatusEnum.ErroPrograma;
                logger.Error(ex.StackTrace);
            }

            return(lResposta);
        }
Exemplo n.º 2
0
        private void ListarPapeisNegociadosBovespaBmf(object pStateTransaction)
        {
            try
            {
                PapelNegociadoBmfDbLib       lPapelBmfDb  = new PapelNegociadoBmfDbLib();
                List <PapelNegociadoBmfInfo> listPapelBmf = lPapelBmfDb.ListarPapelNegociadoBmf();

                PapelNegociadoBovespaDbLib       lPapelBovespaDb  = new PapelNegociadoBovespaDbLib();
                List <PapelNegociadoBovespaInfo> listPapelBovespa = lPapelBovespaDb.ListarPapelNegociadoBovespa();

                ListaPapeisNegociados = new Hashtable();
                ListaPapeisNegociados.Clear();

                lock (ListaPapeisNegociados)
                {
                    foreach (PapelNegociadoBovespaInfo item in listPapelBovespa)
                    {
                        if (!ListaPapeisNegociados.Contains(item.CodNegociacao.Trim()))
                        {
                            ListaPapeisNegociados.Add(item.CodNegociacao.Trim(), item);
                        }
                    }

                    foreach (PapelNegociadoBmfInfo item in listPapelBmf)
                    {
                        if (!ListaPapeisNegociados.Contains(string.Concat(item.CodMercadoria.Trim(), item.SerieVencimento.Trim())))
                        {
                            ListaPapeisNegociados.Add(string.Concat(item.CodMercadoria.Trim(), item.SerieVencimento.Trim()), item);
                        }
                    }

                    logger.Info(string.Concat("Entrou no ListarPapeisNegociadosBovespaBmf e listou ", ListaPapeisNegociados.Count, " papeis"));
                }

                ListaCadastroPapeisMDS = new Dictionary <string, CadastroPapelMdsInfo>();
                ListaCadastroPapeisMDS.Clear();

                lock (ListaCadastroPapeisMDS)
                {
                    CadastroPapeisMdsDbLib lCadastroPapeisMdsDb = new CadastroPapeisMdsDbLib();
                    lCadastroPapeisMdsDb._ConnectionStringName = ConnectionStringMDS;
                    ListaCadastroPapeisMDS = lCadastroPapeisMdsDb.ListarCadastroPapeisMDS();
                    logger.Info(string.Concat("Entrou no ListarCadastroPapeisMDS e listou ", ListaCadastroPapeisMDS.Count, " papeis"));

                    List <string> ListaComposicaoIndicesMDS = lCadastroPapeisMdsDb.ListarComposicaoIndicesMDS();
                    logger.Info(string.Concat("Entrou no ListarComposicaoIndicesMDS e listou ", ListaComposicaoIndicesMDS.Count, " papeis"));

                    foreach (string item in ListaComposicaoIndicesMDS)
                    {
                        string[] composicaoIndice = item.Split('@');
                        string   indice           = composicaoIndice[0];
                        string   instrumento      = composicaoIndice[1];

                        if (ListaCadastroPapeisMDS.ContainsKey(instrumento))
                        {
                            CadastroPapelMdsInfo dadosInstrumento = ListaCadastroPapeisMDS[instrumento];
                            dadosInstrumento.ComposicaoIndice  += indice + ",";
                            ListaCadastroPapeisMDS[instrumento] = dadosInstrumento;
                        }
                        else
                        {
                            logger.Error("Ops, nao ha instrumento [" + instrumento + "] na ListaCadastroPapeisMDS, erro na composicao de Indice");
                        }
                    }
                    logger.Info("Composição dos Indices atualizado");
                }
            }
            catch (Exception ex)
            {
                logger.Error(pStateTransaction, ex);
            }
        }