Esempio n. 1
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);
        }
Esempio n. 2
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);
        }