public void QuandoUmaRequisicaoDeCompraJaGerouUmProcessoDeCotacaoNaoApareceMaisDisponivelParaOutrosProcessos()
{
//Cria duas requisições de compra: 1 e 2
//Cria um processo de cotação e associa a requisição 1 com este processo
//Cria um novo processo de cotação, salva e Lista as requisições para este processo. A requisição ' não deve aparecer.
RemoveQueries.RemoverRequisicoesDeCompraCadastradas();
RequisicaoDeCompra requisicao1 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
RequisicaoDeCompra requisicao2 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
var processo1 = new ProcessoDeCotacaoDeMaterial();
processo1.AdicionarItem(requisicao1);
var processo2 = new ProcessoDeCotacaoDeMaterial();
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicao2);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo1);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo2);
var consultaRequisicao = ObjectFactory.GetInstance <IConsultaRequisicaoDeCompra>();
var kendoGridVm = consultaRequisicao.Listar(DefaultObjects.ObtemPaginacaoDefault(), new RequisicaoDeCompraFiltroVm(processo2.Id));
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
var requisicaoDeCompraVm = kendoGridVm.Registros.Cast <RequisicaoDeCompraVm>().Single();
Assert.AreEqual(requisicao2.Numero, requisicaoDeCompraVm.NumeroRequisicao);
Assert.AreEqual(requisicao2.NumeroItem, requisicaoDeCompraVm.NumeroItem);
}
public void ConsigoPersistirEConsultarUmProcessoDeCotacaoComImpostosNasCotacoes()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor);
processoDeCotacaoDeMaterial.Abrir(DefaultObjects.ObtemUsuarioPadrao());
var cotacao = processoDeCotacaoDeMaterial.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(), DefaultObjects.ObtemIncotermPadrao(), "inc");
var processoCotacaoItem = processoDeCotacaoDeMaterial.Itens.First();
var cotacaoItem = cotacao.InformarCotacaoDeItem(processoCotacaoItem, 100, 120, 100, DateTime.Today.AddMonths(1), "obs fornec");
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Icms, 17);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 5);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();
Console.WriteLine("Consultando Cotacao - INICIO");
var processoConsultado = (ProcessoDeCotacaoDeMaterial)processosDeCotacaoDeMaterial.BuscaPorId(processoDeCotacaoDeMaterial.Id).Single();
Cotacao cotacaoConsultada = processoConsultado.FornecedoresParticipantes.First().Cotacao;
Assert.AreEqual(2, cotacaoConsultada.Itens.First().Impostos.Count);
Console.WriteLine("Consultando Cotacao - FIM");
}
public void DepoisDePersistirUmProcessoDeCotacaoDeMaterialConsigoConsultar()
{
var processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
UnitOfWorkNh.Session.Clear();
var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();
var processoConsultado = (ProcessoDeCotacaoDeMaterial)processosDeCotacaoDeMaterial.BuscaPorId(processoDeCotacaoDeMaterial.Id).Single();
Assert.IsNotNull(processoConsultado);
Assert.AreEqual(Enumeradores.StatusProcessoCotacao.NaoIniciado, processoConsultado.Status);
Assert.AreEqual(processoDeCotacaoDeMaterial.Id, processoConsultado.Id);
Assert.AreEqual(processoDeCotacaoDeMaterial.DataLimiteDeRetorno, processoConsultado.DataLimiteDeRetorno);
Assert.AreEqual(processoDeCotacaoDeMaterial.Requisitos, processoConsultado.Requisitos);
var item = (ProcessoDeCotacaoDeMaterialItem)processoDeCotacaoDeMaterial.Itens.First();
var itemConsultado = (ProcessoDeCotacaoDeMaterialItem)processoConsultado.Itens.First();
Assert.AreEqual(item.Produto.Codigo, itemConsultado.Produto.Codigo);
Assert.AreEqual(item.UnidadeDeMedida.CodigoInterno, itemConsultado.UnidadeDeMedida.CodigoInterno);
Assert.IsFalse(NHibernateUtil.IsInitialized(itemConsultado.RequisicaoDeCompra));
Assert.AreEqual(item.RequisicaoDeCompra.Id, itemConsultado.RequisicaoDeCompra.Id);
}
public void ConsultaListagemDeProcessosRetornaObjetoEsperado()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
KendoGridVm kendoGridVm = consultaProcesso.Listar(new PaginacaoVm()
{
Page = 1, PageSize = 10, Take = 10
},
new ProcessoCotacaoFiltroVm());
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
ProcessoCotacaoMaterialListagemVm processoListagem = kendoGridVm.Registros.Cast <ProcessoCotacaoMaterialListagemVm>().First();
Assert.AreEqual(processoDeCotacaoDeMaterial.Id, processoListagem.Id);
//Assert.AreEqual(processoDeCotacaoDeMaterial.Itens.First().Produto.Codigo, processoListagem.CodigoMaterial);
Assert.AreEqual(processoDeCotacaoDeMaterial.Itens.First().Produto.Descricao, processoListagem.Material);
//Assert.AreEqual(1000, processoListagem.Quantidade);
Assert.AreEqual("Não Iniciado", processoListagem.Status);
Assert.IsNotNull(processoDeCotacaoDeMaterial.DataLimiteDeRetorno);
Assert.AreEqual(processoDeCotacaoDeMaterial.DataLimiteDeRetorno.Value.ToShortDateString(), processoListagem.DataTermino);
}
public void QuandoInformoImpostosDeUmaCotacaoRetornaOsDadosDosImpostos()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
Fornecedor fornecedor = processo.FornecedoresParticipantes.First().Fornecedor;
var cotacao = processo.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "Desc Incoterm");
var itemDoProcesso = (ProcessoDeCotacaoDeMaterialItem)processo.Itens.First();
RequisicaoDeCompra requisicaoDeCompra = itemDoProcesso.RequisicaoDeCompra;
var cotacaoItem = cotacao.InformarCotacaoDeItem(itemDoProcesso, 100, 120, 12, DateTime.Today.AddMonths(1), "observacoes");
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Icms, 1);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.IcmsSubstituicao, 11);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.Ipi, 21);
cotacaoItem.InformarImposto(Enumeradores.TipoDeImposto.PisCofins, 3);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
CotacaoImpostosVm vm = consulta.ConsultarCotacaoDeItemDeMaterial(processo.Id, fornecedor.Codigo, requisicaoDeCompra.Numero, requisicaoDeCompra.NumeroItem).Impostos;
Assert.AreEqual(1, vm.IcmsAliquota);
Assert.AreEqual(1, vm.IcmsValor);
Assert.AreEqual(11, vm.IcmsStAliquota);
Assert.AreEqual(11, vm.IcmsStValor);
Assert.AreEqual(21, vm.IpiAliquota);
Assert.AreEqual(21, vm.IpiValor);
Assert.AreEqual(3, vm.PisCofinsValor);
Assert.AreEqual(3, vm.PisCofinsAliquota);
}
public void RetornaListaComTodosFornecedoresParticipantesDoProcessoDeCotacao()
{
//crio um processo de cotação de materiais
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
processoDeCotacao.Atualizar(DateTime.Today.AddDays(4), "req");
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor3 = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacao.AdicionarFornecedor(fornecedor1);
processoDeCotacao.AdicionarFornecedor(fornecedor2);
processoDeCotacao.AdicionarFornecedor(fornecedor3);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao);
var consulta = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
FornecedorVm[] fornecedores = consulta.ListarFornecedores(processoDeCotacao.Id);
Assert.AreEqual(3, fornecedores.Count());
Assert.IsTrue(fornecedores.Any(x => x.Codigo == fornecedor1.Codigo && x.Nome == fornecedor1.Nome));
Assert.IsTrue(fornecedores.Any(x => x.Codigo == fornecedor2.Codigo && x.Nome == fornecedor2.Nome));
Assert.IsTrue(fornecedores.Any(x => x.Codigo == fornecedor3.Codigo && x.Nome == fornecedor3.Nome));
}
public void QuandoConsultoUmaCotacaoDoFornecedorQueJaFoiPreenchidaRetornaOsDadosEsperados()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
Fornecedor fornecedor = processo.FornecedoresParticipantes.First().Fornecedor;
var cotacao = processo.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(),
"Desc Incoterm");
var processoCotacaoItem = processo.Itens.First();
cotacao.InformarCotacaoDeItem(processoCotacaoItem, 100, 120, 12, DateTime.Today.AddMonths(1), "observacoes");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
CotacaoMaterialCadastroVm vm = consulta.ConsultarCotacaoDeMaterial(processo.Id, fornecedor.Codigo);
Assert.IsNotNull(vm);
Assert.AreEqual(processo.Id, vm.IdProcessoCotacao);
Assert.AreEqual(cotacao.Id, vm.IdCotacao);
Assert.AreEqual(cotacao.CondicaoDePagamento.Codigo, vm.CodigoCondicaoPagamento);
Assert.AreEqual(cotacao.Incoterm.Codigo, vm.CodigoIncoterm);
Assert.AreEqual("Desc Incoterm", vm.DescricaoIncoterm);
Assert.AreEqual(fornecedor.Codigo, vm.CodigoFornecedor);
Assert.IsTrue(processo.DataLimiteDeRetorno.HasValue);
Assert.AreEqual(processo.DataLimiteDeRetorno.Value.ToShortDateString(), vm.DataLimiteDeRetorno);
Assert.AreEqual("Aberto", vm.Status);
}
public void QuandoConsultoRequisicoesDisponiveisParaUmProcessoDeCotacaoListaAsRequisicoesQueJaEstaoAssociadasAoProcessoETambemAsQueNaoEstaoAssociadasANenhumOutroProcesso()
{
//Cria duas requisições de compra: 1 e 2
//Cria um processo de cotação 1 e associa a requisição 1 com este processo
//Salva os registros
//Depois consultar novamente as requisições para o processo 1: deve listar as requisiões 1 e 2
RemoveQueries.RemoverRequisicoesDeCompraCadastradas();
RequisicaoDeCompra requisicao1 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
RequisicaoDeCompra requisicao2 = DefaultObjects.ObtemRequisicaoDeCompraPadrao();
var processo1 = new ProcessoDeCotacaoDeMaterial();
processo1.AdicionarItem(requisicao1);
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicao1);
DefaultPersistedObjects.PersistirRequisicaoDeCompra(requisicao2);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo1);
var consultaRequisicao = ObjectFactory.GetInstance <IConsultaRequisicaoDeCompra>();
var kendoGridVm = consultaRequisicao.Listar(DefaultObjects.ObtemPaginacaoDefault(), new RequisicaoDeCompraFiltroVm(processo1.Id));
Assert.AreEqual(2, kendoGridVm.QuantidadeDeRegistros);
}
public void QuandoConsultoUmaCotacaoDoFornecedorParaUmItemQueJaFoiPreenchidaRetornaOsDadosEsperados()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
Fornecedor fornecedor = processo.FornecedoresParticipantes.First().Fornecedor;
var cotacao = processo.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(),
"Desc Incoterm");
var processoCotacaoItem = processo.Itens.First();
var cotacaoItem = cotacao.InformarCotacaoDeItem(processoCotacaoItem, 100, 120, 12, DateTime.Today.AddMonths(1), "observacoes");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
var itemDoProcesso = (ProcessoDeCotacaoDeMaterialItem)processo.Itens.First();
RequisicaoDeCompra requisicaoDeCompra = itemDoProcesso.RequisicaoDeCompra;
CotacaoMaterialItemCadastroVm vm = consulta.ConsultarCotacaoDeItemDeMaterial(processo.Id, fornecedor.Codigo, requisicaoDeCompra.Numero, requisicaoDeCompra.NumeroItem);
Assert.IsNotNull(vm);
Assert.AreEqual(processo.Id, vm.IdProcessoCotacao);
Assert.AreEqual(cotacao.Id, vm.IdCotacao);
Assert.AreEqual(cotacaoItem.Id, vm.IdCotacaoItem);
Assert.AreEqual(itemDoProcesso.Id, vm.IdProcessoCotacaoItem);
Assert.AreEqual(itemDoProcesso.Produto.Descricao, vm.Material);
Assert.AreEqual(itemDoProcesso.Quantidade, vm.Quantidade);
Assert.AreEqual(itemDoProcesso.UnidadeDeMedida.Descricao, vm.UnidadeDeMedida);
Assert.AreEqual(100, vm.ValorComImpostos);
Assert.AreEqual(100, vm.Custo);
Assert.AreEqual(100, vm.Preco);
Assert.AreEqual(120, vm.Mva);
}
public void ConsigoPersistirEConsultarUmProcessoDeCotacaoComFornecedores()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();
//sou obrigado a executar o método Clear aqui, caso contrário o objeto que foi persistido fica em cache
UnitOfWorkNh.Session.Clear();
var processoConsultado = (ProcessoDeCotacaoDeMaterial)processosDeCotacaoDeMaterial.BuscaPorId(processoDeCotacaoDeMaterial.Id).Single();
Assert.AreEqual(processoDeCotacaoDeMaterial.FornecedoresParticipantes.Count, processoConsultado.FornecedoresParticipantes.Count);
}
public void FiltrarUmProcessoDeCotacaoPorStatusRetornaProcessoEsperado()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
ProcessoDeCotacaoDeMaterial processoDeCotacao1 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
ProcessoDeCotacaoDeMaterial processoDeCotacao2 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialFechado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao1);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao2);
var processosDeCotacao = ObjectFactory.GetInstance <IProcessosDeCotacao>();
IList <ProcessoDeCotacao> processosConsultados = processosDeCotacao.FiltraPorStatus(Enumeradores.StatusProcessoCotacao.NaoIniciado).List();
Assert.AreEqual(1, processosConsultados.Count());
Assert.AreEqual(Enumeradores.StatusProcessoCotacao.NaoIniciado, processosConsultados.First().Status);
}
public void RepositorioDoProcessoDeCotacaoDeMateriasContemApenasProcessosDeCotacaoDeMaterial()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
//crio dois processos de cotação (um de frete e um de materiais) e persisto
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
ProcessoDeCotacaoDeFrete processoDeCotacaoDeFrete = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processoDeCotacaoDeFrete);
//listo todos os processsos do repositório: deve retornar apenas o processo de cotação de material
var processosDeCotacaoDeMaterias = ObjectFactory.GetInstance <IProcessosDeCotacaoDeMaterial>();
var todosProcessos = processosDeCotacaoDeMaterias.List();
Assert.AreEqual(1, todosProcessos.Count);
Assert.IsInstanceOfType(todosProcessos.Single(), typeof(ProcessoDeCotacaoDeMaterial));
}
public void ConsultaProcessoRetornaObjetoEsperado()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
ProcessoCotacaoMaterialCadastroVm processoCotacaoMaterialCadastroVm = consultaProcesso.ConsultaProcesso(processoDeCotacaoDeMaterial.Id);
Assert.AreEqual(processoDeCotacaoDeMaterial.Id, processoCotacaoMaterialCadastroVm.Id);
//Assert.AreEqual(processoDeCotacaoDeMaterial.Itens.First().Produto.Codigo,processoCotacaoMaterialCadastroVm.CodigoMaterial);
Assert.IsTrue(processoDeCotacaoDeMaterial.DataLimiteDeRetorno.HasValue);
Assert.AreEqual(processoDeCotacaoDeMaterial.DataLimiteDeRetorno.Value.ToShortDateString(), processoCotacaoMaterialCadastroVm.DataLimiteRetorno);
Assert.AreEqual("Não Iniciado", processoCotacaoMaterialCadastroVm.DescricaoStatus);
Assert.AreEqual("Requisitos do Processo de Cotação de Materiais", processoCotacaoMaterialCadastroVm.Requisitos);
}
public void ConsigoConsultarItensDeUmProcessoDeCotacaoDeMaterial()
{
ProcessoDeCotacaoDeMaterial processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao);
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
KendoGridVm kendoGridVm = consultaProcesso.ListarItens(processoDeCotacao.Id);
IList <ProcessoDeCotacaoDeMaterialItemVm> itens = kendoGridVm.Registros.Cast <ProcessoDeCotacaoDeMaterialItemVm>().ToList();
Assert.IsNotNull(itens);
Assert.AreEqual(1, itens.Count);
var requisicaoDeCompraVm = itens.First();
var item = (ProcessoDeCotacaoDeMaterialItem)processoDeCotacao.Itens.First();
Assert.AreEqual(item.RequisicaoDeCompra.Numero, requisicaoDeCompraVm.NumeroRequisicao);
Assert.AreEqual(item.RequisicaoDeCompra.NumeroItem, requisicaoDeCompraVm.NumeroItem);
}
public void ConsigoPersistirEConsultarUmProcessoDeCotacaoComCotacoes()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor);
var usuarioComprador = DefaultObjects.ObtemUsuarioPadrao();
processoDeCotacaoDeMaterial.Abrir(usuarioComprador);
var cotacao = processoDeCotacaoDeMaterial.InformarCotacao(fornecedor.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "inc");
var processoDeCotacaoItem = processoDeCotacaoDeMaterial.Itens.First();
var cotacaoItem = cotacao.InformarCotacaoDeItem(processoDeCotacaoItem, 1000, 120, 100, DateTime.Today.AddMonths(1), "obs fornec");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var processosDeCotacaoDeMaterial = ObjectFactory.GetInstance <IProcessosDeCotacao>();
Console.WriteLine("Consultando Cotacao - INICIO");
var processoConsultado = (ProcessoDeCotacaoDeMaterial)processosDeCotacaoDeMaterial.BuscaPorId(processoDeCotacaoDeMaterial.Id).Single();
Assert.AreEqual(processoDeCotacaoDeMaterial.FornecedoresParticipantes.Count(x => x.Cotacao != null), processoConsultado.FornecedoresParticipantes.Count(x => x.Cotacao != null));
var cotacaoConsultada = (CotacaoMaterial)processoConsultado.FornecedoresParticipantes.First().Cotacao.CastEntity();
Assert.AreEqual(cotacao.Incoterm, cotacaoConsultada.Incoterm.CastEntity());
Assert.AreEqual(cotacao.DescricaoIncoterm, cotacaoConsultada.DescricaoIncoterm);
Assert.AreEqual(cotacao.CondicaoDePagamento, cotacaoConsultada.CondicaoDePagamento.CastEntity());
Assert.AreEqual(processoDeCotacaoDeMaterial.Comprador.Login, processoConsultado.Comprador.Login);
var cotacaoItemConsultada = (CotacaoMaterialItem)cotacaoConsultada.Itens.First().CastEntity();
Assert.AreEqual(cotacaoItem.ValorComImpostos, cotacaoItemConsultada.ValorComImpostos);
Assert.AreEqual(cotacaoItem.Preco, cotacaoItemConsultada.Preco);
Assert.AreEqual(cotacaoItem.PrecoInicial, cotacaoItemConsultada.PrecoInicial);
Assert.AreEqual(cotacaoItem.Selecionada, cotacaoItemConsultada.Selecionada);
Assert.AreEqual(cotacaoItem.QuantidadeDisponivel, cotacaoItemConsultada.QuantidadeDisponivel);
Assert.AreEqual(cotacaoItem.QuantidadeAdquirida, cotacaoItemConsultada.QuantidadeAdquirida);
Assert.AreEqual(cotacaoItem.Observacoes, cotacaoItemConsultada.Observacoes);
Console.WriteLine("Consultando Cotacao - FIM");
}
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);
}
public void ConsultaFornecedoresParticipantesRetornaObjetoEsperado()
{
ProcessoDeCotacaoDeMaterial processoDeCotacaoDeMaterial = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialNaoIniciado();
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor1);
processoDeCotacaoDeMaterial.AdicionarFornecedor(fornecedor2);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
Console.WriteLine("INICIANDO CONSULTA");
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
KendoGridVm kendoGridVm = consultaProcesso.FornecedoresParticipantes(processoDeCotacaoDeMaterial.Id);
Assert.AreEqual(2, kendoGridVm.QuantidadeDeRegistros);
IList <FornecedorCadastroVm> viewModels = kendoGridVm.Registros.Cast <FornecedorCadastroVm>().ToList();
Assert.AreEqual(1, viewModels.Count(x => x.Codigo == fornecedor1.Codigo));
Assert.AreEqual(1, viewModels.Count(x => x.Codigo == fornecedor2.Codigo));
}
public void QuandoConsultoUmaCotacaoDoFornecedorParaUmItemQueAindaNaoFoiPreenchidaRetornaOsDadosEsperados()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
Fornecedor fornecedor = processo.FornecedoresParticipantes.First().Fornecedor;
var itemDoProcesso = (ProcessoDeCotacaoDeMaterialItem)processo.Itens.First();
RequisicaoDeCompra requisicaoDeCompra = itemDoProcesso.RequisicaoDeCompra;
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
CotacaoMaterialItemCadastroVm vm = consulta.ConsultarCotacaoDeItemDeMaterial(processo.Id, fornecedor.Codigo, requisicaoDeCompra.Numero, requisicaoDeCompra.NumeroItem);
Assert.IsNotNull(vm);
Assert.AreEqual(itemDoProcesso.Produto.Descricao, vm.Material);
Assert.AreEqual(itemDoProcesso.Quantidade, vm.Quantidade);
Assert.AreEqual(itemDoProcesso.UnidadeDeMedida.Descricao, vm.UnidadeDeMedida);
Assert.IsNull(vm.ValorComImpostos);
Assert.IsNull(vm.Preco);
Assert.IsNull(vm.Mva);
}
public void QuandoConsultoUmaCotacaoDoFornecedorQueAindaNaoFoiPreenchidaRetornaOsDadosEsperados()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAbertoPadrao();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
Fornecedor fornecedor = processo.FornecedoresParticipantes.First().Fornecedor;
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
CotacaoMaterialCadastroVm vm = consulta.ConsultarCotacaoDeMaterial(processo.Id, fornecedor.Codigo);
Assert.IsNotNull(vm);
Assert.AreEqual(processo.Id, vm.IdProcessoCotacao);
Assert.AreEqual(0, vm.IdCotacao);
Assert.IsNull(vm.CodigoCondicaoPagamento);
Assert.IsNull(vm.CodigoIncoterm);
Assert.IsNull(vm.DescricaoIncoterm);
Assert.AreEqual(fornecedor.Codigo, vm.CodigoFornecedor);
Assert.IsTrue(processo.DataLimiteDeRetorno.HasValue);
Assert.AreEqual(processo.DataLimiteDeRetorno.Value.ToShortDateString(), vm.DataLimiteDeRetorno);
Assert.AreEqual("Aberto", vm.Status);
}
public void QuandoConsultaUmaCotacaoQueParticipaMaisDeUmFornecedorRetornaOsDadoDoFornecedorInformado()
{
ProcessoDeCotacaoDeMaterial processo = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAtualizado();
Fornecedor fornecedor1 = DefaultObjects.ObtemFornecedorPadrao();
Fornecedor fornecedor2 = DefaultObjects.ObtemFornecedorPadrao();
processo.AdicionarFornecedor(fornecedor1);
processo.AdicionarFornecedor(fornecedor2);
processo.Abrir(DefaultObjects.ObtemUsuarioPadrao());
var processoDeCotacaoItem = processo.Itens.First();
var cotacao1 = processo.InformarCotacao(fornecedor1.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "Desc Incoterm");
cotacao1.InformarCotacaoDeItem(processoDeCotacaoItem, 100, 120, 12, DateTime.Today.AddMonths(1), "observacoes");
var cotacao2 = processo.InformarCotacao(fornecedor2.Codigo, DefaultObjects.ObtemCondicaoDePagamentoPadrao(),
DefaultObjects.ObtemIncotermPadrao(), "Desc Incoterm");
cotacao2.InformarCotacaoDeItem(processoDeCotacaoItem, 120, 130, 14, DateTime.Today.AddMonths(1), "observacoes");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processo);
var cotacao = (CotacaoMaterial)processo.FornecedoresParticipantes.Single(x => x.Fornecedor.Codigo == fornecedor1.Codigo).Cotacao;
var consulta = ObjectFactory.GetInstance <IConsultaCotacaoDoFornecedor>();
CotacaoMaterialCadastroVm vm = consulta.ConsultarCotacaoDeMaterial(processo.Id, fornecedor1.Codigo);
Assert.IsNotNull(vm);
Assert.AreEqual(processo.Id, vm.IdProcessoCotacao);
Assert.AreEqual(cotacao.Id, vm.IdCotacao);
Assert.AreEqual(cotacao.CondicaoDePagamento.Codigo, vm.CodigoCondicaoPagamento);
Assert.AreEqual(cotacao.Incoterm.Codigo, vm.CodigoIncoterm);
Assert.AreEqual("Desc Incoterm", vm.DescricaoIncoterm);
Assert.AreEqual(fornecedor1.Codigo, vm.CodigoFornecedor);
Assert.IsTrue(processo.DataLimiteDeRetorno.HasValue);
Assert.AreEqual(processo.DataLimiteDeRetorno.Value.ToShortDateString(), vm.DataLimiteDeRetorno);
Assert.AreEqual("Aberto", vm.Status);
}
public void QuandoBuscoProcessosDeCotacaoDeUmCompradorEspecificoTodosProcessosSaoDesteComprador()
{
//crio dois processos de cotação: 1 para cada comprador
Usuario comprador1 = DefaultObjects.ObtemUsuarioPadrao();
comprador1.AdicionarPerfil(Enumeradores.Perfil.CompradorSuprimentos);
ProcessoDeCotacaoDeMaterial processoDeCotacao1 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAberto(comprador1);
Usuario comprador2 = DefaultObjects.ObtemUsuarioPadrao();
comprador2.AdicionarPerfil(Enumeradores.Perfil.CompradorSuprimentos);
ProcessoDeCotacaoDeMaterial processoDeCotacao2 = DefaultObjects.ObtemProcessoDeCotacaoDeMaterialAberto(comprador2);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao1);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacao2);
var processosDeCotacaoDeMateriais = ObjectFactory.GetInstance <IProcessosDeCotacaoDeMaterial>();
IList <ProcessoDeCotacao> processosConsultados = processosDeCotacaoDeMateriais.EfetuadosPeloComprador(comprador1.Login).List();
Assert.AreEqual(1, processosConsultados.Count);
Assert.AreEqual(processoDeCotacao1.Id, processosConsultados.Single().Id);
}
public void QuandoConsultaListagemDeUmProcessoQueNaoPossuiItensRetornaObjetoEsperado()
{
RemoveQueries.RemoverProcessosDeCotacaoCadastrados();
var processoDeCotacaoDeMaterial = new ProcessoDeCotacaoDeMaterial();
processoDeCotacaoDeMaterial.Atualizar(DateTime.Today, "requisitos");
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeMaterial(processoDeCotacaoDeMaterial);
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
KendoGridVm kendoGridVm = consultaProcesso.Listar(new PaginacaoVm()
{
Page = 1, PageSize = 10, Take = 10
},
new ProcessoCotacaoFiltroVm());
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
ProcessoCotacaoMaterialListagemVm processoListagem = kendoGridVm.Registros.Cast <ProcessoCotacaoMaterialListagemVm>().First();
Assert.AreEqual(processoDeCotacaoDeMaterial.Id, processoListagem.Id);
Assert.AreEqual("Sem Materiais", processoListagem.Material);
Assert.AreEqual("Não Iniciado", processoListagem.Status);
Assert.IsNotNull(processoDeCotacaoDeMaterial.DataLimiteDeRetorno);
Assert.AreEqual(processoDeCotacaoDeMaterial.DataLimiteDeRetorno.Value.ToShortDateString(), processoListagem.DataTermino);
}
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]);
}