public ProcessoCotacaoFreteCadastroVm ConsultaProcesso(int idProcessoCotacao)
        {
            var processoDeCotacao      = (ProcessoDeCotacaoDeFrete)_processosDeCotacao.BuscaPorId(idProcessoCotacao).Single();
            ProcessoDeCotacaoItem item = processoDeCotacao.Itens.First();

            return(new ProcessoCotacaoFreteCadastroVm()
            {
                Id = processoDeCotacao.Id,
                DataLimiteRetorno = processoDeCotacao.DataLimiteDeRetorno.Value.ToShortDateString(),
                DescricaoStatus = processoDeCotacao.Status.Descricao(),
                CodigoMaterial = item.Produto.Codigo,
                DescricaoMaterial = item.Produto.Descricao,
                QuantidadeMaterial = item.Quantidade,
                CodigoUnidadeMedida = item.UnidadeDeMedida.CodigoInterno,
                CodigoItinerario = processoDeCotacao.Itinerario.Codigo,
                DescricaoItinerario = processoDeCotacao.Itinerario.Descricao,
                Requisitos = processoDeCotacao.Requisitos,
                NumeroDoContrato = processoDeCotacao.NumeroDoContrato,
                DataValidadeCotacaoInicial = processoDeCotacao.DataDeValidadeInicial.ToShortDateString(),
                DataValidadeCotacaoFinal = processoDeCotacao.DataDeValidadeFinal.ToShortDateString(),

                PermiteAlterarFornecedores = processoDeCotacao.Status == Enumeradores.StatusProcessoCotacao.NaoIniciado,
                PermiteFecharProcesso = processoDeCotacao.Status == Enumeradores.StatusProcessoCotacao.Aberto,
                PermiteSalvar = processoDeCotacao.Status == Enumeradores.StatusProcessoCotacao.NaoIniciado,
                PermitirAbrirProcesso = processoDeCotacao.Status == Enumeradores.StatusProcessoCotacao.NaoIniciado,
                PermiteSelecionarCotacoes = processoDeCotacao.Status == Enumeradores.StatusProcessoCotacao.Aberto,
            });
        }
Ejemplo n.º 2
0
        public void QuandoACotacaoPossuiIcmsDeSubstituicaoTributariaEoCampoMvaNaoForPreenchidoDeveDispararExcecao()
        {
            ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
            var codigoFornecedor = processoDeCotacao.FornecedoresParticipantes.First().Fornecedor.Codigo;
            ProcessoDeCotacaoItem processoDeCotacaoItem = processoDeCotacao.Itens.First();
            var cotacao     = processoDeCotacao.InformarCotacao(codigoFornecedor, DefaultObjects.ObtemCondicaoDePagamentoPadrao(), DefaultObjects.ObtemIncotermPadrao(), "INC");
            var cotacaoItem = cotacao.InformarCotacaoDeItem(processoDeCotacaoItem, 100, null, 100, DateTime.Today, null);

            cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.IcmsSubstituicao, 17);
        }
Ejemplo n.º 3
0
        //public ComunicacaoFechamentoProcessoCotacaoFrete(CredencialSap credencialSap)
        //{
        //    _comunicacaoSap = new ComunicacaoSap<ListaProcessoDeCotacaoDeFreteFechamento>(credencialSap);
        //}

        public ApiResponseMessage EfetuarComunicacao(ProcessoDeCotacao processo)
        {
            ProcessoDeCotacaoItem item = processo.Itens.First();

            if (item.Produto.NaoEstocavel)
            {
                //Cotações de frete para empresas do grupo que não utilizam o SAP deverão ser realizadas com material NLAG
                //(Material não estocável). Para este tipo de material a cotação não deverá ser enviada para o SAP;
                return(new ApiResponseMessage
                {
                    Retorno = new Retorno
                    {
                        Codigo = "200",
                        Texto = "S"
                    }
                });
            }

            var mensagemParaEnviar = new ListaProcessoDeCotacaoDeFreteFechamento();

            var processoAuxiliar = (ProcessoDeCotacaoDeFrete)processo.CastEntity();

            foreach (var fornecedorParticipante in processoAuxiliar.FornecedoresParticipantes)
            {
                if (fornecedorParticipante.Cotacao != null && fornecedorParticipante.Cotacao.Itens.First().Selecionada)
                {
                    CotacaoItem itemDaCotacao = fornecedorParticipante.Cotacao.Itens.First();
                    mensagemParaEnviar.Add(new ProcessoDeCotacaoDeFreteFechamentoComunicacaoSapVm
                    {
                        CodigoTransportadora = fornecedorParticipante.Fornecedor.Codigo,
                        //CodigoMaterial = processoAuxiliar.Produto.Codigo,
                        CodigoMaterial = item.Produto.Codigo,
                        //CodigoUnidadeMedida = processoAuxiliar.UnidadeDeMedida.CodigoInterno,
                        CodigoUnidadeMedida   = item.UnidadeDeMedida.CodigoInterno,
                        CodigoItinerario      = processoAuxiliar.Itinerario.Codigo,
                        DataDeValidadeInicial = processoAuxiliar.DataDeValidadeInicial.ToString("yyyyMMdd"),
                        DataDeValidaFinal     = processoAuxiliar.DataDeValidadeFinal.ToString("yyyyMMdd"),
                        NumeroDoContrato      = processoAuxiliar.NumeroDoContrato ?? "",
                        Valor = itemDaCotacao.ValorComImpostos
                    });
                }
            }

            ApiResponseMessage apiResponseMessage =
                _comunicacaoSap.EnviarMensagem(
                    "/HttpAdapter/HttpMessageServlet?senderParty=PORTAL&senderService=HTTP&interfaceNamespace=http://portal.bsbios.com.br/&interface=si_cotacaoFreteFechamento_portal&qos=be"
                    , mensagemParaEnviar);

            if (apiResponseMessage.Retorno.Codigo == "E")
            {
                throw new ComunicacaoSapException("json", "Ocorreu um erro ao comunicar o fechamento do Processo de Cotação de Frete para o SAP. Detalhes: " + apiResponseMessage.Retorno.Texto);
            }
            return(apiResponseMessage);
        }
Ejemplo n.º 4
0
        public MensagemDeEmail AberturaDoProcessoDeCotacaoDeFrete(ProcessoDeCotacao processoDeCotacao)
        {
            ProcessoDeCotacaoItem item      = processoDeCotacao.Itens.First();
            var    processoDeCotacaoDeFrete = (ProcessoDeCotacaoDeFrete)processoDeCotacao;
            string mensagem = "Prezado Fornecedor. " + Environment.NewLine +
                              "A BSBIOS convida a participar do nosso processo de cotação para o Produto/Serviço " +
                              "conforme informações descritas abaixo. " + Environment.NewLine +
                              "Caso tenha interesse em participar favor acessar o Portal de Cotações (http://bsnet.bsbios.com/)." + Environment.NewLine + Environment.NewLine +
                              "Material: " + item.Produto.Descricao + Environment.NewLine +
                              "Quantidade: " + item.Quantidade + Environment.NewLine +
                              "Itinerário: " + processoDeCotacaoDeFrete.Itinerario.Descricao + Environment.NewLine +
                              "Unidade de Medida: " + item.UnidadeDeMedida.Descricao + Environment.NewLine +
                              "Data Limite de Retorno: " + (processoDeCotacaoDeFrete.DataLimiteDeRetorno.HasValue ? processoDeCotacaoDeFrete.DataLimiteDeRetorno.Value.ToShortDateString() : "") + Environment.NewLine +
                              "Requisitos: " + processoDeCotacaoDeFrete.Requisitos + Environment.NewLine;

            return(new MensagemDeEmail("Cotação de Frete", mensagem));
        }
Ejemplo n.º 5
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);
        }
Ejemplo n.º 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 Atualizar(CotacaoInformarVm cotacaoInformarVm)
        {
            try
            {
                _unitOfWork.BeginTransaction();
                var processoDeCotacao = (ProcessoDeCotacaoDeFrete)_processosDeCotacao.BuscaPorId(cotacaoInformarVm.IdProcessoCotacao).Single();

                ProcessoDeCotacaoItem item = processoDeCotacao.Itens.First();

                processoDeCotacao.InformarCotacao(cotacaoInformarVm.CodigoFornecedor, cotacaoInformarVm.ValorComImpostos.Value,
                                                  cotacaoInformarVm.QuantidadeDisponivel.Value, cotacaoInformarVm.ObservacoesDoFornecedor);

                _processosDeCotacao.Save(processoDeCotacao);
                _unitOfWork.Commit();
            }
            catch (Exception)
            {
                _unitOfWork.RollBack();
                throw;
            }
        }
        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]);
        }