public void ReenviarEmailDeAbertura(int idProcessoCotacao, int idFornecedorParticipante)
{
ProcessoDeCotacao processoDeCotacao = _processosDeCotacao.BuscaPorId(idProcessoCotacao).Single();
FornecedorParticipante fornecedorParticipante = processoDeCotacao.FornecedoresParticipantes.First(x => x.Id == idProcessoCotacao);
_geradorDeEmail.GerarEmail(fornecedorParticipante);
}
public void QuandoConsultaCotacaoResumidaAntesDoFornecedorInformarCotacaoRetornaObjetoEsperado()
{
ProcessoDeCotacaoDeFrete processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeFrete();
Fornecedor fornecedor = DefaultObjects.ObtemFornecedorPadrao();
FornecedorParticipante fornecedorParticipante = processoDeCotacao.AdicionarFornecedor(fornecedor);
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processoDeCotacao);
UnitOfWorkNh.Session.Clear();
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
KendoGridVm kendoGridVm = consultaProcesso.CotacoesDosFornecedoresResumido(processoDeCotacao.Id);
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
var processoCotacaoFornecedorVm = (ProcessoCotacaoFornecedorVm)kendoGridVm.Registros.First();
Assert.AreEqual(fornecedorParticipante.Id, processoCotacaoFornecedorVm.IdFornecedorParticipante);
Assert.AreEqual(fornecedor.Codigo, processoCotacaoFornecedorVm.Codigo);
Assert.AreEqual(fornecedor.Nome, processoCotacaoFornecedorVm.Nome);
Assert.AreEqual("Não", processoCotacaoFornecedorVm.Selecionado);
Assert.IsNull(processoCotacaoFornecedorVm.ValorLiquido);
Assert.IsNull(processoCotacaoFornecedorVm.ValorComImpostos);
Assert.IsNull(processoCotacaoFornecedorVm.QuantidadeDisponivel);
Assert.AreEqual("Não", processoCotacaoFornecedorVm.VisualizadoPeloFornecedor);
}
public void QuandoConsultaCotacaoDeFornecedoresQueNaoInformaramCotacaoRetornaDadosEsperados()
{
ProcessoDeCotacaoDeFrete processo = DefaultObjects.ObtemProcessoDeCotacaoDeFreteComFornecedor();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processo);
FornecedorParticipante fornecedorParticipante = processo.FornecedoresParticipantes.Single();
Fornecedor fornecedor = fornecedorParticipante.Fornecedor;
var consulta = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeFrete>();
IList <CotacaoSelecionarVm> cotacoes = consulta.CotacoesDosFornecedores(processo.Id);
Assert.AreEqual(1, cotacoes.Count);
var cotacaoSelecionarVm = cotacoes.Single();
Assert.AreEqual(fornecedor.Cnpj, cotacaoSelecionarVm.Cnpj);
Assert.AreEqual(fornecedor.Nome, cotacaoSelecionarVm.Fornecedor);
Assert.AreEqual(fornecedor.Codigo, cotacaoSelecionarVm.CodigoFornecedor);
Assert.AreEqual(0, cotacaoSelecionarVm.IdCotacao);
Assert.AreEqual(0, cotacaoSelecionarVm.IdProcessoCotacaoItem);
Assert.IsFalse(cotacaoSelecionarVm.Selecionada);
Assert.IsNull(cotacaoSelecionarVm.QuantidadeAdquirida);
Assert.IsNull(cotacaoSelecionarVm.QuantidadeDisponivel);
Assert.IsNull(cotacaoSelecionarVm.ValorComImpostos);
Assert.IsNull(cotacaoSelecionarVm.ObservacaoDoFornecedor);
}
public void GerarEmail(FornecedorParticipante fornecedorParticipante)
{
if (string.IsNullOrEmpty(fornecedorParticipante.Fornecedor.Email))
{
throw new UsuarioSemEmailException(fornecedorParticipante.Fornecedor.Nome);
}
MensagemDeEmail mensagemDeEmail = _geradorDeMensagemDeEmail.AberturaDoProcessoDeCotacaoDeMaterial(fornecedorParticipante.ProcessoDeCotacao);
_emailService.Enviar(fornecedorParticipante.Fornecedor.Email, mensagemDeEmail);
}
public void QuandoAtualizaCotacaoDoFornecedorComSucessoAsPropriedadesDaCotacaoSaoAlteradas()
{
_processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
.Callback((ProcessoDeCotacao processoDeCotacao) =>
{
_unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
_unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
Assert.IsNotNull(processoDeCotacao);
FornecedorParticipante fornecedorParticipante = processoDeCotacao.FornecedoresParticipantes.First();
Assert.IsNotNull(fornecedorParticipante.Cotacao);
var cotacao = (CotacaoMaterial)fornecedorParticipante.Cotacao;
Assert.AreSame(CondicaoDePagamento, cotacao.CondicaoDePagamento);
Assert.AreSame(Incoterm, cotacao.Incoterm);
Assert.AreEqual("Desc Incoterm", cotacao.DescricaoIncoterm);
});
_atualizadorDeCotacao.AtualizarCotacao(_cotacaoAtualizarVm);
}
public void QuandoConsultaCotacaoResumidaAposFornecedorInformarCotacaoRetornaObjetoEsperado()
{
ProcessoDeCotacaoDeFrete processoDeCotacao = DefaultObjects.ObtemProcessoDeCotacaoDeFreteComCotacaoSelecionada();
FornecedorParticipante fornecedorParticipante = processoDeCotacao.FornecedoresParticipantes.First();
Fornecedor fornecedor = fornecedorParticipante.Fornecedor;
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processoDeCotacao);
var consultaProcesso = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeMaterial>();
KendoGridVm kendoGridVm = consultaProcesso.CotacoesDosFornecedoresResumido(processoDeCotacao.Id);
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
var processoCotacaoFornecedorVm = (ProcessoCotacaoFornecedorVm)kendoGridVm.Registros.First();
Assert.AreEqual(fornecedorParticipante.Id, processoCotacaoFornecedorVm.IdFornecedorParticipante);
Assert.AreEqual(fornecedor.Codigo, processoCotacaoFornecedorVm.Codigo);
Assert.AreEqual(fornecedor.Nome, processoCotacaoFornecedorVm.Nome);
Assert.AreEqual("Sim", processoCotacaoFornecedorVm.Selecionado);
Assert.AreEqual("Não", processoCotacaoFornecedorVm.VisualizadoPeloFornecedor);
}
public void QuandoAtualizaItemDaCotacaoDoFornecedorComSucessoAsPropriedadesSaoAlteradas()
{
_processosDeCotacaoMock.Setup(x => x.Save(It.IsAny <ProcessoDeCotacao>()))
.Callback((ProcessoDeCotacao processoDeCotacao) =>
{
_unitOfWorkMock.Verify(x => x.BeginTransaction(), Times.Once());
_unitOfWorkMock.Verify(x => x.Commit(), Times.Never());
Assert.IsNotNull(processoDeCotacao);
FornecedorParticipante fornecedorParticipante = processoDeCotacao.FornecedoresParticipantes.First();
Assert.IsNotNull(fornecedorParticipante.Cotacao);
var cotacaoItem = (CotacaoMaterialItem)fornecedorParticipante.Cotacao.Itens.First();
Assert.AreEqual(110, cotacaoItem.Preco);
Assert.AreEqual((decimal)115.5, cotacaoItem.ValorComImpostos);
Assert.AreEqual(0, cotacaoItem.Mva);
Imposto icms = cotacaoItem.Impostos.Single(x => x.Tipo == Enumeradores.TipoDeImposto.Icms);
Assert.AreEqual(17, icms.Aliquota);
Assert.AreEqual((decimal)18.7, icms.Valor);
});
_atualizadorDeCotacao.AtualizarItemDaCotacao(_cotacaoItemAtualizarVm);
}
public void ConsigoConsultarCotacaoResumidaDosFornecedoresDeUmProcessoDeCotacaoDeFrete()
{
ProcessoDeCotacaoDeFrete processo = DefaultObjects.ObtemProcessoDeCotacaoDeFreteComCotacaoNaoSelecionada();
DefaultPersistedObjects.PersistirProcessoDeCotacaoDeFrete(processo);
FornecedorParticipante fornecedorParticipante = processo.FornecedoresParticipantes.Single();
Fornecedor fornecedor = fornecedorParticipante.Fornecedor;
CotacaoItem cotacaoItem = fornecedorParticipante.Cotacao.Itens.Single();
var consulta = ObjectFactory.GetInstance <IConsultaProcessoDeCotacaoDeFrete>();
KendoGridVm kendoGridVm = consulta.CotacoesDosFornecedoresResumido(processo.Id);
Assert.AreEqual(1, kendoGridVm.QuantidadeDeRegistros);
ProcessoCotacaoFornecedorVm vm = kendoGridVm.Registros.Cast <ProcessoCotacaoFornecedorVm>().Single();
Assert.AreEqual(fornecedor.Codigo, vm.Codigo);
Assert.AreEqual(fornecedor.Nome, vm.Nome);
Assert.AreEqual(fornecedorParticipante.Id, vm.IdFornecedorParticipante);
Assert.AreEqual(cotacaoItem.QuantidadeDisponivel, vm.QuantidadeDisponivel);
Assert.AreEqual("Não", vm.Selecionado);
Assert.AreEqual(cotacaoItem.ValorComImpostos, vm.ValorComImpostos);
Assert.AreEqual(cotacaoItem.Preco, vm.ValorLiquido);
}
public void GerarEmail(FornecedorParticipante fornecedorParticipante)
{
MensagemDeEmail mensagemDeEmail = _geradorDeMensagemDeEmail.AberturaDoProcessoDeCotacaoDeFrete(fornecedorParticipante.ProcessoDeCotacao);
_emailService.Enviar(fornecedorParticipante.Fornecedor.Email, mensagemDeEmail);
}
public KendoGridVm ConsultarResumo(PaginacaoVm paginacaoVm, EficienciaNegociacaoFiltroVm filtro)
{
IQueryOver <ProcessoDeCotacao, ProcessoDeCotacao> queryOver = _processosDeCotacaoDeMaterial.GetQueryOver();
queryOver = queryOver
.Where(x => x.GetType() == typeof(ProcessoDeCotacaoDeMaterial))
.And(x => x.Status == Enumeradores.StatusProcessoCotacao.Fechado);
Usuario compradorAlias = null;
queryOver = queryOver
.JoinAlias(x => x.Comprador, () => compradorAlias);
if (!string.IsNullOrEmpty(filtro.LoginComprador))
{
queryOver = queryOver.Where(() => compradorAlias.Login == filtro.LoginComprador);
}
if (filtro.DataDeFechamentoInicial.HasValue)
{
queryOver = queryOver.Where(x => x.DataDeFechamento >= filtro.DataDeFechamentoInicial.Value);
}
if (filtro.DataDeFechamentoFinal.HasValue)
{
queryOver = queryOver.Where(x => x.DataDeFechamento <= filtro.DataDeFechamentoFinal.Value);
}
ProcessoDeCotacaoDeMaterialItem processoDeCotacaoItem = null;
queryOver = queryOver
.JoinAlias(x => x.Itens, () => processoDeCotacaoItem);
//para contabilizar os registros a query deve ser feita antes de fazer junção com as outras tabelas, para evitar repetições.
//Precisa ter junção apenas com os itens do processo de cotação
var contadorDeRegistros = queryOver.ToRowCountQuery().SingleOrDefault <int>();
EficienciaDeNegociacaoResumoVm eficienciaDeNegociacaoResumoVm = null;
FornecedorParticipante fornecedorParticipante = null;
Cotacao cotacao = null;
CotacaoMaterialItem cotacaoItem = null;
Produto produto = null;
RequisicaoDeCompra requisicaoDeCompra = null;
queryOver = queryOver
.JoinAlias(() => processoDeCotacaoItem.Produto, () => produto)
.JoinAlias(() => processoDeCotacaoItem.RequisicaoDeCompra, () => requisicaoDeCompra)
.JoinAlias(x => x.FornecedoresParticipantes, () => fornecedorParticipante)
.JoinAlias(() => fornecedorParticipante.Cotacao, () => cotacao)
.JoinAlias(() => cotacao.Itens, () => cotacaoItem)
.Where(() => cotacaoItem.Selecionada);
//Para calcular o percentual e o valor de eficiência tive que utilizar SQLProjection porque o método SelectSum()
// não entende uma expressão lambda, como por exemplo, "() => (PrecoInicial - Preco) * QuantidadeAdquirida)".
//O método espera uma expressao lambda com o nome de uma propriedade que leve, para uma coluna do mapeamento.
IProjection projecaoValorDeEficiencia =
Projections.SqlProjection("SUM((PrecoInicial - Preco) * QuantidadeAdquirida) AS ValorDeEficiencia",
new[] { "ValorDeEficiencia" }, new IType[] { NHibernateUtil.Decimal });
IProjection projecaoPercentualDeEficiencia =
Projections.SqlProjection(
"ROUND(SUM((PrecoInicial - Preco) * QuantidadeAdquirida) / SUM(PrecoInicial * QuantidadeAdquirida) * 100, 2) AS PercentualDeEficiencia",
new[] { "PercentualDeEficiencia" }, new IType[] { NHibernateUtil.Decimal });
IList <EficienciaDeNegociacaoResumoVm> eficiencias = queryOver
.SelectList(list => list
.SelectGroup(x => x.Id).WithAlias(() => eficienciaDeNegociacaoResumoVm.IdProcessoCotacao)
.SelectGroup(() => processoDeCotacaoItem.Id).WithAlias(() => eficienciaDeNegociacaoResumoVm.IdProcessoCotacaoItem)
.SelectGroup(x => compradorAlias.Nome).WithAlias(() => eficienciaDeNegociacaoResumoVm.Comprador)
.SelectGroup(() => produto.Descricao).WithAlias(() => eficienciaDeNegociacaoResumoVm.Produto)
.SelectGroup(() => requisicaoDeCompra.Numero).WithAlias(() => eficienciaDeNegociacaoResumoVm.NumeroDaRequisicao)
.SelectGroup(() => requisicaoDeCompra.NumeroItem).WithAlias(() => eficienciaDeNegociacaoResumoVm.NumeroDoItem)
.Select(projecaoValorDeEficiencia)
.Select(projecaoPercentualDeEficiencia)
)
.TransformUsing(Transformers.AliasToBean <EficienciaDeNegociacaoResumoVm>())
.Skip(paginacaoVm.Skip)
.Take(paginacaoVm.Take)
.List <EficienciaDeNegociacaoResumoVm>();
var eficienciaTotal = queryOver
.SelectList(list => list
.Select(Projections.Constant("TOTAL")).WithAlias(() => eficienciaDeNegociacaoResumoVm.Produto)
.Select(projecaoValorDeEficiencia)
.Select(projecaoPercentualDeEficiencia)
)
.TransformUsing(Transformers.AliasToBean <EficienciaDeNegociacaoResumoVm>())
.SingleOrDefault <EficienciaDeNegociacaoResumoVm>();
eficiencias.Add(eficienciaTotal);
return(new KendoGridVm
{
QuantidadeDeRegistros = contadorDeRegistros + 1, //soma 1 por causa do registro de total
Registros = eficiencias.Cast <ListagemVm>().ToList()
});
}
