public void QuandoConsultaProcessosDeCotacaoDeUmDeterminadoFornecedorNaoConsideraOsProcessosNaoIniciados()
        {
            //crio um fornecedor e adiciono ele em uma cotação aberta e uma não iniciada
            Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();

            ProcessoDeCotacaoDeMaterial processoDeCotacao1 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
            ProcessoDeCotacaoDeMaterial processoDeCotacao2 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();

            processoDeCotacao1.AdicionarFornecedor(fornecedor1);
            processoDeCotacao1.Abrir(DefaultObjects.ObtemUsuarioPadrao());

            processoDeCotacao2.AdicionarFornecedor(fornecedor1);

            DefaultPersistedObjects.PersistirProcessosDeCotacaoDeMaterial(new List <ProcessoDeCotacaoDeMaterial>()
            {
                processoDeCotacao1, processoDeCotacao2
            });

            var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
            //consulta filtrando pelo fornecedor
            KendoGridVm kendoGridVm = consultaProcesso.Listar(new PaginacaoVm()
            {
                Page = 1, PageSize = 10, Take = 10
            },
                                                              new ProcessoCotacaoFiltroVm()
            {
                CodigoFornecedor = fornecedor1.Codigo
            });

            Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
            var viewModels = kendoGridVm.Registros.Cast <ProcessoCotacaoMaterialListagemVm>().ToList();

            //verifico que está retornado apenas o processo que foi aberto
            Assert.IsNotNull(viewModels.First(x => x.Id == processoDeCotacao1.Id));
        }
        public void QuandoListaProcessosDeCotacaoDeUmDeterminadoFornecedorRetornaApenasProcessosDesteFornecedor()
        {
            //crio dois fornecedores e adiciono cada um deles em duas cotações distintas
            Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
            Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();

            ProcessoDeCotacaoDeMaterial processoDeCotacao1 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
            ProcessoDeCotacaoDeMaterial processoDeCotacao2 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
            ProcessoDeCotacaoDeMaterial processoDeCotacao3 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
            ProcessoDeCotacaoDeMaterial processoDeCotacao4 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();

            processoDeCotacao1.AdicionarFornecedor(fornecedor1);
            processoDeCotacao1.Abrir(DefaultObjects.ObtemUsuarioPadrao());

            processoDeCotacao2.AdicionarFornecedor(fornecedor1);
            processoDeCotacao2.Abrir(DefaultObjects.ObtemUsuarioPadrao());

            processoDeCotacao3.AdicionarFornecedor(fornecedor2);
            processoDeCotacao3.Abrir(DefaultObjects.ObtemUsuarioPadrao());

            processoDeCotacao4.AdicionarFornecedor(fornecedor2);
            processoDeCotacao4.Abrir(DefaultObjects.ObtemUsuarioPadrao());

            DefaultPersistedObjects.PersistirProcessosDeCotacaoDeMaterial(new List <ProcessoDeCotacaoDeMaterial>()
            {
                processoDeCotacao1, processoDeCotacao2, processoDeCotacao3, processoDeCotacao4
            });

            var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
            //consulta filtrando pelo fornecedor1
            KendoGridVm kendoGridVm = consultaProcesso.Listar(new PaginacaoVm()
            {
                Page = 1, PageSize = 10, Take = 10
            },
                                                              new ProcessoCotacaoFiltroVm()
            {
                CodigoFornecedor = fornecedor1.Codigo
            });

            Assert.AreEqual(2, kendoGridVm.QuantidadeDeRegistros);
            var viewModels = kendoGridVm.Registros.Cast <ProcessoCotacaoMaterialListagemVm>().ToList();

            //verifico que está retornado os dois processos vinculados ao fornecedor 1
            Assert.IsNotNull(viewModels.First(x => x.Id == processoDeCotacao1.Id));
            Assert.IsNotNull(viewModels.First(x => x.Id == processoDeCotacao2.Id));
        }
コード例 #3
0
        public void QuandoFiltroProcessosDeCotacaoPorRequisicaoDeCompraRetornaApenasProcessosVinculadosComARequisicao()
        {
            //crio duas requisicoes de compra e  um processo para cada requisicão
            ProcessoDeCotacaoDeMaterial processoDeCotacao1  = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
            RequisicaoDeCompra          requisicaoDeCompra1 = ((ProcessoDeCotacaoDeMaterialItem)processoDeCotacao1.Itens.Single()).RequisicaoDeCompra;
            ProcessoDeCotacaoDeMaterial processoDeCotacao2  = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();

            DefaultPersistedObjects.PersistirProcessosDeCotacaoDeMaterial(new List <ProcessoDeCotacaoDeMaterial> {
                processoDeCotacao1, processoDeCotacao2
            });

            //filtra os processos por uma das requisições
            var processosDeCotacao   = ObjectFactory.GetInstance <IProcessosDeCotacaoDeMaterial>();
            var processosConsultados = processosDeCotacao.GeradosPelaRequisicaoDeCompra(requisicaoDeCompra1.Id).Count();

            //retorna apenas o processo vinculado com a requisição indicada
            Assert.AreEqual(1, processosConsultados);
            //Assert.AreEqual(processoDeCotacao1.Id, processosConsultados.Single().Id);
        }
コード例 #4
0
        public void QuandoConsultaEficienciaNegociacaoRetornaEficienciaDosProcessosFechados()
        {
            RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
            //cria dois compradores
            Usuario comprador1 = DefaultObjects.ObtemCompradorDeSuprimentos();
            Usuario comprador2 = DefaultObjects.ObtemCompradorDeSuprimentos();

            //cria um processo aberto e um fechado para o comprador1
            ProcessoDeCotacaoDeMaterial processo11 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAberto(comprador1);
            var cotacaoMaterial11 = processo11.InformarCotacao(processo11.FornecedoresParticipantes.Single().Fornecedor.Codigo,
                                                               DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                               DefaultObjects.ObtemIncotermPadrao(), "incoterm 2");

            var cotacaoItem11 = cotacaoMaterial11.InformarCotacaoDeItem(processo11.Itens.Single(), 100, 0, 50, DateTime.Today.AddDays(5), "obs11");

            cotacaoItem11.InformarImposto(Enumeradores.TipoDeImposto.Icms, 12);
            cotacaoItem11.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 10);
            cotacaoItem11.InformarImposto(Enumeradores.TipoDeImposto.PisCofins, 9);

            var processoDeCotacaoItem11 = (ProcessoDeCotacaoDeMaterialItem)processo11.Itens.Single();

            //cotacaoItem11.Atualizar(95,50,"obs11");
            cotacaoItem11.Selecionar(50);
            processo11.Fechar();

            ProcessoDeCotacaoDeMaterial processo12 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAberto(comprador1);

            //cria um processo aberto e um fechado para o comprador2
            ProcessoDeCotacaoDeMaterial processo21 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAberto(comprador2);
            var cotacaoMaterial21 = processo21.InformarCotacao(processo21.FornecedoresParticipantes.Single().Fornecedor.Codigo,
                                                               DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                               DefaultObjects.ObtemIncotermPadrao(), "incoterm 2");

            var cotacaoItem21 = cotacaoMaterial21.InformarCotacaoDeItem(processo21.Itens.Single(), 110, 0, 50, DateTime.Today.AddDays(5), "obs21");

            cotacaoItem21.InformarImposto(Enumeradores.TipoDeImposto.Icms, 12);
            cotacaoItem21.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 10);
            cotacaoItem21.InformarImposto(Enumeradores.TipoDeImposto.PisCofins, 9);

            cotacaoItem21.Atualizar(99, 50, "obs21");

            cotacaoItem21.Selecionar(50);

            processo21.Fechar();

            var processoDeCotacaoItem21 = (ProcessoDeCotacaoDeMaterialItem)processo21.Itens.Single();

            ProcessoDeCotacaoDeMaterial processo22 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAberto(comprador2);

            DefaultPersistedObjects.PersistirProcessosDeCotacaoDeMaterial(new List <ProcessoDeCotacaoDeMaterial>
            {
                processo11, processo12, processo21, processo22
            });


            var         consulta    = ObjectFactory.GetInstance <IConsultaEficienciaDeNegociacao>();
            KendoGridVm kendoGridVm = consulta.ConsultarResumo(DefaultObjects.ObtemPaginacaoDefault(), new EficienciaNegociacaoFiltroVm());

            //retorna um registro para cada comprador
            Assert.AreEqual(3, kendoGridVm.QuantidadeDeRegistros);

            var eficiencias = kendoGridVm.Registros.Cast <EficienciaDeNegociacaoResumoVm>().ToList();

            var eficienciaDoComprador1 = eficiencias.Single(x => x.Comprador == comprador1.Nome);

            Assert.AreEqual(processo11.Id, eficienciaDoComprador1.IdProcessoCotacao);
            Assert.AreEqual(processoDeCotacaoItem11.Id, eficienciaDoComprador1.IdProcessoCotacaoItem);
            Assert.AreEqual(cotacaoItem11.ProcessoDeCotacaoItem.Produto.Descricao, eficienciaDoComprador1.Produto);
            Assert.AreEqual(processoDeCotacaoItem11.RequisicaoDeCompra.Numero, eficienciaDoComprador1.NumeroDaRequisicao);
            Assert.AreEqual(processoDeCotacaoItem11.RequisicaoDeCompra.NumeroItem, eficienciaDoComprador1.NumeroDoItem);
            Assert.AreEqual(0, eficienciaDoComprador1.ValorDeEficiencia);
            Assert.AreEqual(0, eficienciaDoComprador1.PercentualDeEficiencia);

            var eficienciaDoComprador2 = eficiencias.Single(x => x.Comprador == comprador2.Nome);

            Assert.AreEqual(processo21.Id, eficienciaDoComprador2.IdProcessoCotacao);
            Assert.AreEqual(processoDeCotacaoItem21.Id, eficienciaDoComprador2.IdProcessoCotacaoItem);
            Assert.AreEqual(cotacaoItem21.ProcessoDeCotacaoItem.Produto.Descricao, eficienciaDoComprador2.Produto);
            Assert.AreEqual(processoDeCotacaoItem21.RequisicaoDeCompra.Numero, eficienciaDoComprador2.NumeroDaRequisicao);
            Assert.AreEqual(processoDeCotacaoItem21.RequisicaoDeCompra.NumeroItem, eficienciaDoComprador2.NumeroDoItem);
            Assert.AreEqual(550, eficienciaDoComprador2.ValorDeEficiencia);
            Assert.AreEqual(10, eficienciaDoComprador2.PercentualDeEficiencia);

            var eficienciaTotal = eficiencias.Single(x => x.Produto == "TOTAL");

            Assert.IsNotNull(eficienciaTotal);
            Assert.AreEqual(550, eficienciaTotal.ValorDeEficiencia);
            Assert.AreEqual((decimal)5.24, eficienciaTotal.PercentualDeEficiencia);
        }