Exemple #1
0
        public static List <LOAItemOferta> resetLivro(List <LOAGrupoOfertas> agregado,
                                                      List <LOFDadosOferta> livro,
                                                      List <LOFDadosOferta> listaLOF)
        {
            List <LOAItemOferta> retorno = new List <LOAItemOferta>();

            for (int i = 0; i < livro.Count; i++)
            {
                LOFDadosOferta oferta = livro[i];
                oferta.Posicao = i;
                listaLOF.Add(oferta);
                livro.RemoveAt(i);
            }

            for (int i = agregado.Count - 1; i >= 0; i--)
            {
                LOAGrupoOfertas grupo = agregado[i];
                agregado.RemoveAt(i);

                LOAItemOferta itemOferta = new LOAItemOferta();
                itemOferta.Indice     = i;
                itemOferta.Preco      = grupo.Preco;
                itemOferta.Quantidade = grupo.Quantidade;
                itemOferta.QtdeOrdens = grupo.QtdeOrdens;
                itemOferta.Acao       = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_EXCLUIR;

                retorno.Add(itemOferta);
            }

            return(retorno);
        }
Exemple #2
0
 public LOAGrupoOfertas(Decimal preco2, LOFDadosOferta oferta, int indice)
 {
     this.Preco      = preco2;
     this.Quantidade = oferta.Quantidade;
     this.Indice     = indice;
     this.QtdeOrdens = 1;
 }
Exemple #3
0
        public static void alteraOfertaLOF(String instrumento, List <LOFDadosOferta> livro, LOFDadosOferta oferta, int sentido)
        {
            LOFDadosOferta ofertaVelha = livro[oferta.Posicao];

            ofertaVelha.Posicao = oferta.Posicao;

            String descricaoSentido = (sentido == LIVRO_VENDA ? "Compra" : "Venda");

            // Se for alteracao da oferta sem mudar o preco
            if (ofertaVelha.Preco.CompareTo(oferta.Preco) == 0)
            {
                if (logger.IsDebugEnabled)
                {
                    logger.DebugFormat("LOF [{0}]: Altera oferta {1} [{2}] [{3}] [{4}] [{5}]",
                                       instrumento, descricaoSentido, oferta.IDOferta, oferta.Preco, oferta.Quantidade, oferta.Posicao);
                }

                livro[oferta.Posicao] = oferta;
            }
            else
            {
                if (logger.IsDebugEnabled)
                {
                    logger.DebugFormat("LOF [{0}]: Altera oferta {1} [{2}] [{3}] --> [{4}] [{5}]",
                                       instrumento, descricaoSentido, ofertaVelha.IDOferta, ofertaVelha.Preco, oferta.IDOferta, oferta.Preco);
                }

                removeOfertaLOF(instrumento, livro, ofertaVelha, sentido);
                insereOfertaLOF(instrumento, livro, oferta, sentido);
            }
        }
Exemple #4
0
        public static List <Dictionary <String, String> > montaLivroOfertasCompleto(
            LivroOfertasBase livroOferta, int sentido, int casasDecimais)
        {
            List <Dictionary <String, String> > mensagem =
                new List <Dictionary <String, String> >();

            List <LOFDadosOferta> livro = null;

            if (sentido == LivroOfertasBase.LIVRO_COMPRA)
            {
                livro = livroOferta.getLivroCompra();
            }
            else
            {
                livro = livroOferta.getLivroVenda();
            }


            for (int posicao = 0; posicao < livro.Count; posicao++)
            {
                LOFDadosOferta item = livro[posicao];

                item.Posicao = posicao;

                mensagem.Add(LOFDadosOferta.montarRegistroOferta(ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_INCLUIR, item, casasDecimais));
            }

            return(mensagem);
        }
Exemple #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="livroOferta"></param>
        /// <param name="numeroItens"></param>
        /// <param name="sentido"></param>
        /// <returns></returns>
        public static string montaMensagemHomeBrokerLOF(List <LOFDadosOferta> livroOferta, int numeroItens, int sentido)
        {
            StringBuilder mensagem = new StringBuilder();

            String side        = (sentido == LIVRO_COMPRA) ? "C" : "V";
            int    posicaoItem = 0;

            while (posicaoItem < numeroItens &&
                   posicaoItem < livroOferta.Count)
            {
                LOFDadosOferta itemOferta = livroOferta[posicaoItem];

                mensagem.Append(side);
                mensagem.Append(String.Format("{0:d8}", itemOferta.Corretora));
                if (itemOferta.Preco == ConstantesMDS.PRECO_LIVRO_OFERTAS_MIN_VALUE || itemOferta.Preco == ConstantesMDS.PRECO_LIVRO_OFERTAS_MAX_VALUE)
                {
                    mensagem.Append(String.Format("{0,-13}", ConstantesMDS.DESCRICAO_OFERTA_ABERTURA));
                }
                else
                {
                    mensagem.Append(itemOferta.Preco.ToString("0000000000.00"));
                }
                mensagem.Append(String.Format("{0:d12}", itemOferta.Quantidade));

                posicaoItem++;
            }

            mensagem.Replace('.', ',');

            return(mensagem.ToString());
        }
Exemple #6
0
        public static List <LOAItemOferta> removeOferta(List <LOAGrupoOfertas> agregado,
                                                        List <LOFDadosOferta> livro,
                                                        LOFDadosOferta oferta)
        {
            List <LOAItemOferta> retorno = new List <LOAItemOferta>();

            LOAItemOferta itemLOA = new LOAItemOferta();

            LOFDadosOferta ofertaremovida = livro[oferta.Posicao];

            if (logger.IsDebugEnabled)
            {
                logger.Debug("Remover oferta [" + ofertaremovida.IDOferta + "] do grupo [" + ofertaremovida.Preco +
                             "][" + ofertaremovida.Quantidade + "] posicao [" + oferta.Posicao + "]");
            }

            livro.RemoveAt(oferta.Posicao);
            itemLOA.Acao = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_ALTERAR;

            for (int i = 0; i < agregado.Count; i++)
            {
                LOAGrupoOfertas grupo = agregado[i];

                if (grupo.Preco.CompareTo(ofertaremovida.Preco) == 0)
                {
                    if (LOAGrupoOfertas.excluiOferta(grupo, ofertaremovida, 1))
                    {
                        if (logger.IsDebugEnabled)
                        {
                            logger.Debug("Oferta [" + oferta.IDOferta + "] eh a ultima do grupo [" + ofertaremovida.Preco + "] removendo grupo");
                        }
                        itemLOA.Acao = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_EXCLUIR;
                        agregado.RemoveAt(i);
                    }
                    else
                    {
                        agregado[i] = grupo;
                    }

                    itemLOA.Indice     = i;
                    itemLOA.Quantidade = grupo.Quantidade;
                    itemLOA.Preco      = grupo.Preco;
                    itemLOA.QtdeOrdens = grupo.QtdeOrdens;

                    retorno.Add(itemLOA);

                    return(retorno);
                }
            }

            logger.Error("removeOferta: Nao encontrou indice para o grupo de preco [" + ofertaremovida.Preco + "]");

            return(retorno);
        }
Exemple #7
0
        public static void resetLivroLOF(String instrumento, List <LOFDadosOferta> livro, List <LOFDadosOferta> listaLOF)
        {
            logger.InfoFormat("LOF [{0}]: Reset Livro", instrumento);

            for (int i = 0; i < livro.Count; i++)
            {
                LOFDadosOferta oferta = livro[i];
                oferta.Posicao = i;
                listaLOF.Add(oferta);
                livro.RemoveAt(i);
            }
        }
Exemple #8
0
        public static bool excluiOferta(LOAGrupoOfertas grupo, LOFDadosOferta oferta, long qtdeOrdens)
        {
            grupo.Quantidade = grupo.Quantidade - oferta.Quantidade;
            grupo.QtdeOrdens = grupo.QtdeOrdens - qtdeOrdens;

            // Indica que deve remover esse preco do mapa
            if (grupo.Quantidade <= 0)
            {
                return(true);
            }

            //if (grupo.QtdeOrdens <= 0)
            //    grupo.QtdeOrdens = 1;

            return(false);
        }
Exemple #9
0
        //public LOFDadosOferta(
        //        String data,
        //        String hora,
        //        Decimal preco,
        //        long quantidade,
        //        long compradora,
        //        long vendedora)
        //{
        //    this.Data = data;
        //    this.Hora = hora;
        //    this.Preco = preco;
        //    this.Quantidade = quantidade;
        //    this.Compradora = compradora;
        //    this.Vendedora = vendedora;
        //}

        public static Dictionary <String, String> montarRegistroOferta(int acao, LOFDadosOferta dadosOferta, int casasDecimais)
        {
            Dictionary <String, String> oferta = new Dictionary <String, String>();

            String preco = "";

            if (dadosOferta.Preco == ConstantesMDS.PRECO_LIVRO_OFERTAS_MIN_VALUE || dadosOferta.Preco == ConstantesMDS.PRECO_LIVRO_OFERTAS_MAX_VALUE)
            {
                preco = ConstantesMDS.DESCRICAO_OFERTA_ABERTURA;
            }
            else
            {
                if (dadosOferta.Preco != Decimal.Zero)
                {
                    preco = String.Format("{0:f" + casasDecimais + "}", dadosOferta.Preco).Replace('.', ',');
                }
            }

            oferta.Add(
                ConstantesMDS.HTTP_OFERTAS_ACAO,
                String.Format("{0:d}", acao));
            oferta.Add(
                ConstantesMDS.HTTP_OFERTAS_POSICAO,
                String.Format("{0:d}", dadosOferta.Posicao));
            oferta.Add(
                ConstantesMDS.HTTP_OFERTAS_PRECO,
                preco);
            oferta.Add(
                ConstantesMDS.HTTP_OFERTAS_QUANTIDADE,
                dadosOferta.Quantidade == 0 ? "" : String.Format("{0:d}", dadosOferta.Quantidade));
            oferta.Add(
                ConstantesMDS.HTTP_OFERTAS_CORRETORA,
                dadosOferta.Corretora == 0 ? "" : String.Format("{0:d}", dadosOferta.Corretora));
            oferta.Add(
                ConstantesMDS.HTTP_OFERTAS_ID,
                dadosOferta.IDOferta);

            return(oferta);
        }
Exemple #10
0
        public static void removeOfertaEPioresLOF(
            String instrumento,
            List <LOFDadosOferta> livro,
            LOFDadosOferta oferta,
            int sentido,
            List <LOFDadosOferta> listaLOF)
        {
            String descricaoSentido = (sentido == LIVRO_VENDA ? "Compra" : "Venda");

            if (logger.IsDebugEnabled)
            {
                logger.DebugFormat("LOF [{0}]: Remove oferta {1} [{2}] e piores",
                                   instrumento, descricaoSentido, oferta.Posicao);
            }

            for (int posdel = livro.Count - 1; posdel >= oferta.Posicao; posdel--)
            {
                LOFDadosOferta ofertaremovida = livro[posdel];
                ofertaremovida.Posicao = posdel;
                livro.RemoveAt(posdel);
                listaLOF.Add(ofertaremovida);
            }
        }
Exemple #11
0
        public static void removeOfertaLOF(String instrumento, List <LOFDadosOferta> livro, LOFDadosOferta oferta, int sentido)
        {
            String descricaoSentido = (sentido == LIVRO_VENDA ? "Compra" : "Venda");

            if (logger.IsDebugEnabled)
            {
                logger.DebugFormat("LOF [{0}]: Remove oferta {1} [{2}] [{3}]",
                                   instrumento, descricaoSentido, oferta.Posicao, oferta.IDOferta);
            }

            livro.RemoveAt(oferta.Posicao);
        }
Exemple #12
0
        public static void insereOfertaLOF(String instrumento, List <LOFDadosOferta> livro, LOFDadosOferta oferta, int sentido)
        {
            String descricaoSentido = (sentido == LIVRO_VENDA ? "Compra" : "Venda");

            if (logger.IsDebugEnabled)
            {
                logger.DebugFormat("LOF [{0}]: Insere oferta {1} [{2}] [{3}] [{4}] [{5}]",
                                   instrumento, descricaoSentido, oferta.IDOferta, oferta.Preco, oferta.Quantidade, oferta.Posicao);
            }

            // Insere a oferta no livro
            livro.Insert(oferta.Posicao, oferta);
        }
Exemple #13
0
 public static void incluiOferta(LOAGrupoOfertas grupo, LOFDadosOferta oferta)
 {
     grupo.Quantidade = grupo.Quantidade + oferta.Quantidade;
     grupo.QtdeOrdens = grupo.QtdeOrdens + 1;
 }
Exemple #14
0
        public static List <LOAItemOferta> removeOfertaEPiores(List <LOAGrupoOfertas> agregado,
                                                               List <LOFDadosOferta> livro,
                                                               LOFDadosOferta oferta,
                                                               int sentido,
                                                               List <LOFDadosOferta> listaLOF)
        {
            String nomelivro = "Compra";

            long quantidadeRemovida      = 0;
            List <LOAItemOferta> retorno = new List <LOAItemOferta>();

            if (sentido == LIVRO_VENDA)
            {
                nomelivro = "Venda";
            }

            if (logger.IsDebugEnabled)
            {
                logger.Debug(nomelivro + ":Remover oferta [" + oferta.IDOferta + "] do grupo [" + oferta.Preco + "] e piores");
            }

            LOFDadosOferta ofertaReferencia = livro[oferta.Posicao];
            long           qtdeOrdens       = 0;

            for (int posdel = livro.Count - 1; posdel >= oferta.Posicao; posdel--)
            {
                LOFDadosOferta ofertaremovida = livro[posdel];
                ofertaremovida.Posicao = posdel;
                livro.RemoveAt(posdel);
                listaLOF.Add(ofertaremovida);

                // Se for do mesmo grupo de ofertas, acumula pra remover de uma unica vez
                if (ofertaremovida.Preco.CompareTo(ofertaReferencia.Preco) == 0)
                {
                    quantidadeRemovida += ofertaremovida.Quantidade;
                    qtdeOrdens++;
                }
            }

            int i = agregado.Count - 1;

            while (i >= 0)
            {
                LOAGrupoOfertas grupo = agregado[i];

                if ((grupo.Preco.CompareTo(ofertaReferencia.Preco) < 0 && sentido == LIVRO_COMPRA) ||
                    (grupo.Preco.CompareTo(ofertaReferencia.Preco) > 0 && sentido == LIVRO_VENDA))
                {
                    if (logger.IsDebugEnabled)
                    {
                        logger.Debug(nomelivro + ":Remover grupo do preco [" + grupo.Preco + "]");
                    }

                    // Remove o elemento. A lista sobe, entao novamente
                    // pegamos o elemento no indice atual
                    LOAItemOferta itemOferta = new LOAItemOferta();
                    itemOferta.Acao       = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_EXCLUIR;
                    itemOferta.Indice     = i;
                    itemOferta.Preco      = grupo.Preco;
                    itemOferta.Quantidade = grupo.Quantidade;
                    itemOferta.QtdeOrdens = grupo.QtdeOrdens;

                    retorno.Add(itemOferta);

                    agregado.RemoveAt(i);
                    //continue;
                }

                // Remove as melhores ofertas do mesmo grupo da oferta
                if (grupo.Preco.CompareTo(ofertaReferencia.Preco) == 0)
                {
                    if (logger.IsDebugEnabled)
                    {
                        logger.Debug(nomelivro + ":Remover a oferta do grupo do preco [" + grupo.Preco + "] indice [" + i + "]");
                    }

                    ofertaReferencia.Quantidade = quantidadeRemovida;

                    LOAItemOferta itemOferta = new LOAItemOferta();
                    itemOferta.Indice = i;
                    itemOferta.Preco  = grupo.Preco;

                    // Na verdade, ele so recalcula a quantidade,
                    // se zerar, exclui o grupo
                    if (LOAGrupoOfertas.excluiOferta(grupo, ofertaReferencia, qtdeOrdens))
                    {
                        if (logger.IsDebugEnabled)
                        {
                            logger.Debug(nomelivro + ":Oferta [" + ofertaReferencia.IDOferta + "] eh a ultima do grupo [" + ofertaReferencia.Preco + "] removendo grupo");
                        }

                        itemOferta.Acao = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_EXCLUIR;
                        agregado.RemoveAt(i);
                    }
                    else
                    {
                        itemOferta.Acao = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_ALTERAR;
                    }

                    itemOferta.Quantidade = grupo.Quantidade;
                    itemOferta.QtdeOrdens = grupo.QtdeOrdens;
                    retorno.Add(itemOferta);
                    break;
                }

                if ((grupo.Preco.CompareTo(ofertaReferencia.Preco) > 0 && sentido == LIVRO_COMPRA) ||
                    (grupo.Preco.CompareTo(ofertaReferencia.Preco) < 0 && sentido == LIVRO_VENDA))
                {
                    break;
                }

                i--;
            }

            return(retorno);
        }
Exemple #15
0
        //TODO: em lugar de retornar um int, retornar um objeto
        //TODO: que contenha a acao, indice, preco, e quantidade
        public static List <LOAItemOferta> insereOferta(List <LOAGrupoOfertas> agregado,
                                                        List <LOFDadosOferta> livro,
                                                        LOFDadosOferta oferta,
                                                        int sentido)
        {
            String  nomelivro = "Compra";
            Decimal preco     = oferta.Preco;

            List <LOAItemOferta> retorno = new List <LOAItemOferta>();

            LOAItemOferta itemLOA = new LOAItemOferta();

            if (sentido == LIVRO_VENDA)
            {
                nomelivro = "Venda";
            }

            if (logger.IsDebugEnabled)
            {
                logger.Debug("Insere oferta " + nomelivro + " [" +
                             oferta.IDOferta + "][" +
                             oferta.Preco + "][" +
                             oferta.Quantidade + "][" + oferta.Posicao + "]");
            }

            itemLOA.Acao  = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_INCLUIR;
            itemLOA.Preco = preco;

            // Insere a oferta no livro
            livro.Insert(oferta.Posicao, oferta);

            // Se eh a melhor oferta, e nao eh leilao
            // armazena valor para tratamento no leilao
            if (oferta.Posicao == 0 && !oferta.Leilao)
            {
            }

            int i = 0;

            while (i < agregado.Count)
            {
                LOAGrupoOfertas grupo = agregado[i];

                if ((preco.CompareTo(grupo.Preco) > 0 && sentido == LIVRO_COMPRA) ||
                    (preco.CompareTo(grupo.Preco) < 0 && sentido == LIVRO_VENDA))
                {
                    if (logger.IsDebugEnabled)
                    {
                        logger.Debug(nomelivro + ": Inclui novo grupo na posicao [" + i + "]");
                    }

                    LOAGrupoOfertas novogrupo = new LOAGrupoOfertas(preco, oferta, i);
                    agregado.Insert(i, novogrupo);

                    itemLOA.Quantidade = novogrupo.Quantidade;
                    itemLOA.Indice     = i;
                    itemLOA.QtdeOrdens = novogrupo.QtdeOrdens;

                    retorno.Add(itemLOA);

                    return(retorno);
                }

                if (preco.CompareTo(grupo.Preco) == 0)
                {
                    if (logger.IsDebugEnabled)
                    {
                        logger.Debug(nomelivro + ": Encontrou grupo na posicao [" + i + "]");
                    }

                    LOAGrupoOfertas.incluiOferta(grupo, oferta);
                    grupo.Indice = i;

                    agregado[i] = grupo;

                    itemLOA.Acao       = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_ALTERAR;
                    itemLOA.Quantidade = grupo.Quantidade;
                    itemLOA.Indice     = i;
                    itemLOA.QtdeOrdens = grupo.QtdeOrdens;

                    retorno.Add(itemLOA);

                    return(retorno);
                }

                if (oferta.Posicao == 0)
                {
                    if ((preco.CompareTo(grupo.Preco) < 0 && sentido == LIVRO_COMPRA) ||
                        (preco.CompareTo(grupo.Preco) > 0 && sentido == LIVRO_VENDA))
                    {
                        logger.Error(nomelivro + ": Inconsistencia, inserindo na posicao 0 com preco pior que o topo");

                        itemLOA            = new LOAItemOferta();
                        itemLOA.Acao       = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_EXCLUIR;
                        itemLOA.Quantidade = grupo.Quantidade;
                        itemLOA.Indice     = i;
                        itemLOA.QtdeOrdens = grupo.QtdeOrdens;
                        itemLOA.Preco      = grupo.Preco;

                        agregado.RemoveAt(i);

                        retorno.Add(itemLOA);

                        continue;
                    }
                }

                i++;
            }

            if (logger.IsDebugEnabled)
            {
                logger.Debug(nomelivro + ": Inclui novo grupo no final do livro, posicao [" + i + "]");
            }

            LOAGrupoOfertas novogrupo1 = new LOAGrupoOfertas(preco, oferta, i);

            itemLOA      = new LOAItemOferta();
            itemLOA.Acao = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_INCLUIR;

            itemLOA.Preco      = preco;
            itemLOA.Indice     = i;
            itemLOA.Quantidade = novogrupo1.Quantidade;
            itemLOA.QtdeOrdens = novogrupo1.QtdeOrdens;
            agregado.Add(novogrupo1);

            retorno.Add(itemLOA);

            return(retorno);
        }
Exemple #16
0
        public static List <LOAItemOferta> alteraOferta(List <LOAGrupoOfertas> agregado,
                                                        List <LOFDadosOferta> livro,
                                                        LOFDadosOferta oferta,
                                                        int sentido)
        {
            List <LOAItemOferta> retorno = new List <LOAItemOferta>();
            Decimal preco = oferta.Preco;

            if (logger.IsDebugEnabled)
            {
                logger.Debug("Altera oferta [" + oferta.IDOferta + "][" + oferta.Preco + "][" + oferta.Quantidade + "] pos [" + oferta.Posicao + "]");
            }

            LOFDadosOferta old = livro[oferta.Posicao];

            old.Posicao = oferta.Posicao;

            // Se for alteracao da oferta sem mudar o preco
            if (old.Preco.CompareTo(oferta.Preco) == 0)
            {
                livro[oferta.Posicao] = oferta;

                for (int i = 0; i < agregado.Count; i++)
                {
                    LOAGrupoOfertas grupo = agregado[i];

                    if (grupo.Preco.CompareTo(oferta.Preco) == 0)
                    {
                        LOAItemOferta itemOferta = new LOAItemOferta();
                        LOAGrupoOfertas.alteraOferta(grupo, old, oferta);

                        agregado[i] = grupo;

                        itemOferta.Acao       = ConstantesMDS.HTTP_OFERTAS_TIPO_ACAO_ALTERAR;
                        itemOferta.Indice     = i;
                        itemOferta.Quantidade = grupo.Quantidade;
                        itemOferta.Preco      = preco;
                        itemOferta.QtdeOrdens = grupo.QtdeOrdens;

                        retorno.Add(itemOferta);
                        return(retorno);
                    }
                }

                logger.Error("alteraOferta(): Nao encontrou indice para o grupo de preco [" + oferta.Preco + "]");
            }
            else
            {
                if (logger.IsDebugEnabled)
                {
                    logger.Debug("alteraoferta: [" + old.IDOferta + "] mudou para [" +
                                 oferta.IDOferta + "] preco [" +
                                 old.Preco + "]->[" + oferta.Preco + "]");
                }
                List <LOAItemOferta> itemsOfertas = LivroOfertasBase.removeOferta(agregado, livro, old);
                if (itemsOfertas.Count > 0)
                {
                    retorno.AddRange(itemsOfertas);
                }

                itemsOfertas = LivroOfertasBase.insereOferta(agregado, livro, oferta, sentido);
                if (itemsOfertas.Count > 0)
                {
                    retorno.AddRange(itemsOfertas);
                }
            }

            return(retorno);
        }
Exemple #17
0
 public static void alteraOferta(LOAGrupoOfertas grupo, LOFDadosOferta oldoferta, LOFDadosOferta newoferta)
 {
     grupo.Quantidade = grupo.Quantidade - oldoferta.Quantidade;
     grupo.Quantidade = grupo.Quantidade + newoferta.Quantidade;
 }