public static ProcessoDeCotacaoDeMaterial ObtemProcessoDeCotacaoDeMaterialComCotacaoDoFornecedor()
        {
            ProcessoDeCotacaoDeMaterial processoDeCotacao = ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
            var             codigoFornecedor      = processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo;
            CotacaoMaterial cotacao               = processoDeCotacao.InformarCotacao(codigoFornecedor, ObtemCondicaoDePagamentoPadrao(), ObtemIncotermPadrao(), "Descrição do Incotem");
            var             processoDeCotacaoItem = processoDeCotacao.Itens.First();

            cotacao.InformarCotacaoDeItem(processoDeCotacaoItem, 125, 12, 100, DateTime.Today.AddMonths(1), "obs");
            return(processoDeCotacao);
        }
示例#2
0
        public void QuandoCrioUmaCotacaoParaUmItemEAdicionadoHistoricoDePreco()
        {
            ProcessoDeCotacaoDeMaterial processo  = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAberto(DefaultObjects.ObtemCompradorDeSuprimentos());
            string          codigoFornecedor      = processo.FornecedoresParticipantes.Single().Fornecedor.Codigo;
            int             idProcessoCotacaoItem = processo.Itens.Single().Id;
            CotacaoMaterial cotacao     = processo.InformarCotacao(codigoFornecedor, DefaultObjects.ObtemCondicaoDePagamentoPadrao(), DefaultObjects.ObtemIncotermPadrao(), "inc");
            var             cotacaoItem = (CotacaoMaterialItem)processo.InformarCotacaoDeItem(idProcessoCotacaoItem, cotacao.Id, 100, 0, 20, DateTime.Today.AddDays(5), "obs");

            Assert.AreEqual(1, cotacaoItem.HistoricosDePreco.Count);
            Assert.AreEqual(100, cotacaoItem.HistoricosDePreco.Single().Valor);
        }
        public void ConsigoPersistirEConsultarUmProcessoDeCotacaoComHistoricoDePrecos()
        {
            ProcessoDeCotacaoDeMaterial processo  = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAberto(DefaultObjects.ObtemCompradorDeSuprimentos());
            string          codigoFornecedor      = processo.FornecedoresParticipantes.Single().Fornecedor.Codigo;
            int             idProcessoCotacaoItem = processo.Itens.Single().Id;
            CotacaoMaterial cotacao     = processo.InformarCotacao(codigoFornecedor, DefaultObjects.ObtemCondicaoDePagamentoPadrao(), DefaultObjects.ObtemIncotermPadrao(), "inc");
            var             cotacaoItem = (CotacaoMaterialItem)processo.InformarCotacaoDeItem(idProcessoCotacaoItem, cotacao.Id, 100, 0, 20, DateTime.Today.AddDays(5), "obs");

            cotacaoItem.Atualizar(95, 0, 20, DateTime.Today.AddDays(5), "obs");
            Assert.AreEqual(2, cotacaoItem.HistoricosDePreco.Count);

            DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);

            var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();

            var processoConsultado = processosDeCotacaoDeMaterial.BuscaPorId(processo.Id).Single();

            Assert.AreEqual(2, processoConsultado.FornecedoresParticipantes.Single().Cotacao.Itens.Single().HistoricosDePreco.Count);
        }
示例#4
0
        public void QuandoInformoUmaCotacaoParaUmaCotacaoParaUmProdutoQueNaoEMateriaPrimaCalculadoCustoCorretamente()
        {
            ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
            Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();

            processoDeCotacao.AdicionarFornecedor(fornecedor);
            processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
            CotacaoMaterial cotacao = processoDeCotacao.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                                        DefaultObjects.ObtemIncotermPadrao(), "incoterm");

            ProcessoDeCotacaoItem item = processoDeCotacao.Itens.Single();
            var cotacaoItem            = cotacao.InformarCotacaoDeItem(item, 100, 0, 10, DateTime.Today.AddDays(10), "obs");

            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Icms, 17);
            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.PisCofins, 9);
            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 10);
            //preço + ipi
            Assert.AreEqual(110, cotacaoItem.Custo);
        }
        public void QuandoCalculaBaseDeCalculoDeUmImpostoComRetencaoRetornaValorCorreto()
        {
            ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialDeMateriaPrima();
            Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();

            processoDeCotacao.AdicionarFornecedor(fornecedor);
            processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
            CotacaoMaterial cotacao = processoDeCotacao.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                                        DefaultObjects.ObtemIncotermPadrao(), "descriçao");
            var         processoDeCotacaoDeMaterialItem = (ProcessoDeCotacaoDeMaterialItem)processoDeCotacao.Itens.Single();
            CotacaoItem cotacaoItem = cotacao.InformarCotacaoDeItem(processoDeCotacaoDeMaterialItem, 100, 0, 10, DateTime.Today.AddDays(10), "obs");

            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Icms, 12);
            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.PisCofins, (decimal)9.25);
            var     calculador    = new CalculadorDeBaseDeCalculoComCreditoDeImpostos();
            decimal baseDeCalculo = calculador.Calcular(cotacaoItem);

            Assert.AreEqual((decimal)78.75, baseDeCalculo);
        }
示例#6
0
        public void QuandoInformoUmaCotacaoParaUmaMateriaPrimaCalculadoCustoCorretamente()
        {
            ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialDeMateriaPrima();
            Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();

            processoDeCotacao.AdicionarFornecedor(fornecedor);
            processoDeCotacao.Abrir(DefaultObjects.ObtemUsuarioPadrao());
            CotacaoMaterial cotacao = processoDeCotacao.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                                        DefaultObjects.ObtemIncotermPadrao(), "incoterm");

            ProcessoDeCotacaoItem item = processoDeCotacao.Itens.Single();
            var cotacaoItem            = cotacao.InformarCotacaoDeItem(item, 100, 0, 10, DateTime.Today.AddDays(10), "obs");

            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Icms, 17);
            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.PisCofins, 9);
            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 10);

            //PREÇO - ICMS - PIS / COFINS - IPI = 100 - 17 - 9 - 7,40
            Assert.AreEqual((decimal)66.6, cotacaoItem.Custo);
        }
        public void ConsigoConsultarAsCotacoesDetalhadasDeTodosOsFornecedores()
        {
            Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
            Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
            Fornecedor fornecedor3 = DefaultObjects.ObtemFornecedorPadrao();
            //crio um processo de cotação com um item e três fornecedores.
            ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();

            ProcessoDeCotacaoItem processoDeCotacaoItem = processoDeCotacao.Itens.Single();

            processoDeCotacao.AdicionarFornecedor(fornecedor1);
            processoDeCotacao.AdicionarFornecedor(fornecedor2);
            processoDeCotacao.AdicionarFornecedor(fornecedor3);

            processoDeCotacao.Abrir(DefaultObjects.ObtemCompradorDeSuprimentos());

            //para os fornecedores 1 e 3 informo o preço duas vezes
            CotacaoMaterial cotacaoFornecedor1 = processoDeCotacao.InformarCotacao(fornecedor1.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                                                   DefaultObjects.ObtemIncotermPadrao(), "inc");

            CotacaoItem cotacaoItemFornecedor1 = cotacaoFornecedor1.InformarCotacaoDeItem(processoDeCotacaoItem, 1000, 0, 200, DateTime.Today.AddDays(10), "OBS");

            cotacaoFornecedor1.InformarCotacaoDeItem(processoDeCotacaoItem, 995, 0, 200, DateTime.Today.AddDays(10), "OBS");

            CotacaoMaterial cotacaoFornecedor3 = processoDeCotacao.InformarCotacao(fornecedor3.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                                                   DefaultObjects.ObtemIncotermPadrao(), "inc");

            cotacaoFornecedor3.InformarCotacaoDeItem(processoDeCotacaoItem, 1010, 0, 100, DateTime.Today.AddDays(10), "OBS");
            cotacaoFornecedor3.InformarCotacaoDeItem(processoDeCotacaoItem, 1000, 0, 100, DateTime.Today.AddDays(10), "OBS");

            //para o fornecedor 2 informo o preço apenas uma vez
            CotacaoMaterial cotacaoFornecedor2 = processoDeCotacao.InformarCotacao(fornecedor2.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
                                                                                   DefaultObjects.ObtemIncotermPadrao(), "inc");

            cotacaoFornecedor2.InformarCotacaoDeItem(processoDeCotacaoItem, 1200, 0, 100, DateTime.Today.AddDays(10), "OBS");

            //seleciono apenas o fornecedor 1
            cotacaoItemFornecedor1.Selecionar(200);

            DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao);

            var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
            IList <FornecedorCotacaoVm> cotacoes = consultaProcesso.CotacoesDetalhadaDosFornecedores(processoDeCotacao.Id, processoDeCotacaoItem.Id);

            Assert.AreEqual(3, cotacoes.Count);

            //asserts fornecedor 1
            FornecedorCotacaoVm fornecedorCotacaoVm1 = cotacoes.Single(x => x.Codigo == fornecedor1.Codigo);

            Assert.AreEqual(1000, fornecedorCotacaoVm1.PrecoInicial);
            Assert.AreEqual(995, fornecedorCotacaoVm1.PrecoFinal);
            Assert.IsTrue(fornecedorCotacaoVm1.Selecionada);
            Assert.AreEqual(200, fornecedorCotacaoVm1.QuantidadeAdquirida);
            //Assert.AreEqual(2, fornecedorCotacaoVm1.Precos.Length);
            Assert.AreEqual(2, fornecedorCotacaoVm1.Precos.Count());

            Assert.AreEqual(1000, fornecedorCotacaoVm1.Precos[0]);
            Assert.AreEqual(995, fornecedorCotacaoVm1.Precos[1]);

            //asserts fornecedor 2
            FornecedorCotacaoVm fornecedorCotacaoVm2 = cotacoes.Single(x => x.Codigo == fornecedor2.Codigo);

            Assert.AreEqual(1200, fornecedorCotacaoVm2.PrecoInicial);
            Assert.AreEqual(1200, fornecedorCotacaoVm2.PrecoFinal);
            Assert.IsFalse(fornecedorCotacaoVm2.Selecionada);
            Assert.AreEqual(0, fornecedorCotacaoVm2.QuantidadeAdquirida);
            //Assert.AreEqual(1, fornecedorCotacaoVm2.Precos.Length);
            Assert.AreEqual(1, fornecedorCotacaoVm2.Precos.Count());

            Assert.AreEqual(1200, fornecedorCotacaoVm2.Precos[0]);

            //asserts fornecedor 3
            FornecedorCotacaoVm fornecedorCotacaoVm3 = cotacoes.Single(x => x.Codigo == fornecedor3.Codigo);

            Assert.AreEqual(1010, fornecedorCotacaoVm3.PrecoInicial);
            Assert.AreEqual(1000, fornecedorCotacaoVm3.PrecoFinal);
            Assert.IsFalse(fornecedorCotacaoVm3.Selecionada);
            Assert.AreEqual(0, fornecedorCotacaoVm3.QuantidadeAdquirida);
            //Assert.AreEqual(2, fornecedorCotacaoVm3.Precos.Length);
            Assert.AreEqual(2, fornecedorCotacaoVm3.Precos.Count());

            Assert.AreEqual(1010, fornecedorCotacaoVm3.Precos[0]);
            Assert.AreEqual(1000, fornecedorCotacaoVm3.Precos[1]);
        }