WebSVN - Integrator Subversion - Blame - Rev 690 - /projeto/espacocase/src/main/java/br/com/ec/domain/service/venda/impl/VendaServiceImpl.java

Rev	Author	Line No.	Line
149	espaco	1	package br.com.ec.domain.service.venda.impl;
		2
		3	import java.util.ArrayList;
		4	import java.util.Date;
		5	import java.util.List;
		6	import java.util.Map;
		7
		8	import org.springframework.beans.factory.annotation.Autowired;
		9	import org.springframework.stereotype.Service;
		10
195	espaco	11	import br.com.ec.core.consulta.ParametrosConsulta;
		12	import br.com.ec.core.exception.NegocioException;
		13	import br.com.ec.core.generic.AbstractService;
		14	import br.com.ec.core.generic.GenericRepository;
		15	import br.com.ec.core.util.DataUtils;
		16	import br.com.ec.core.util.StringUtil;
		17	import br.com.ec.core.util.VerificadorUtil;
		18	import br.com.ec.core.validador.Validador;
149	espaco	19	import br.com.ec.domain.dto.GraficoAcumuladoDTO;
		20	import br.com.ec.domain.dto.ParametrosConsultaLancamentosDTO;
		21	import br.com.ec.domain.dto.ParametrosConsultaModelosMaisVendidosDTO;
		22	import br.com.ec.domain.dto.ParametrosConsultaParaComprasTransferenciasDTO;
		23	import br.com.ec.domain.dto.ParametrosConsultaPedidoDTO;
		24	import br.com.ec.domain.dto.ParametrosConsultaPorPeriodoDTO;
		25	import br.com.ec.domain.dto.ParametrosConsultaProdutosVendidosDTO;
		26	import br.com.ec.domain.dto.ParametrosConsultaVendasDTO;
		27	import br.com.ec.domain.dto.ParametrosConsultaVendasVivoDTO;
		28	import br.com.ec.domain.dto.ParametrosVendaDTO;
		29	import br.com.ec.domain.dto.RankingComprasTransferenciasDTO;
		30	import br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO;
600	blopes	31	import br.com.ec.domain.dto.RankingComprasTransferenciasSubtipoProdutoDTO;
149	espaco	32	import br.com.ec.domain.dto.RankingLojaDTO;
		33	import br.com.ec.domain.dto.RankingModeloDTO;
		34	import br.com.ec.domain.dto.RankingProdutoDTO;
		35	import br.com.ec.domain.dto.RankingVendedorDTO;
		36	import br.com.ec.domain.dto.VendasDTO;
		37	import br.com.ec.domain.model.Avaliacao;
		38	import br.com.ec.domain.model.AvaliacaoFuncionario;
356	espaco	39	import br.com.ec.domain.model.AvaliacaoProduto;
149	espaco	40	import br.com.ec.domain.model.Categoria;
		41	import br.com.ec.domain.model.Cupom;
		42	import br.com.ec.domain.model.EstoqueAuditoria;
		43	import br.com.ec.domain.model.FormaPagamento;
		44	import br.com.ec.domain.model.Lancamento;
		45	import br.com.ec.domain.model.Loja;
		46	import br.com.ec.domain.model.Marca;
		47	import br.com.ec.domain.model.Modelo;
		48	import br.com.ec.domain.model.NotaFiscal;
		49	import br.com.ec.domain.model.Pedido;
		50	import br.com.ec.domain.model.PedidoHistorico;
		51	import br.com.ec.domain.model.Produto;
600	blopes	52	import br.com.ec.domain.model.SubtipoProduto;
149	espaco	53	import br.com.ec.domain.model.Usuario;
577	blopes	54	import br.com.ec.domain.model.UsuarioPerfil;
149	espaco	55	import br.com.ec.domain.model.Venda;
		56	import br.com.ec.domain.model.VendaFormaPagamento;
		57	import br.com.ec.domain.model.Vendedor;
		58	import br.com.ec.domain.model.Vigencia;
		59	import br.com.ec.domain.model.tipos.TipoEmitirNotaFiscal;
		60	import br.com.ec.domain.model.tipos.TipoEstiloProduto;
		61	import br.com.ec.domain.model.tipos.TipoEstoqueAuditoria;
		62	import br.com.ec.domain.model.tipos.TipoOrdenacaoPlanejamentoCompras;
		63	import br.com.ec.domain.model.tipos.TipoProduto;
		64	import br.com.ec.domain.model.tipos.TipoSituacaoPedido;
		65	import br.com.ec.domain.model.tipos.TipoSituacaoVenda;
		66	import br.com.ec.domain.service.avaliacao.AvaliacaoService;
		67	import br.com.ec.domain.service.avaliacaofuncionario.AvaliacaoFuncionarioService;
		68	import br.com.ec.domain.service.avaliacaoloja.AvaliacaoLojaService;
		69	import br.com.ec.domain.service.bancohoras.BancoHorasService;
685	blopes	70	import br.com.ec.domain.service.cashback.CashbackService;
149	espaco	71	import br.com.ec.domain.service.cupom.CupomService;
		72	import br.com.ec.domain.service.email.impl.GerenciadorEmailImpl;
		73	import br.com.ec.domain.service.estoqueauditoria.EstoqueAuditoriaService;
		74	import br.com.ec.domain.service.funcionario.FuncionarioService;
		75	import br.com.ec.domain.service.lancamento.LancamentoService;
		76	import br.com.ec.domain.service.loja.LojaService;
		77	import br.com.ec.domain.service.modelo.ModeloService;
		78	import br.com.ec.domain.service.parcela.ParcelaService;
		79	import br.com.ec.domain.service.pedido.PedidoService;
635	blopes	80	import br.com.ec.domain.service.posvenda.PosVendaService;
149	espaco	81	import br.com.ec.domain.service.produto.ProdutoService;
		82	import br.com.ec.domain.service.produtodaloja.ProdutoLojaService;
577	blopes	83	import br.com.ec.domain.service.usuario.UsuarioService;
149	espaco	84	import br.com.ec.domain.service.venda.VendaService;
		85	import br.com.ec.domain.service.vendaformapagamento.VendaFormaPagamentoService;
		86	import br.com.ec.domain.service.vendavivo.VendaVivoService;
		87	import br.com.ec.domain.service.vendedor.VendedorService;
356	espaco	88	import br.com.ec.domain.service.vigencia.VigenciaService;
149	espaco	89	import br.com.ec.domain.shared.ConstantesSEC;
		90	import br.com.ec.domain.shared.Ordenador;
		91	import br.com.ec.domain.shared.OrdenadorImpl;
		92	import br.com.ec.infrastructure.repository.NotaFiscalRepository;
		93	import br.com.ec.infrastructure.repository.VendaRepository;
		94
		95	@Service
		96	public class VendaServiceImpl extends AbstractService<Venda> implements VendaService {
		97
		98	private VendaRepository vendaRepository;
		99
		100	private LancamentoService lancamentoService;
		101	private VendaFormaPagamentoService vendaFormaPagamentoService;
		102	private ProdutoService produtoService;
		103	private ProdutoLojaService produtoLojaService;
		104	private VendedorService vendedorService;
		105	private FuncionarioService funcionarioService;
		106	private LojaService lojaService;
		107	private PedidoService pedidoService;
		108	private ParcelaService parcelaService;
		109	private AvaliacaoService avaliacaoService;
		110	private AvaliacaoFuncionarioService avaliacaoFuncionarioService;
		111	private AvaliacaoLojaService avaliacaoLojaService;
		112	private VendaVivoService vendaVivoService;
		113	private ModeloService modeloService;
		114	private CupomService cupomService;
		115	private BancoHorasService bancoHorasService;
		116	private EstoqueAuditoriaService estoqueAuditoriaService;
356	espaco	117	private VigenciaService vigenciaService;
577	blopes	118	private UsuarioService usuarioService;
635	blopes	119	private PosVendaService posVendaService;
685	blopes	120	private CashbackService cashbackService;
149	espaco	121
		122	private Ordenador ordenador;
		123	private NotaFiscalRepository notaFiscalRepository;
		124
		125	@Autowired
		126	public VendaServiceImpl(Validador validador, VendaRepository vendaRepository, LancamentoService lancamentoService,
		127	VendaFormaPagamentoService vendaFormaPagamentoService, ProdutoService produtoService, ProdutoLojaService produtoLojaService,
		128	VendedorService vendedorService, FuncionarioService funcionarioService, LojaService lojaService, PedidoService pedidoService,
		129	ParcelaService parcelaService, AvaliacaoService avaliacaoService, AvaliacaoFuncionarioService avaliacaoFuncionarioService,
		130	AvaliacaoLojaService avaliacaoLojaService, VendaVivoService vendaVivoService, ModeloService modeloService, CupomService cupomService,
356	espaco	131	BancoHorasService bancoHorasService, EstoqueAuditoriaService estoqueAuditoriaService, VigenciaService vigenciaService,
685	blopes	132	UsuarioService usuarioService, PosVendaService posVendaService, CashbackService cashbackService, NotaFiscalRepository notaFiscalRepository) {
149	espaco	133	super(validador);
		134	this.vendaRepository = vendaRepository;
		135	this.funcionarioService = funcionarioService;
		136	this.lancamentoService = lancamentoService;
		137	this.vendaFormaPagamentoService = vendaFormaPagamentoService;
		138	this.produtoService = produtoService;
		139	this.produtoLojaService = produtoLojaService;
		140	this.vendedorService = vendedorService;
		141	this.lojaService = lojaService;
		142	this.pedidoService = pedidoService;
		143	this.parcelaService = parcelaService;
		144	this.avaliacaoService = avaliacaoService;
		145	this.avaliacaoFuncionarioService = avaliacaoFuncionarioService;
		146	this.avaliacaoLojaService = avaliacaoLojaService;
		147	this.vendaVivoService = vendaVivoService;
		148	this.modeloService = modeloService;
		149	this.cupomService = cupomService;
		150	this.bancoHorasService = bancoHorasService;
		151	this.estoqueAuditoriaService = estoqueAuditoriaService;
356	espaco	152	this.vigenciaService = vigenciaService;
577	blopes	153	this.usuarioService = usuarioService;
635	blopes	154	this.posVendaService = posVendaService;
685	blopes	155	this.cashbackService = cashbackService;
356	espaco	156	this.notaFiscalRepository = notaFiscalRepository;
149	espaco	157	this.ordenador = new OrdenadorImpl();
		158	}
		159
		160	@Override
		161	protected GenericRepository<Venda> getRepository() {
		162	return vendaRepository;
		163	}
		164
		165	@Override
		166	protected void regrasNegocioCadastrar(Venda venda) {
		167	if (VerificadorUtil.estaNulo(venda.getVendedor())) {
		168	throw new NegocioException("Obrigatório informar o vendedor.");
		169	}
		170	venda.setDataVenda(DataUtils.getDataAtual());
		171	venda.setTipoSituacao(TipoSituacaoVenda.NOVO.getValor());
		172	}
		173
		174	/***************************************************************/
		175
		176	@Override
		177	public Venda detalharVenda(Venda venda) {
		178	return vendaRepository.detalharVenda(venda);
		179	}
		180
		181	@Override
		182	public Venda detalharVendaCompleta(Venda venda) {
		183	return vendaRepository.detalharVendaCompleta(venda);
		184	}
		185
		186	public void excluirVenda(Venda venda, Usuario usuario) {
		187	List<NotaFiscal> notasVinculadas = desvincularNotaFiscalEmitida(venda, usuario);
		188	verificarSeExisteLancamentoFinanceiro(venda);
		189	reporEstoqueAoExcluirVenda(venda);
635	blopes	190	excluirPosVenda(venda);
149	espaco	191	excluirPagamentos(venda);
689	blopes	192	excluirCashback(venda);
237	espaco	193	desvincularPedido(venda, usuario);
149	espaco	194	super.excluir(venda);
		195	enviarEmail(venda, usuario, notasVinculadas);
		196	}
		197
		198	private List<NotaFiscal> desvincularNotaFiscalEmitida(Venda venda, Usuario usuario) {
		199	List<NotaFiscal> notasFiscais = notaFiscalRepository.consultarNotasFiscais(venda);
		200	for (NotaFiscal nf : notasFiscais) {
		201	nf.setObservacaoVenda("VENDA ID: " + venda.getSequencial() + " em " +
		202	DataUtils.converterDataComHorarioParaString(venda.getDataVenda()) + ". " +
		203	venda.getJustificativaParaExcluir());
		204	notaFiscalRepository.desvincularVenda(nf);
		205	}
		206	return notasFiscais;
		207	}
		208
		209	private void verificarSeExisteLancamentoFinanceiro(Venda venda) {
		210	if (parcelaService.verificarPossuiParcela(venda)) {
		211	throw new NegocioException("Não é permitido excluir uma venda com lançamentos financeiros.");
		212	}
		213	}
		214
		215	public void reporEstoqueAoExcluirVenda(Venda venda) {
		216	for (Lancamento lancamento : venda.getLancamentos()) {
305	espaco	217	alterarEstoqueProduto(1, venda.getLoja(), lancamento.getProduto().getCodigo(), lancamento.getTipoPersonalizacao());
149	espaco	218	}
		219	}
		220
635	blopes	221	public void excluirPosVenda(Venda venda) {
		222	posVendaService.excluirPosVenda(venda.getSequencial());
		223	}
		224
149	espaco	225	private void excluirPagamentos(Venda venda) {
		226	for (VendaFormaPagamento vendaFormaPagamento : venda.getListaVendaFormaPagamentos()) {
		227	// vendaFormaPagamentoService.excluirPorId(vendaFormaPagamento);
		228	vendaFormaPagamentoService.excluir(vendaFormaPagamento);
		229	}
		230	}
		231
689	blopes	232	private void excluirCashback(Venda venda) {
		233	cashbackService.excluirCashbackVenda(venda.getSequencial());
		234	}
		235
237	espaco	236	private void desvincularPedido(Venda venda, Usuario usuario) {
		237	Pedido pedidoCompleto = pedidoService.consultarPedidoCompletoDaVenda(venda);
246	espaco	238	if (VerificadorUtil.naoEstaNulo(pedidoCompleto)) {
		239	PedidoHistorico pedidoHistorico = new PedidoHistorico();
		240	pedidoHistorico.setPedido(pedidoCompleto);
		241	pedidoHistorico.setDataHistorico(DataUtils.getDataAtual());
		242	pedidoHistorico.setObservacao("VENDA: " + venda.getSequencial() + " FOI ESTORNADA.");
		243	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getJustificativaParaExcluir())) {
		244	pedidoHistorico.setObservacao(pedidoHistorico.getObservacao() + " JUSTIFICATIVA: " + venda.getJustificativaParaExcluir());
		245	}
		246	pedidoHistorico.setTipoSituacao(TipoSituacaoPedido.PENDENTE.getValor());
		247	pedidoHistorico.setUsuario(usuario);
		248	pedidoCompleto.getHistorico().add(pedidoHistorico);
		249	pedidoCompleto.setTipoSituacao(TipoSituacaoPedido.PENDENTE.getValor());
		250	pedidoCompleto.setDataUltimaAlteracaoSituacao(DataUtils.getDataAtual());
		251	pedidoCompleto.setVenda(null);
		252	pedidoService.alterar(pedidoCompleto);
237	espaco	253	}
		254	}
		255
149	espaco	256	private void enviarEmail(Venda venda, Usuario usuario, List<NotaFiscal> notasFiscaisVinculadas) {
		257	String diaAtual = DataUtils.converterDataParaString(DataUtils.getDataAtual());
		258	StringBuilder conteudo = new StringBuilder();
		259	conteudo.append(montarDadosDaVenda(venda, usuario, venda.getLancamentos(), venda.getVendaFormaPagamentos()));
		260	if (!notasFiscaisVinculadas.isEmpty()) {
		261	conteudo.append("--------------------------------------------------\n\n");
		262	conteudo.append("NOTAS FISCAIS DESVINCULADAS:\n");
		263	for (NotaFiscal nota : notasFiscaisVinculadas) {
		264	conteudo.append("NÚMERO: " + nota.getNumeroNotaFiscal() + "\n");
		265	}
		266	}
		267	new GerenciadorEmailImpl()
		268	.comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_DIRECAO)
		269	.comAssunto("ESPAÇO CASE - OPERAÇÃO DE EXCLUSÃO DE VENDA: " + diaAtual)
		270	.comConteudo(conteudo.toString())
		271	.enviar();
		272	}
		273
		274	@Override
		275	public Venda cadastrarVendaPeloPDV(ParametrosVendaDTO parametrosVenda) {
		276	verificarLancamentos(parametrosVenda.getLancamentos());
		277	// lancarExcecaoCasoFreteContraditorio(parametrosVenda);
		278	lancarExcecaoCasoNaoSejaInformadoCamposObrigatorios(parametrosVenda);
		279	lancarExcecaoSeValoresNaoSaoIguais(parametrosVenda);
		280	Venda venda = new Venda(parametrosVenda);
		281	cadastrar(venda);
		282	cadastrarLancamentos(parametrosVenda, venda);
		283	cadastrarPagamentos(parametrosVenda, venda);
635	blopes	284	cadastrarPosVenda(venda);
686	blopes	285	atualizarCashback(parametrosVenda, venda);
149	espaco	286	alterarSituacaoPedido(parametrosVenda.getPedidoVinculado(), venda);
		287	enviarAlertasPorEmail(parametrosVenda, venda);
		288	venda.verificarSePermiteEmissaoNotaFiscal();
		289	venda.setEmitirNotaFiscal(verificarEmissaoNotaFiscal(parametrosVenda, venda));
		290	return venda;
		291	}
		292
		293	private Boolean verificarEmissaoNotaFiscal(ParametrosVendaDTO parametrosVenda, Venda venda) {
		294	if (venda.getPermitirEmissaoNotaFiscal() == false) {return false;}
		295	Boolean emitir = null;
		296	emitir = naoEmitirLojaSemPermissao(parametrosVenda);
		297	if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
		298
		299	emitir = naoEmitirCpfCnpjInvalido(parametrosVenda);
		300	if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
		301
		302	emitir = emitirLojaComEmissaoObrigatoria(parametrosVenda);
		303	if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
		304
		305	emitir = emitirProdutoComEmissaoObrigatoria(parametrosVenda);
		306	if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
		307
		308	emitir = emitirVendasAcimaQuinhetosReais(parametrosVenda);
		309	if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
		310
		311	emitir = emitirVendaPagamentoCartao(parametrosVenda);
		312	if (VerificadorUtil.naoEstaNulo(emitir)) {return emitir;}
		313	return false;
		314	}
		315
		316	private Boolean naoEmitirLojaSemPermissao(ParametrosVendaDTO parametrosVenda) {
		317	if (parametrosVenda.getLoja().getTipoEmitirNotaFiscal().equals(TipoEmitirNotaFiscal.NAO_PERMITIR_EMISSAO.getValor()) \|\|
		318	parametrosVenda.getLoja().getTipoEmitirNotaFiscal().equals(TipoEmitirNotaFiscal.NAO_EMITIR.getValor())) {
		319	return false;
		320	}
		321	return null;
		322	}
		323
		324	private Boolean naoEmitirCpfCnpjInvalido(ParametrosVendaDTO parametrosVenda) {
		325	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getCliente())) {
		326	if (!parametrosVenda.getCliente().cpfCnpjEhValido()) {
		327	return false;
		328	}
		329	}
		330	return null;
		331	}
		332
		333	private Boolean emitirLojaComEmissaoObrigatoria(ParametrosVendaDTO parametrosVenda) {
		334	if (parametrosVenda.getLoja().getTipoEmitirNotaFiscal().equals(TipoEmitirNotaFiscal.TODAS_VENDAS.getValor())) {
		335	return true;
		336	}
		337	return null;
		338	}
		339
		340
		341
		342	private Boolean emitirProdutoComEmissaoObrigatoria(ParametrosVendaDTO parametrosVenda) {
		343	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		344	if (lancamento.getProduto().getIndicadorEmissaoNotaFiscal()) {
		345	return true;
		346	}
		347	}
		348	return null;
		349	}
		350
		351	private Boolean emitirVendasAcimaQuinhetosReais(ParametrosVendaDTO parametrosVenda) {
		352	Double valorVenda = new Double(0.0);
		353	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		354	valorVenda = valorVenda + lancamento.getValorVenda();
		355	}
		356	if (valorVenda > 499.9) {
		357	return true;
		358	}
		359	return null;
		360	}
		361
		362	private Boolean emitirVendaPagamentoCartao(ParametrosVendaDTO parametrosVenda) {
		363	if (parametrosVenda.getLoja().getTipoEmitirNotaFiscal().equals(TipoEmitirNotaFiscal.VENDAS_OBRIGATORIAS.getValor())) {
		364	for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
690	blopes	365	if (pagamento.getFormaPagamento().formaPagamentoEhPix() \|\|
		366	pagamento.getFormaPagamento().formaPagamentoEhTransferencia() \|\|
		367	pagamento.getFormaPagamento().formaPagamentoEhCredito() \|\|
149	espaco	368	pagamento.getFormaPagamento().formaPagamentoEhDebito() \|\|
		369	pagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {
		370	return true;
		371	}
		372	}
		373	}
		374	return null;
		375	}
		376
		377	private void alterarSituacaoPedido(Pedido pedidoVinculado, Venda venda) {
		378	if (VerificadorUtil.naoEstaNulo(pedidoVinculado)) {
		379	PedidoHistorico pedidoHistorico = new PedidoHistorico();
		380	pedidoHistorico.setDataHistorico(DataUtils.getDataAtual());
		381	pedidoHistorico.setObservacao("VENDA: " + venda.getSequencial());
		382	pedidoHistorico.setTipoSituacao(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor());
		383	pedidoHistorico.setUsuario(venda.getUsuario());
		384	pedidoHistorico.setPedido(pedidoVinculado);
		385	if (VerificadorUtil.estaNulo(pedidoVinculado.getHistorico())) {
		386	pedidoVinculado.setHistorico(new ArrayList<PedidoHistorico>());
		387	}
		388	pedidoVinculado.getHistorico().add(pedidoHistorico);
		389	pedidoVinculado.setTipoSituacao(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor());
		390	pedidoVinculado.setDataUltimaAlteracaoSituacao(DataUtils.getDataAtual());
165	espaco	391	pedidoVinculado.setVenda(venda);
149	espaco	392	pedidoService.alterar(pedidoVinculado);
		393	}
		394	}
		395
		396	private void enviarAlertasPorEmail(ParametrosVendaDTO parametrosVenda, Venda venda) {
577	blopes	397	Boolean enviarAlerta = false;
		398	String emailsDestino = "";
		399	String assuntoAlerta = "";
149	espaco	400	if (descontosEmProdutosSuperiores(parametrosVenda)) {
577	blopes	401	enviarAlerta = true;
		402	emailsDestino = ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO;
		403	assuntoAlerta = "ESPAÇO CASE - VENDA COM DESCONTO SUPERIOR : " + DataUtils.converterDataParaString(DataUtils.getDataAtual());
149	espaco	404	}
		405	if (produtosComDescontoECupom(parametrosVenda)) {
577	blopes	406	enviarAlerta = true;
		407	emailsDestino = ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO;
		408	assuntoAlerta = "ESPAÇO CASE - VENDA COM PRODUTO COM DESCONTO E CUPOM PROMOCIONAL : " + DataUtils.converterDataParaString(DataUtils.getDataAtual());
		409	}
		410	if (possuiMaisDeDuasFormasDePagamento(parametrosVenda)) {
		411	enviarAlerta = true;
		412	emailsDestino = ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO;
		413	assuntoAlerta = "ESPAÇO CASE - VENDA SUSPEITA COM MAIS DE 2 FORMAS DE PAGAMENTO : " + DataUtils.converterDataParaString(DataUtils.getDataAtual());
		414	}
		415	if (enviarAlerta) {
149	espaco	416	new GerenciadorEmailImpl()
577	blopes	417	.comEmailsDestino(emailsDestino)
		418	.comAssunto(assuntoAlerta)
149	espaco	419	.comConteudo(montarDadosDaVenda(venda, venda.getUsuario(), parametrosVenda.getLancamentos(), parametrosVenda.getLancamentosPagamentos()))
		420	.enviar();
		421	}
		422	}
		423
577	blopes	424	private Boolean possuiMaisDeDuasFormasDePagamento(ParametrosVendaDTO parametrosVenda) {
		425	return parametrosVenda.getLancamentosPagamentos().size() > 2;
		426	}
		427
149	espaco	428	/*
		429	private void enviarAlertasPorEmail(ParametrosVendaDTO parametrosVenda, Venda venda) {
		430	if (pagamentoDividido(parametrosVenda)) {
		431	if (descontoEmProdutos(parametrosVenda)) {
		432	String diaAtual = DataUtils.converterDataParaString(DataUtils.getDataAtual());
		433	new GerenciadorEmailImpl()
		434	.comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_DIRECAO)
		435	.comAssunto("ESPAÇO CASE - VENDA DIVIDIDA E COM DESCONTO : " + diaAtual)
		436	.comConteudo(montarDadosDaVenda(venda, venda.getUsuario(), parametrosVenda.getLancamentos(), parametrosVenda.getLancamentosPagamentos()))
		437	.enviar();
		438	}
		439	}
		440	}
320	espaco	441
149	espaco	442
		443	private Boolean pagamentoDividido(ParametrosVendaDTO parametrosVenda) {
		444	for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
		445	if (pagamento.getFormaPagamento().formaPagamentoEhCreditoDividido()) {
		446	return true;
		447	}
		448	}
		449	return false;
		450	}
		451
		452	private boolean descontoEmProdutos(ParametrosVendaDTO parametrosVenda) {
		453	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		454	if (lancamento.comDescontos()) {
		455	return true;
		456	}
		457	}
		458	return false;
		459	}
320	espaco	460	*/
149	espaco	461
		462	private boolean descontosEmProdutosSuperiores(ParametrosVendaDTO parametrosVenda) {
320	espaco	463	if (produtoJBLComDesconto(parametrosVenda.getLancamentos())) {
		464	return true;
		465	}
		466
		467	Double totalDescontoPermitido = 0.0;
		468	Double totalDescontoConcebido = 0.0;
149	espaco	469	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
320	espaco	470	if (VerificadorUtil.naoEstaNulo(lancamento.getValorVarejo()) && VerificadorUtil.naoEstaNulo(lancamento.getValorVenda())) {
		471	totalDescontoConcebido = totalDescontoConcebido + (lancamento.getValorVarejo() - lancamento.getValorVenda());
		472	if (lancamento.getValorVarejo() < 100) {
		473	totalDescontoPermitido = totalDescontoPermitido + 5.0;
		474	} else {
		475	totalDescontoPermitido = totalDescontoPermitido + (lancamento.getValorVarejo()*10/100);
		476	}
		477	}
		478	}
		479	if (totalDescontoConcebido > totalDescontoPermitido) {
		480	return true;
		481	}
		482	return false;
		483	}
		484
		485	private boolean produtoJBLComDesconto(List<Lancamento> lancamentos) {
		486	for (Lancamento lancamento : lancamentos) {
		487	if (lancamento.getProduto().getDescricaoCompleta().contains("JBL") && lancamento.comDescontos()) {
149	espaco	488	return true;
		489	}
		490	}
		491	return false;
		492	}
320	espaco	493
149	espaco	494	private boolean produtosComDescontoECupom(ParametrosVendaDTO parametrosVenda) {
		495	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		496	if (VerificadorUtil.naoEstaNulo(lancamento.getCupom()) && lancamento.comDescontos()) {
		497	return true;
		498	}
		499	}
		500	return false;
		501	}
		502
		503	@Override
		504	public void alterarVenda(ParametrosVendaDTO parametrosVenda, Usuario usuario, Boolean verificarJustificativa) {
		505	verificarLancamentos(parametrosVenda.getLancamentos());
577	blopes	506	lancarExcecaoSeUsuarioNaoTiverPermissao(parametrosVenda, usuario, verificarJustificativa);
149	espaco	507	lancarExcecaoCasoNaoSejaInformadoCamposObrigatorios(parametrosVenda);
		508	lancarExcecaoSeValoresNaoSaoIguais(parametrosVenda);
		509	if (verificarJustificativa) {enviarEmailAlteracoes(parametrosVenda, usuario);}
		510	atualizarDadosDaVenda(parametrosVenda);
		511	alterarLancamentos(parametrosVenda);
		512	alterarPagamentos(parametrosVenda);
		513	alterar(parametrosVenda.getVenda());
		514	alterarSituacaoPedido(parametrosVenda.getPedidoVinculado(), parametrosVenda.getVenda());
		515	}
		516
577	blopes	517	private void lancarExcecaoSeUsuarioNaoTiverPermissao(ParametrosVendaDTO parametrosVenda, Usuario usuario, Boolean verificarJustificativa) {
		518	if (verificarJustificativa) {
		519	for (UsuarioPerfil usuarioPerfil : usuario.getPerfis()) {
		520	if (usuarioPerfil.getPerfil().getCodigo().equals(ConstantesSEC.PERFIL_LOJA_9)) {
		521	throw new NegocioException("USUÁRIO SEM PERMISSÃO PARA ESTA OPERAÇÃO");
		522	}
		523	}
		524
		525	if (!parametrosVenda.getVendedor().equals(parametrosVenda.getVenda().getVendedor())) {
		526	Usuario usuarioDetalhe = usuarioService.detalhar(usuario);
		527	if (VerificadorUtil.naoEstaNulo(usuarioDetalhe.getPessoa())) {
		528	if (!parametrosVenda.getVenda().getVendedor().getPessoa().equals(usuarioDetalhe.getPessoa())) {
		529	throw new NegocioException("OPERAÇÃO SÓ PODE SER REALIZADA PELO VENDEDOR ATUAL");
		530	}
		531	} else {
		532	throw new NegocioException("USUÁRIO SEM PERMISSÃO PARA ESTA OPERAÇÃO");
		533	}
		534	}
		535	}
		536	}
		537
149	espaco	538	private void enviarEmailAlteracoes(ParametrosVendaDTO parametrosVenda, Usuario usuario) {
		539	String diaAtual = DataUtils.converterDataParaString(DataUtils.getDataAtual());
		540	StringBuilder conteudo = new StringBuilder();
		541	conteudo.append("OPERAÇÃO REALIZADA POR: " + usuario.getNome() + "\n");
		542	conteudo.append("ID: " + parametrosVenda.getVenda().getSequencial() + "\n");
		543	conteudo.append("DATA DA VENDA: " + DataUtils.converterDataComHorarioParaString(parametrosVenda.getVenda().getDataVenda()) + "\n");
		544	conteudo.append("ALTERAÇÕES:\n");
		545	if (!parametrosVenda.getLoja().equals(parametrosVenda.getVenda().getLoja())) {
		546	conteudo.append("LOJA: " + parametrosVenda.getVenda().getLoja().getDescricao() + " -> " + parametrosVenda.getLoja().getDescricao() + "\n");
		547	}
		548	if (!parametrosVenda.getVendedor().equals(parametrosVenda.getVenda().getVendedor())) {
		549	conteudo.append("VENDEDOR: " + parametrosVenda.getVenda().getVendedor().getNomeDaPessoa() + " -> " + parametrosVenda.getVendedor().getNomeDaPessoa() + "\n");
		550	}
		551
		552	String indicacao = "NÃO INFORMADO";
		553	String novaIndicacao = "NÃO INFORMADO";
		554	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getVenda().getIndicacao())) {
		555	indicacao = parametrosVenda.getVenda().getIndicacao().getNome();
		556	}
		557	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getIndicacao())) {
		558	novaIndicacao = parametrosVenda.getIndicacao().getNome();
		559	}
		560	if (!indicacao.equals(novaIndicacao)) {
		561	conteudo.append("INDICAÇÃO: " + indicacao + " -> " + novaIndicacao + "\n");
		562	}
		563
		564	String cliente = "NÃO INFORMADO";
		565	String novoCliente = "NÃO INFORMADO";
		566	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getVenda().getCliente())) {
		567	cliente = parametrosVenda.getVenda().getCliente().getNome();
		568	}
		569	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getCliente())) {
		570	novoCliente = parametrosVenda.getCliente().getNome();
		571	}
		572	if (!cliente.equals(novoCliente)) {
		573	conteudo.append("CLIENTE: " + cliente + " -> " + novoCliente + "\n");
		574	}
		575
		576	if (!parametrosVenda.getObservacao().equals(parametrosVenda.getVenda().getObservacao())) {
		577	conteudo.append("OBS: " + parametrosVenda.getVenda().getObservacao() + " -> " + parametrosVenda.getObservacao() + "\n");
		578	}
		579
		580	String formasPagamento = "";
		581	String novasFormasPagamento = "";
		582	List<VendaFormaPagamento> pagamentosAnteriores = consultarPagamentosCadastrados(parametrosVenda);
		583	if (!VerificadorUtil.isListaNulaOuVazia(pagamentosAnteriores)) {
		584	for (VendaFormaPagamento pagamento : pagamentosAnteriores) {
		585	formasPagamento = formasPagamento + " R$" + pagamento.getValorPagamento() + " (" + pagamento.getFormaPagamento().getDescricao();
		586	if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
		587	formasPagamento = formasPagamento + " - " + pagamento.getBandeiraCartao().getTipoCartaoDescricao() + " - " + pagamento.getDescricaoDaBandeiraCartao();
		588	}
		589	formasPagamento = formasPagamento + "); ";
		590	}
		591	}
		592	if (!VerificadorUtil.isListaNulaOuVazia(parametrosVenda.getLancamentosPagamentos())) {
		593	for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
		594	novasFormasPagamento = novasFormasPagamento + " R$" + pagamento.getValorPagamento() + " (" + pagamento.getFormaPagamento().getDescricao();
		595	if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
		596	novasFormasPagamento = novasFormasPagamento + " - " + pagamento.getBandeiraCartao().getTipoCartaoDescricao() + " - " + pagamento.getDescricaoDaBandeiraCartao();
		597	}
		598	novasFormasPagamento = novasFormasPagamento + "); ";
		599	}
		600	}
		601	if (!formasPagamento.equals(novasFormasPagamento)) {
		602	conteudo.append("FORMAS DE PAGAMENTO: " + formasPagamento + " -> " + novasFormasPagamento + "\n");
		603	}
		604
		605	conteudo.append("\n");
		606	conteudo.append("JUSTIFICATIVA: " + parametrosVenda.getVenda().getJustificativaParaExcluir() + "\n");
		607	new GerenciadorEmailImpl()
		608	.comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO)
		609	.comAssunto("ESPAÇO CASE - ALTERAÇÃO DE VENDA: " + diaAtual)
		610	.comConteudo(conteudo.toString())
		611	.enviar();
		612	}
		613
		614	private String montarDadosDaVenda(Venda venda, Usuario usuario, List<Lancamento> lancamentos, List<VendaFormaPagamento> pagamentos) {
		615	StringBuilder conteudo = new StringBuilder();
		616	conteudo.append("OPERAÇÃO REALIZADA POR: " + usuario.getNome() + "\n");
		617	conteudo.append("ID: " + venda.getSequencial() + "\n");
		618	conteudo.append("DATA DA VENDA: " + DataUtils.converterDataComHorarioParaString(venda.getDataVenda()) + "\n");
		619	conteudo.append("LOJA: " + venda.getLoja().getDescricao() + "\n");
		620	conteudo.append("VENDEDOR: " + venda.getVendedor().getNomeDaPessoa() + "\n");
		621	conteudo.append("TOTAL: " + valorTotalVenda(lancamentos) + "\n");
		622	conteudo.append("OBS.: " + venda.getObservacao() + "\n");
		623	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getJustificativaParaExcluir())) {
		624	conteudo.append("JUSTIFICATIVA: " + venda.getJustificativaParaExcluir() + "\n");
		625	} else {
		626	conteudo.append("SEM JUSTIFICATIVA\n");
		627	}
		628	conteudo.append("--------------------------------------------------\n");
		629	for (Lancamento lancamento : lancamentos) {
		630	conteudo.append(lancamento.getProduto().getCodigoProdutoPadrao() + " \| ");
		631	conteudo.append(lancamento.getProduto().getDescricaoComModeloCompleta() + ", ");
		632	conteudo.append("R$" + lancamento.getValorVenda());
		633	if (lancamento.comDescontos()) {
		634	conteudo.append(" (COM DESCONTO DE R$" + lancamento.valorDescontos());
		635	conteudo.append(" [" + lancamento.valorPercentualDescontos() + "])");
		636	}
		637	if (VerificadorUtil.naoEstaNuloOuVazio(lancamento.getObservacao())) {
		638	conteudo.append(" (OBS.: " + lancamento.getObservacao() + ")");
		639	}
		640	if (VerificadorUtil.naoEstaNulo(lancamento.getCupom())) {
		641	String descricaoCupom = lancamento.getCupom().getCodigo();
		642	if (VerificadorUtil.naoEstaNulo(lancamento.getCupom().getDescricao())) {
		643	descricaoCupom = descricaoCupom + " - " + lancamento.getCupom().getDescricao();
		644	}
		645	conteudo.append(" (CUPOM: " + descricaoCupom + ")");
		646	}
		647	conteudo.append("\n");
		648	}
		649	conteudo.append("--------------------------------------------------\n");
		650	for (VendaFormaPagamento pagamento : pagamentos) {
		651	if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
		652	conteudo.append(pagamento.getFormaPagamento().getDescricao() + " - " + pagamento.getBandeiraCartao().getDescricao() + ": R$" + pagamento.getValorPagamento() + "\n");
		653	} else {
		654	conteudo.append(pagamento.getFormaPagamento().getDescricao() + ": R$" + pagamento.getValorPagamento() + "\n");
		655	}
		656	conteudo.append("\n");
		657	}
		658	conteudo.append("--------------------------------------------------\n");
		659	if (VerificadorUtil.naoEstaNulo(venda.getCliente())) {
		660	conteudo.append("DADOS DO CLIENTE:\n");
		661	conteudo.append(venda.getCliente().getNome() + "\n");
		662	conteudo.append(venda.getCliente().getCpfCnpjFormatado() + "\n");
		663	}
		664	return conteudo.toString();
		665	}
		666
		667	private Double valorTotalVenda(List<Lancamento> lancamentos) {
		668	Double total = new Double(0.0);
		669	for (Lancamento lancamento : lancamentos) {
		670	if (lancamento.getAtivo()) {
		671	total = total + lancamento.getValorVenda();
		672	}
		673	}
		674	return total;
		675	}
		676
		677	private void atualizarDadosDaVenda(ParametrosVendaDTO parametrosVenda) {
		678	parametrosVenda.getVenda().setVendedor(parametrosVenda.getVendedor());
		679	parametrosVenda.getVenda().setIndicacao(parametrosVenda.getIndicacao());
		680	parametrosVenda.getVenda().setCliente(parametrosVenda.getCliente());
		681	parametrosVenda.getVenda().setObservacao(parametrosVenda.getObservacao());
		682	parametrosVenda.getVenda().setNotaFiscal(parametrosVenda.getNotaFiscal());
		683	parametrosVenda.getVenda().setMaquineta(parametrosVenda.getMaquineta());
		684	if (!parametrosVenda.getVenda().getLoja().equals(parametrosVenda.getLoja())) {
		685	for (Lancamento lancamento : parametrosVenda.getVenda().getLancamentos()) {
305	espaco	686	alterarEstoqueProduto(1, parametrosVenda.getVenda().getLoja(), lancamento.getProduto().getCodigo(), lancamento.getTipoPersonalizacao());
		687	alterarEstoqueProduto(-1, parametrosVenda.getLoja(), lancamento.getProduto().getCodigo(), lancamento.getTipoPersonalizacao());
149	espaco	688	}
		689	parametrosVenda.getVenda().setLoja(parametrosVenda.getLoja());
		690	parametrosVenda.getVenda().setMaquineta(parametrosVenda.getLoja().getMaquineta());
		691	}
		692	parametrosVenda.getVenda().setTipoSituacao(parametrosVenda.getTipoSituacao());
		693	parametrosVenda.getVenda().setDataVenda(parametrosVenda.getDataVenda());
		694	}
		695
		696	@Override
		697	public List<Venda> consultarVendasDoDia(Long sequencialLoja, Date dataVendas) {
		698	return vendaRepository.consultarVendasDoDia(sequencialLoja, dataVendas);
		699	}
		700
		701	@Override
		702	public Integer obterQuantidadeDeVendasPorLojaEePeriodo(Venda venda, Date dataInicial, Date dataFinal) {
		703	return vendaRepository.obterQuantidadeDeVendasPorLojaEePeriodo(venda, dataInicial, dataFinal);
		704	}
		705
		706	@Override
		707	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodo(Loja loja, Date dataInicial, Date dataFinal) {
		708	Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodo(loja, dataInicial, dataFinal);
689	blopes	709	valorTotal = valorTotal - vendaRepository.obterValorDeCuponsOuCashbackUtilizadosPorLojaEePeriodo(new ParametrosConsultaVendasDTO(loja, dataInicial, dataFinal));
149	espaco	710	return valorTotal;
		711	}
		712
		713	@Override
		714	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		715	Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsulta);
689	blopes	716	valorTotal = valorTotal - vendaRepository.obterValorDeCuponsOuCashbackUtilizadosPorLojaEePeriodo(parametrosConsulta);
149	espaco	717	return valorTotal;
		718	}
		719
		720	@Override
		721	public Double obterValorTotalDeDescontosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		722	return vendaRepository.obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsulta);
		723	}
		724
		725	@Override
		726	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodoEeFormasDePagamento(ParametrosConsultaVendasDTO parametrosConsultaVendas, List<FormaPagamento> formasDePagamento) {
		727	return vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodoEeFormasDePagamento(parametrosConsultaVendas, formasDePagamento);
		728	}
		729
		730	@Override
		731	public Double obterValorTotalLiquidoDeVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		732	return vendaRepository.obterValorTotalLiquidoDeVendasPorLojaEePeriodo(parametrosConsulta);
		733	}
		734
		735	@Override
		736	public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		737	return vendaRepository.obterQuantidadeProdutosVendidosPorLojaEePeriodo(parametrosConsultaVendas);
		738	}
		739
		740	@Override
		741	public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		742	return vendaRepository.obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(parametrosConsultaVendas);
		743	}
		744
		745	@Override
		746	public Integer obterQuantidadeProdutosVendidosPorEstiloEeGenero(Date dataInicial, Date dataFinal, Long sequencialLoja, Long sequencialModelo, String tipoProduto, String estiloProduto, String tipoGenero) {
		747	return vendaRepository.obterQuantidadeProdutosVendidosPorEstiloEeGenero(dataInicial, dataFinal, sequencialLoja, sequencialModelo, tipoProduto, estiloProduto, tipoGenero);
		748	}
		749
		750	@Override
		751	public Double obterValorProdutosUtilizadosEmVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		752	return vendaRepository.obterValorProdutosUtilizadosEmVendasPorLojaEePeriodo(parametrosConsulta);
		753	}
		754
		755	private void verificarLancamentos(List<Lancamento> lancamentos) {
		756	if (lancamentos.isEmpty()) {
		757	throw new NegocioException("Obrigatório informar ao menos um produto");
		758	}
		759	}
		760
		761	// TODO: EM DESENVOLVIMENTO
		762	/*
		763	private void lancarExcecaoCasoFreteContraditorio(ParametrosVendaDTO parametrosVenda) {
		764	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getTipoFrete())) {
		765	if (parametrosVenda.getTipoFrete().equals(ConstantesSEC.NotaFiscal.Transporte.SEM_OCORRENCIA_TRANSPORTE_9)
		766	&& parametrosVenda.getValorFrete() > 0.0) {
		767	throw new NegocioException("Não é possível informar o frete sem a ocorrência.");
		768	}
		769	if (parametrosVenda.getTipoFrete().equals(ConstantesSEC.NotaFiscal.Transporte.FRETE_POR_CONTA_REMETENTE_TRANSPORTE_PROPRIO_3)
		770	&& parametrosVenda.getValorFrete() == 0.0) {
		771	throw new NegocioException("É necessário informar o valor do frete.");
		772	}
		773
		774	}
		775	// CASO TENHA VALOR E: FRETE CIF, FRETE DE TERCEIROS, FRETE REMETENTE (TP) OU SEM OCORRÊNCIA
		776	// CASO NÃO TENHA VALOR E: FRETE FOB.
		777	}
		778	*/
		779
		780	private void lancarExcecaoCasoNaoSejaInformadoCamposObrigatorios(ParametrosVendaDTO parametrosVenda) {
		781	if (VerificadorUtil.isListaNulaOuVazia(parametrosVenda.getLancamentosPagamentos()) && VerificadorUtil.estaNuloOuVazio(parametrosVenda.getObservacao())) {
		782	throw new NegocioException("Obrigatório informar as observações em vendas sem pagamentos");
		783	}
		784	if (VerificadorUtil.estaNulo(parametrosVenda.getLoja())) {
		785	throw new NegocioException("Informe a loja");
		786	}
277	espaco	787	for (VendaFormaPagamento vendaFormaPagamento : parametrosVenda.getLancamentosPagamentos()) {
		788	if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCartao()) {
		789	if (VerificadorUtil.estaNulo(parametrosVenda.getMaquineta())) {
		790	throw new NegocioException("Informe a maquineta");
		791	}
		792	}
		793	}
305	espaco	794	if (possuiLancamentoPersonalizacao(parametrosVenda.getLancamentos())) {
		795	if (VerificadorUtil.estaNulo(parametrosVenda.getCliente()) && VerificadorUtil.estaNuloOuVazio(parametrosVenda.getObservacao())) {
		796	throw new NegocioException("Informe o cliente ou o contato do cliente nas observações");
		797	}
		798	}
		799	if (VerificadorUtil.estaNulo(parametrosVenda.getLoja())) {
		800	throw new NegocioException("Informe a loja");
		801	}
149	espaco	802	}
305	espaco	803
		804	private Boolean possuiLancamentoPersonalizacao(List<Lancamento> lancamentos) {
		805	for (Lancamento lancamento : lancamentos) {
		806	if (VerificadorUtil.naoEstaNuloOuVazio(lancamento.getTipoPersonalizacao())) {
		807	return true;
		808	}
		809	}
		810	return false;
		811	}
149	espaco	812
		813	private void lancarExcecaoSeValoresNaoSaoIguais(ParametrosVendaDTO parametrosVenda) {
		814	final double TOLERANCE = 0.01;
		815	if(Math.abs(parametrosVenda.valorTotalLancamentos() /+ parametrosVenda.getValorFrete() /- parametrosVenda.valorTotalPago()) > TOLERANCE) {
		816	throw new NegocioException("Valores pagos não corresponde ao valor vendido.");
		817	}
		818	}
		819
		820	private void cadastrarLancamentos(ParametrosVendaDTO parametrosVenda, Venda venda) {
		821	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		822	cadastrarLancamento(parametrosVenda.getLoja(), venda, lancamento);
		823	}
		824	}
		825
		826	private void alterarLancamentos(ParametrosVendaDTO parametrosVenda) {
		827	excluirLancamentosRetiradosDaLista(parametrosVenda, consultarLancamentosCadastrados(parametrosVenda));
		828	cadastrarNovosLancamentos(parametrosVenda);
		829	}
		830
		831	private void excluirLancamentosRetiradosDaLista(ParametrosVendaDTO parametrosVenda, List<Lancamento> lancamentosAntigos) {
		832	for (Lancamento lancamentoAntigo : lancamentosAntigos) {
		833	if (!parametrosVenda.getLancamentos().contains(lancamentoAntigo)) {
		834	lancamentoService.excluir(lancamentoAntigo);
305	espaco	835	alterarEstoqueProduto(1, parametrosVenda.getLoja(), lancamentoAntigo.getProduto().getCodigo(), lancamentoAntigo.getTipoPersonalizacao());
149	espaco	836	}
		837	}
		838	}
		839
		840	private void cadastrarNovosLancamentos(ParametrosVendaDTO parametrosVenda) {
		841	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		842	if (VerificadorUtil.estaNulo(lancamento.getSequencial())) {
		843	cadastrarLancamento(parametrosVenda.getLoja(), parametrosVenda.getVenda(), lancamento);
		844	}
		845	}
		846	}
		847
		848	private List<Lancamento> consultarLancamentosCadastrados(ParametrosVendaDTO parametrosVenda) {
		849	Lancamento lancamentoDaVenda = new Lancamento();
		850	lancamentoDaVenda.setVenda(parametrosVenda.getVenda());
		851	return lancamentoService.consultarPassandoEntidade(lancamentoDaVenda, 0, lancamentoService.obterQuantidadeDeRegistrosPassandoEntidade(lancamentoDaVenda));
		852	}
		853
		854	private void cadastrarLancamento(Loja loja, Venda venda, Lancamento lancamento) {
		855	lancamento.setVenda(venda);
		856	igualarValorVarejoComCompraSeProdutoForPadrao(lancamento);
		857	acrescentarValorIPISeHouver(lancamento);
		858	lancamentoService.cadastrar(lancamento);
305	espaco	859	alterarEstoqueProduto(-1, loja, lancamento.getProduto().getCodigo(), lancamento.getTipoPersonalizacao());
149	espaco	860	utilizarCupom(lancamento.getCupom());
		861
		862	}
		863
		864	private void igualarValorVarejoComCompraSeProdutoForPadrao(Lancamento lancamento) {
		865	if (VerificadorUtil.naoEstaNulo(lancamento.getProduto())) {
		866	if (lancamento.getProduto().getCodigo().equals(ConstantesSEC.CODIGO_PRODUTO_PADRAO_000000)) {
		867	lancamento.setValorVarejo(lancamento.getValorVenda());
		868	}
		869	}
		870	}
		871
		872	private void acrescentarValorIPISeHouver(Lancamento lancamento) {
		873	if (VerificadorUtil.naoEstaNulo(lancamento.getProduto())) {
212	espaco	874	lancamento.setValorCompra(lancamento.getProduto().getValorCompra());
		875	// lancamento.setValorCompra(lancamento.getProduto().calculoOperacao());
149	espaco	876	}
		877	}
		878
		879	private void cadastrarPagamentos(ParametrosVendaDTO parametrosVenda, Venda venda) {
		880	for (VendaFormaPagamento vendaFormaPagamento : parametrosVenda.getLancamentosPagamentos()) {
		881	adicionarMaquineta(vendaFormaPagamento, parametrosVenda, venda);
		882	vendaFormaPagamento.setVenda(venda);
		883	vendaFormaPagamentoService.cadastrar(vendaFormaPagamento);
		884	utilizarCupom(vendaFormaPagamento.getCupom());
		885	}
		886	}
635	blopes	887
149	espaco	888	private void adicionarMaquineta(VendaFormaPagamento vendaFormaPagamento, ParametrosVendaDTO parametrosVenda, Venda venda) {
		889	if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCartao()) {
		890	if (VerificadorUtil.estaNulo(parametrosVenda.getMaquineta())) {
		891	parametrosVenda.setMaquineta(parametrosVenda.getLoja().getMaquineta());
		892	}
		893	venda.setMaquineta(parametrosVenda.getMaquineta());
		894	}
		895	}
		896
635	blopes	897	private void cadastrarPosVenda(Venda venda) {
		898	posVendaService.iniciarPosVenda(venda);
		899	}
		900
686	blopes	901	private void atualizarCashback(ParametrosVendaDTO parametrosVenda, Venda venda) {
		902	// RETIRAR DO SALDO O CASHBACK
689	blopes	903	Double valorCashback = 0.0;
		904	for (VendaFormaPagamento vendaFormaPagamento : parametrosVenda.getLancamentosPagamentos()) {
		905	if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCashback()) {
		906	valorCashback += vendaFormaPagamento.getValorPagamento();
		907	}
		908	}
		909	if (valorCashback > 0.0) {
		910	cashbackService.utilizarCashback(venda, valorCashback);
		911	} else {
		912	// GERAR SE NÃO HOUVER UTILIZAÇÃO DO CASHBACK
		913	cashbackService.gerarCashback(parametrosVenda, venda);
		914	}
686	blopes	915
685	blopes	916	}
		917
149	espaco	918	private void alterarPagamentos(ParametrosVendaDTO parametrosVenda) {
		919	excluirPagamentosRetiradosDaLista(parametrosVenda, consultarPagamentosCadastrados(parametrosVenda));
		920	cadastrarNovosPagamentos(parametrosVenda);
		921	}
		922
		923	private void excluirPagamentosRetiradosDaLista(ParametrosVendaDTO parametrosVenda, List<VendaFormaPagamento> pagamentosAntigos) {
		924	for (VendaFormaPagamento pagamentoAntigo : pagamentosAntigos) {
		925	if (!parametrosVenda.getLancamentosPagamentos().contains(pagamentoAntigo)) {
		926	vendaFormaPagamentoService.excluir(pagamentoAntigo);
		927	}
		928	// if (verificarSePagamentoFoiRetiradoDaLista(parametrosVenda.getLancamentosPagamentos(), pagamentoAntigo)) {
		929	// vendaFormaPagamentoService.excluirPorId(pagamentoAntigo);
		930	// }
		931	}
		932	}
		933
		934	private boolean verificarSePagamentoFoiRetiradoDaLista(List<VendaFormaPagamento> pagamentos, VendaFormaPagamento pagamentoAntigo) {
		935	boolean pagamentoRetirado = true;
		936	for (VendaFormaPagamento pagamento : pagamentos) {
		937	if (pagamento.getCodigoDaFormaPagamento().equals(pagamentoAntigo.getCodigoDaFormaPagamento())) {
		938	if (verificarSeBandeiraCartaoEhIgual(pagamento.getCodigoDaBandeiraCartao(), pagamentoAntigo.getCodigoDaBandeiraCartao()) &&
		939	pagamento.getValorPagamento().equals(pagamentoAntigo.getValorPagamento())) {
		940	return false;
		941	} else {
		942	pagamento.setVenda(pagamentoAntigo.getVenda());
		943	vendaFormaPagamentoService.alterar(pagamento);
		944	return false;
		945	}
		946	}
		947	}
		948	return pagamentoRetirado;
		949	}
		950
		951	private boolean verificarSeBandeiraCartaoEhIgual(Long codigoDaBandeiraCartao, Long codigoDaBandeiraCartaoSegundo) {
		952	if (VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartao) && VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartaoSegundo)) {
		953	return codigoDaBandeiraCartao.equals(codigoDaBandeiraCartaoSegundo);
		954	}
		955	if ((VerificadorUtil.estaNulo(codigoDaBandeiraCartao) && VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartaoSegundo)) \|\|
		956	(VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartao) && VerificadorUtil.estaNulo(codigoDaBandeiraCartaoSegundo))) {
		957	return false;
		958	}
		959	return true;
		960	}
		961
		962	private void cadastrarNovosPagamentos(ParametrosVendaDTO parametrosVenda) {
		963	for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
		964	if (VerificadorUtil.estaNulo(pagamento.getSequencial())) {
		965	adicionarMaquineta(pagamento, parametrosVenda, parametrosVenda.getVenda());
		966	pagamento.setVenda(parametrosVenda.getVenda());
		967	vendaFormaPagamentoService.cadastrar(pagamento);
		968	utilizarCupom(pagamento.getCupom());
		969	}
		970	}
		971	}
		972
		973	private List<VendaFormaPagamento> consultarPagamentosCadastrados(ParametrosVendaDTO parametrosVenda) {
		974	VendaFormaPagamento pagamentoDaVenda = new VendaFormaPagamento();
		975	pagamentoDaVenda.setVenda(parametrosVenda.getVenda());
		976	return vendaFormaPagamentoService.consultarPassandoEntidade(pagamentoDaVenda, 0, vendaFormaPagamentoService.obterQuantidadeDeRegistrosPassandoEntidade(pagamentoDaVenda));
		977	}
		978
305	espaco	979	private void alterarEstoqueProduto(Integer quantidadeAlterar, Loja loja, String codigoProduto, String tipoPersonalizacao) {
149	espaco	980	if (VerificadorUtil.naoEstaNulo(codigoProduto)) {
		981	Produto produto = produtoService.consultarProdutoPorCodigo(codigoProduto);
305	espaco	982	Loja lojaAlterarEstoque = retornarLojaParaAlteracaoEstoque(loja, tipoPersonalizacao);
		983	produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(quantidadeAlterar, produto, lojaAlterarEstoque);
149	espaco	984	}
		985	}
		986
305	espaco	987	private Loja retornarLojaParaAlteracaoEstoque(Loja loja, String tipoPersonalizacao) {
		988	if (VerificadorUtil.naoEstaNulo(tipoPersonalizacao)) {
		989	return new Loja(ConstantesSEC.Personalizacao.SEQUENCIAL_LOJA_PERSONALIZACAO);
		990	}
		991	return loja;
		992	}
		993
149	espaco	994	private void utilizarCupom(Cupom cupom) {
		995	if (VerificadorUtil.naoEstaNulo(cupom)) {
		996	Cupom cupomUtilizado = cupomService.consultarPorId(cupom);
		997	cupomUtilizado.setDataHoraUtilizado(DataUtils.getDataAtual());
		998	if (VerificadorUtil.estaNulo(cupomUtilizado.getQuantidadeUtilizada())) {
		999	cupomUtilizado.setQuantidadeUtilizada(0);
		1000	}
		1001	cupomUtilizado.setQuantidadeUtilizada(cupomUtilizado.getQuantidadeUtilizada() + 1);
		1002	cupomService.alterar(cupomUtilizado);
		1003	}
		1004	}
		1005
		1006	@Override
		1007	public List<Venda> consultarVendasPorDemanda(ParametrosConsulta<Venda> parametrosConsulta, Integer primeiroRegistro,
		1008	Integer tamanhoPagina, String sortField, String orderSort, Map<String, Object> filters) {
		1009	return vendaRepository.consultarVendasPorDemanda(parametrosConsulta, primeiroRegistro, tamanhoPagina, sortField, orderSort, filters);
		1010	}
		1011
		1012	@Override
		1013	public List<Venda> consultarVendaPorParametros(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1014	return vendaRepository.consultarVendaPorParametros(parametrosConsultaVendas);
		1015	}
		1016
		1017	@Override
		1018	public GraficoAcumuladoDTO consultarGrafico(String mes, String ano) {
		1019	return vendaRepository.consultarGrafico(mes, ano);
		1020	}
		1021
		1022	@Override
		1023	public List<RankingVendedorDTO> consultarRankingVendedores(Date dataInicial, Date dataFinal, Boolean produtosComissionados, Loja lojaSelecionada) {
		1024	List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
		1025	List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradoresAtivos(lojaSelecionada);
		1026	for (Vendedor vendedor : vendedores) {
		1027	RankingVendedorDTO vendedorConsultado = consultarRankingVendedor(vendedor, dataInicial, dataFinal, produtosComissionados);
		1028	rankingVendedores.add(vendedorConsultado);
		1029	}
		1030	return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
		1031	}
		1032
		1033	@Override
		1034	public RankingVendedorDTO consultarRankingVendedor(Vendedor vendedor, Vigencia vigencia, Boolean produtosComissionados) {
		1035	Avaliacao avaliacao = avaliacaoService.consultarAvaliacaoDaVigencia(vigencia);
		1036	RankingVendedorDTO rankingVendedor = consultarRankingVendedor(vendedor, vigencia.getDataInicio(), vigencia.getDataFim(), produtosComissionados);
		1037	rankingVendedor.setFuncionario(funcionarioService.consultarFuncionarioPorPessoa(vendedor.getPessoa()));
		1038	rankingVendedor.setQuantidadeBancoHoras(bancoHorasService.consultarQuantidadeHoras(rankingVendedor.getFuncionario()));
		1039	AvaliacaoFuncionario avaliacaoFuncionario = avaliacaoFuncionarioService.detalhar(vendedor.getPessoa(), avaliacao);
		1040	if (VerificadorUtil.naoEstaNuloOuVazio(avaliacaoFuncionario)) {
		1041	rankingVendedor.setAvaliacaoFuncionario(avaliacaoFuncionario);
337	espaco	1042	rankingVendedor.setPontuacaoGeral(avaliacaoFuncionario.getPontuacao());
149	espaco	1043	if (VerificadorUtil.naoEstaNulo(avaliacaoFuncionario.getPorcentagemComissao())) {
		1044	rankingVendedor.setComissao(calcularComissao(rankingVendedor.getValorTotalVendido(), avaliacaoFuncionario.getPorcentagemComissao()/100));
		1045	} else {
		1046	rankingVendedor.setComissao(calcularComissao(rankingVendedor.getValorTotalVendido(), avaliacaoFuncionario.retornarFaixaComissao(rankingVendedor.getValorTotalVendido(), rankingVendedor.getFuncionario().getTipoComissionamento())));
		1047	}
		1048	}
		1049	return rankingVendedor;
		1050	}
		1051
		1052	public Double calcularComissao(Double valorTotalVendido, Double porcentagemComissao) {
		1053	if (VerificadorUtil.naoEstaNuloOuVazio(porcentagemComissao)) {
		1054	return valorTotalVendido * porcentagemComissao;
		1055	}
		1056	return 0.0;
		1057	}
		1058
		1059	@Override
		1060	public RankingVendedorDTO consultarRankingVendedor(Vendedor vendedor, Date dataInicial, Date dataFinal, Boolean produtosComissionados) {
		1061	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1062	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1063	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1064	parametrosConsultaVendas.setVendedor(vendedor);
		1065	if (VerificadorUtil.naoEstaNulo(produtosComissionados)) {
		1066	parametrosConsultaVendas.setIndicadorComissionado(produtosComissionados);
		1067	}
		1068
		1069	RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
		1070	rankingVendedor.setVendedor(vendedor);
		1071	try {
		1072	rankingVendedor.setFuncionario(funcionarioService.consultarFuncionarioPorPessoa(vendedor.getPessoa()));
		1073	rankingVendedor.setQuantidadeBancoHoras(bancoHorasService.consultarQuantidadeHoras(rankingVendedor.getFuncionario()));
		1074	} catch (RuntimeException e) {
		1075	rankingVendedor.setFuncionario(null);
		1076	}
		1077
		1078	rankingVendedor.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas));
		1079	rankingVendedor.setValorTotalDescontos(obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsultaVendas));
		1080	rankingVendedor.setQuantidadeTotalProdutosVendidos(obterQuantidadeProdutosVendidosPorLojaEePeriodo(parametrosConsultaVendas));
		1081
		1082	Venda venda = new Venda();
		1083	venda.setVendedor(vendedor);
		1084	rankingVendedor.setQuantidadeVendas(obterQuantidadeDeVendasPorLojaEePeriodo(venda, dataInicial, dataFinal));
		1085	rankingVendedor.setQuantidadePedidos(obterQuantidadePedidosValidos(vendedor, null, dataInicial, dataFinal));
		1086	rankingVendedor.setQuantidadePedidosInvalidos(obterQuantidadePedidos(vendedor, null, dataInicial, dataFinal, TipoSituacaoPedido.INVALIDO.getValor()));
		1087	rankingVendedor.setQuantidadeContagens(obterQuantidadeDeContagens(vendedor, dataInicial, dataFinal));
		1088	rankingVendedor.setQuantidadeAtendimentos(obterQuantidadeDeAtendimentos(vendedor, dataInicial, dataFinal));
		1089	rankingVendedor.setValorTotalVendidoVivo(obterValorTotalBrutoDeVendasVivoPorLojaEePeriodo(parametrosConsultaVendas));
		1090
		1091	rankingVendedor.setAvaliacaoFuncionario(avaliacaoFuncionarioService.consultarAvaliacaoFuncionarioPelaData(vendedor, DataUtils.getDataComHorarioMinimo(dataFinal)));
		1092	if (VerificadorUtil.naoEstaNulo(rankingVendedor.getAvaliacaoFuncionario())) {
		1093	rankingVendedor.setPercentualDescontos(rankingVendedor.getAvaliacaoFuncionario().retornarPercentual(rankingVendedor.getValorTotalDescontos(), rankingVendedor.getValorTotalVendido()));
		1094	rankingVendedor.setPercentualMetaMensal(rankingVendedor.getAvaliacaoFuncionario().retornarPercentualRealizado(rankingVendedor.getValorTotalVendido()));
		1095	rankingVendedor.setPercentualMetaMensalVivo(rankingVendedor.getAvaliacaoFuncionario().retornarPercentualVivoRealizado(rankingVendedor.getValorTotalVendidoVivo()));
333	espaco	1096	rankingVendedor.setPercentualMetaTicketMedio(rankingVendedor.getAvaliacaoFuncionario().retornarPercentualTicketMedioRealizado(rankingVendedor.getTicketMedio()));
149	espaco	1097	}
		1098
		1099	ParametrosConsultaVendasDTO parametrosConsultaVendasDoDia = new ParametrosConsultaVendasDTO();
		1100	parametrosConsultaVendasDoDia.setDataInicial(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()));
		1101	parametrosConsultaVendasDoDia.setDataFinal(DataUtils.getDataComHorarioMaximo(DataUtils.getDataAtual()));
		1102	parametrosConsultaVendasDoDia.setVendedor(vendedor);
		1103	if (VerificadorUtil.naoEstaNulo(produtosComissionados)) {
		1104	parametrosConsultaVendasDoDia.setIndicadorComissionado(produtosComissionados);
		1105	}
		1106	rankingVendedor.setValorTotalVendidoDoDia(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendasDoDia));
		1107
		1108	return rankingVendedor;
		1109	}
		1110
		1111	private Integer obterQuantidadePedidos(Vendedor vendedor, Loja loja, Date dataInicial, Date dataFinal, String tipoSituacao) {
		1112	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1113	if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
		1114	return 0;
		1115	}
		1116	}
		1117	ParametrosConsultaPedidoDTO parametrosPedidos = new ParametrosConsultaPedidoDTO();
		1118	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1119	parametrosPedidos.setPessoa(vendedor.getPessoa());
		1120	}
		1121	parametrosPedidos.setEntidade(new Pedido());
		1122	parametrosPedidos.getEntidade().setTipoSituacao(tipoSituacao);
		1123	parametrosPedidos.getEntidade().setLoja(loja);
		1124	parametrosPedidos.setDataInicial(dataInicial);
		1125	parametrosPedidos.setDataFinal(dataFinal);
		1126	return pedidoService.obterQuantidadeDeRegistrosParametrosConsulta(parametrosPedidos);
		1127	}
		1128
		1129	private Integer obterQuantidadePedidosValidos(Vendedor vendedor, Loja loja, Date dataInicial, Date dataFinal) {
		1130	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1131	if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
		1132	return 0;
		1133	}
		1134	}
		1135	ParametrosConsultaPedidoDTO parametrosPedidos = new ParametrosConsultaPedidoDTO();
		1136	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1137	parametrosPedidos.setPessoa(vendedor.getPessoa());
		1138	}
		1139	parametrosPedidos.setEntidade(new Pedido());
		1140	parametrosPedidos.getEntidade().setLoja(loja);
		1141	parametrosPedidos.setDataInicial(dataInicial);
		1142	parametrosPedidos.setDataFinal(dataFinal);
		1143	parametrosPedidos.setValidos(true);
		1144	return pedidoService.obterQuantidadeDeRegistrosParametrosConsulta(parametrosPedidos);
		1145	}
		1146
		1147	private Integer obterQuantidadeDeContagens(Vendedor vendedor, Date dataInicial, Date dataFinal) {
		1148	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1149	if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
		1150	return 0;
		1151	}
		1152	}
		1153	return produtoLojaService.obterQuantidadeDeContagens(vendedor.getPessoa(), dataInicial, dataFinal);
		1154	}
		1155
		1156	private Integer obterQuantidadeDeAtendimentos(Vendedor vendedor, Date dataInicial, Date dataFinal) {
		1157	if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
		1158	return 0;
		1159	}
		1160	return produtoLojaService.obterQuantidadeDeAtendimentos(vendedor.getPessoa(), dataInicial, dataFinal);
		1161	}
		1162
		1163	private Integer obterQuantidadeDeAtendimentos(Loja loja, Date dataInicial, Date dataFinal) {
		1164	return produtoLojaService.obterQuantidadeDeAtendimentos(loja, dataInicial, dataFinal);
		1165	}
		1166
		1167	private Double obterValorTotalBrutoDeVendasVivoPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1168	ParametrosConsultaVendasVivoDTO parametrosConsultaVendasVivo = new ParametrosConsultaVendasVivoDTO();
		1169	parametrosConsultaVendasVivo.setVendedor(parametrosConsultaVendas.getVendedor());
		1170	parametrosConsultaVendasVivo.setDataInicial(parametrosConsultaVendas.getDataInicial());
		1171	parametrosConsultaVendasVivo.setDataFinal(parametrosConsultaVendas.getDataFinal());
		1172	return vendaVivoService.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendasVivo);
		1173	}
		1174
		1175	@Override
		1176	public List<RankingLojaDTO> consultarRankingLojas(Date dataInicial, Date dataFinal) {
		1177	List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
		1178	List<Loja> lojas = lojaService.listarLojasAtivas();
		1179	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1180	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1181	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1182	for (Loja loja : lojas) {
		1183	if (!loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)
		1184	&& !loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_RESTAURANTE_16)) {
		1185	parametrosConsultaVendas.setLoja(loja);
		1186
		1187	RankingLojaDTO rankingLoja = new RankingLojaDTO();
		1188	rankingLoja.setLoja(loja);
		1189	rankingLoja.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas)
		1190	- obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
		1191	rankingLoja.setAvaliacaoLoja(avaliacaoLojaService.consultarAvaliacaoLojaPelaData(loja, DataUtils.getDataComHorarioMinimo(dataFinal)));
		1192	if (VerificadorUtil.naoEstaNulo(rankingLoja.getAvaliacaoLoja())) {
		1193	rankingLoja.setValorMetaMensal(rankingLoja.getAvaliacaoLoja().getValorMetaMensal());
		1194	}
		1195	rankingLojas.add(rankingLoja);
		1196	}
		1197	}
		1198	return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojas);
		1199	}
		1200
		1201	@Override
		1202	public List<RankingLojaDTO> consultarRankingLojasCompleto(Date dataInicial, Date dataFinal) {
		1203	List<RankingLojaDTO> rankingLojasCompleto = new ArrayList<RankingLojaDTO>();
		1204	List<RankingLojaDTO> rankingLojas = consultarRankingLojas(dataInicial, dataFinal);
		1205	for (RankingLojaDTO rankingLoja : rankingLojas) {
		1206	rankingLoja.setQuantidadeVendas(obterQuantidadeDeVendasPorLojaEePeriodo(new Venda(rankingLoja.getLoja(), null), dataInicial, dataFinal));
		1207	rankingLoja.setQuantidadeAtendimentos(obterQuantidadeDeAtendimentos(rankingLoja.getLoja(), dataInicial, dataFinal));
		1208	rankingLoja.setQuantidadePedidos(obterQuantidadePedidosValidos(null, rankingLoja.getLoja(), dataInicial, dataFinal));
		1209	rankingLoja.setQuantidadePedidosInvalidos(obterQuantidadePedidos(null, rankingLoja.getLoja(), dataInicial, dataFinal, TipoSituacaoPedido.INVALIDO.getValor()));
		1210
		1211	ParametrosConsultaPorPeriodoDTO parametrosConsulta = new ParametrosConsultaPorPeriodoDTO();
		1212	((ParametrosConsultaPorPeriodoDTO)parametrosConsulta).setDataInicial(dataInicial);
		1213	((ParametrosConsultaPorPeriodoDTO)parametrosConsulta).setDataFinal(dataFinal);
		1214	EstoqueAuditoria estoqueAuditoria = new EstoqueAuditoria();
		1215	estoqueAuditoria.setLoja(rankingLoja.getLoja());
		1216	estoqueAuditoria.setTipoEstoqueAuditoria(TipoEstoqueAuditoria.AVARIA.getValor());
		1217	parametrosConsulta.setEntidade(estoqueAuditoria);
		1218	rankingLoja.setQuantidadeAvarias(estoqueAuditoriaService.obterQuantidadeTotalAuditoria(parametrosConsulta));
		1219
		1220	estoqueAuditoria.setTipoEstoqueAuditoria(TipoEstoqueAuditoria.TROCA.getValor());
		1221	parametrosConsulta.setEntidade(estoqueAuditoria);
		1222	rankingLoja.setQuantidadeTrocas(estoqueAuditoriaService.obterQuantidadeTotalAuditoria(parametrosConsulta));
		1223
		1224	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1225	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1226	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1227	parametrosConsultaVendas.setLoja(rankingLoja.getLoja());
		1228	rankingLoja.setValorTotalDescontos(obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsultaVendas));
		1229	rankingLoja.setCustoProdutosVendidos(obterValorProdutosUtilizadosEmVendasPorLojaEePeriodo(parametrosConsultaVendas));
		1230	rankingLoja.setValorTotalEstoque(produtoService.valorTotalEstoque(rankingLoja.getLoja(), null));
		1231	rankingLoja.setQuantidadeTotalEstoque(produtoService.quantidadeTotalEstoque(rankingLoja.getLoja()));
		1232
		1233	ParametrosConsultaLancamentosDTO parametros = new ParametrosConsultaLancamentosDTO();
		1234	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_ALUGUEL_11));
		1235	parametros.setCentroDeCustos(rankingLoja.getLoja());
		1236	parametros.setPagamentoRealizado(true);
		1237	parametros.setDataInicial(dataInicial);
		1238	parametros.setDataFinal(dataFinal);
		1239	Double valorCac = 0.0;
		1240
		1241	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1242	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_HORA_EXTRA_2));
		1243	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1244	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_SALARIO_9));
		1245	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1246	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_FERIAS_12));
		1247	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1248	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_COMISSOES_8));
		1249	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1250	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_VALE_TRANSPORTE_46));
		1251	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1252	valorCac = valorCac / rankingLoja.getQuantidadeVendas();
		1253	rankingLoja.setValorCac(valorCac);
		1254
		1255	rankingLojasCompleto.add(rankingLoja);
		1256	}
		1257	return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojasCompleto);
		1258	}
		1259
		1260	private Double somarValor(Double valor, Double valorAcrescentar) {
		1261	if (VerificadorUtil.naoEstaNulo(valorAcrescentar)) {
		1262	return valor + valorAcrescentar;
		1263	}
		1264	return valor;
		1265	}
		1266
		1267	@Override
		1268	public List<RankingLojaDTO> consultarRankingLojasExtras(Date dataInicial, Date dataFinal) {
		1269	List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
164	espaco	1270
149	espaco	1271	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1272	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1273	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
164	espaco	1274	// rankingLojas.addAll(preenchendoLojasExtras(parametrosConsultaVendas));
		1275
		1276	parametrosConsultaVendas.setLoja(null);
		1277	// rankingLojas.add(preencherLojaAssistencia(parametrosConsultaVendas));
		1278
		1279	return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojas);
		1280	}
		1281
		1282	private RankingLojaDTO preencherLojaAssistencia(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1283	RankingLojaDTO rankingLojaServico = new RankingLojaDTO();
		1284	Loja lojaServico = new Loja();
		1285	lojaServico.setDescricao("ASSISTÊNCIA");
		1286	rankingLojaServico.setValorMetaMensal(new Double(0.0));
		1287	rankingLojaServico.setLoja(lojaServico);
		1288	rankingLojaServico.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
		1289	return rankingLojaServico;
		1290	}
		1291
		1292	private RankingLojaDTO preencherVendasComPedidos(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1293	RankingLojaDTO rankingLojaServico = new RankingLojaDTO();
		1294	Loja lojaServico = new Loja();
		1295	lojaServico.setDescricao("E-COMMERCE");
		1296	rankingLojaServico.setValorMetaMensal(new Double(0.0));
		1297	rankingLojaServico.setLoja(lojaServico);
		1298	rankingLojaServico.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
		1299	return rankingLojaServico;
		1300	}
		1301
		1302	private List<RankingLojaDTO> preenchendoLojasExtras(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1303	List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
		1304	List<Loja> lojas = lojaService.listarLojasAtivas();
149	espaco	1305	for (Loja loja : lojas) {
		1306	if (loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)
		1307	\|\| loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_RESTAURANTE_16)) {
		1308	parametrosConsultaVendas.setLoja(loja);
		1309
		1310	RankingLojaDTO rankingLoja = new RankingLojaDTO();
		1311	rankingLoja.setLoja(loja);
		1312	rankingLoja.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas)
		1313	- obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
164	espaco	1314	rankingLoja.setAvaliacaoLoja(avaliacaoLojaService.consultarAvaliacaoLojaPelaData(loja, DataUtils.getDataComHorarioMinimo(parametrosConsultaVendas.getDataFinal())));
149	espaco	1315	if (VerificadorUtil.naoEstaNulo(rankingLoja.getAvaliacaoLoja())) {
		1316	rankingLoja.setValorMetaMensal(rankingLoja.getAvaliacaoLoja().getValorMetaMensal());
		1317	}
		1318	rankingLojas.add(rankingLoja);
		1319	}
		1320	}
164	espaco	1321	return rankingLojas;
149	espaco	1322	}
		1323
		1324	@Override
		1325	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1326	parametrosConsultaVendas.setTipoProduto(TipoProduto.SERVICO.getValor());
		1327	Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas);
		1328	parametrosConsultaVendas.setTipoProduto(null);
		1329	return VerificadorUtil.estaNulo(valorTotal)? new Double(0.0) : valorTotal;
		1330	}
		1331
		1332	@Override
		1333	public List<RankingProdutoDTO> consultarProdutosVendidos(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1334	List<RankingProdutoDTO> produtosVendidosConsultados = vendaRepository.consultarProdutosVendidos(parametrosConsulta);
		1335	for (RankingProdutoDTO produtoVendido : produtosVendidosConsultados) {
		1336	produtoVendido.atualizarTempoEstoque(parametrosConsulta.getDataInicial(), parametrosConsulta.getDataFinal());
		1337	}
		1338	return produtosVendidosConsultados;
		1339	}
		1340
		1341	@Override
		1342	public List<RankingProdutoDTO> consultarProdutosVendidosResumido(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1343	return vendaRepository.consultarProdutosVendidosResumido(parametrosConsulta);
		1344	}
		1345
		1346	@Override
		1347	public List<RankingProdutoDTO> consultarProdutosParaTransferir(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1348	return vendaRepository.consultarProdutosParaTransferir(parametrosConsulta);
		1349	}
		1350
		1351	@Override
		1352	public List<RankingProdutoDTO> consultarRankingProdutos(Date dataInicial, Date dataFinal, Integer quantidadeProdutos, String tipoOrdenacao, Long sequencialLoja, String tipoProduto, Produto produto, Marca marca) {
		1353	return vendaRepository.consultarProdutosMaisVendidos(dataInicial, dataFinal, quantidadeProdutos, tipoOrdenacao, sequencialLoja, tipoProduto, produto, marca);
		1354	}
		1355
		1356	@Override
		1357	public List<RankingModeloDTO> consultarRankingModelos(ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta) {
		1358	return vendaRepository.consultarModelosMaisVendidos(parametrosConsulta);
		1359	}
		1360
		1361	@Override
		1362	public List<RankingModeloDTO> consultarRankingModelos(Date dataInicial, Date dataFinal, Integer quantidadeModelos, String tipoOrdenacao, String tipoProduto, Long sequencialLoja) {
151	espaco	1363	ParametrosConsultaModelosMaisVendidosDTO parametros = new ParametrosConsultaModelosMaisVendidosDTO(dataInicial, dataFinal, quantidadeModelos, tipoOrdenacao, tipoProduto, sequencialLoja);
		1364	return this.consultarRankingModelos(parametros);
149	espaco	1365	}
		1366
		1367	@Override
		1368	public List<RankingComprasTransferenciasDTO> consultarPlanejamentoParaCompras(ParametrosConsultaParaComprasTransferenciasDTO parametrosParaConsulta) {
		1369	Integer limite = parametrosParaConsulta.getQuantidadeModelos();
		1370	if (parametrosParaConsulta.getIndicadorConsultarTodosModelos()) {
		1371	limite = null;
		1372	}
		1373	List<RankingComprasTransferenciasDTO> planejamentos = new ArrayList<RankingComprasTransferenciasDTO>();
		1374	ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta = new ParametrosConsultaModelosMaisVendidosDTO(parametrosParaConsulta.getDataInicial(), parametrosParaConsulta.getDataFinal(), limite,
		1375	parametrosParaConsulta.getTipoOrdenacao(), parametrosParaConsulta.getTipoProduto(), parametrosParaConsulta.getSequencialLoja(), parametrosParaConsulta.getModelo(), parametrosParaConsulta.getEstilo());
		1376	List<RankingModeloDTO> modelos = vendaRepository.consultarModelosMaisVendidos(parametrosConsulta);
		1377	for (RankingModeloDTO modelo : modelos) {
		1378	RankingComprasTransferenciasDTO planejamento = new RankingComprasTransferenciasDTO();
		1379	planejamento.setModelo(modelo.getModelo());
		1380	planejamento.setValorTotalVendido(modelo.getValorTotalVendido());
		1381	planejamento.setValorTotalComprado(modelo.getValorTotalComprado());
		1382	planejamento.setQuantidadeVendas(modelo.getQuantidadeVendas());
		1383	planejamento.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
		1384	if (VerificadorUtil.naoEstaNuloOuVazio(modelo.getQuantidadeEstoqueLocal())) {
		1385	planejamento.setQuantidadeEstoqueLocal(modelo.getQuantidadeEstoqueLocal().intValue());
		1386	}
		1387	planejamento.setQuantidadeEstoqueGeral(modelo.getQuantidadeEstoqueGeral().intValue());
		1388	planejamentos.add(planejamento);
		1389	}
		1390
		1391	if (parametrosParaConsulta.getIndicadorConsultarTodosModelos()) {
		1392	List<Modelo> modelosAtivos = new ArrayList<Modelo>();
		1393	if (VerificadorUtil.estaNulo(parametrosParaConsulta.getModelo())) {
		1394	modelosAtivos = modeloService.consultarTodosAtivos();
		1395	} else {
		1396	modelosAtivos = modeloService.consultarPassandoEntidade(parametrosParaConsulta.getModelo(), 0, modeloService.obterQuantidadeDeRegistrosPassandoEntidade(parametrosParaConsulta.getModelo()));
		1397	}
		1398	for (Modelo modeloAtivo : modelosAtivos) {
		1399	if (modeloNaoEstaPresenteNaLista(modelos, modeloAtivo)) {
		1400	RankingComprasTransferenciasDTO planejamento = new RankingComprasTransferenciasDTO();
		1401	planejamento.setModelo(modeloAtivo);
		1402	planejamento.setValorTotalVendido(new Double(0.0));
		1403	planejamento.setValorTotalComprado(new Double(0.0));
		1404	planejamento.setQuantidadeVendas(new Long(0));
		1405	planejamento.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
		1406	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosParaConsulta.getSequencialLoja())) {
		1407	planejamento.setQuantidadeEstoqueLocal(produtoLojaService.consultarEstoqueModeloEeLoja(modeloAtivo, parametrosParaConsulta.getSequencialLoja(), null, parametrosParaConsulta.getTipoProduto(), null, null));
		1408	}
		1409	planejamento.setQuantidadeEstoqueGeral(produtoLojaService.consultarEstoqueModeloEeLoja(modeloAtivo, null, null, parametrosParaConsulta.getTipoProduto(), null, null));
		1410	if (planejamento.getQuantidadeEstoqueGeral() > 0) {
		1411	planejamentos.add(planejamento);
		1412	}
		1413	}
		1414	}
		1415	}
		1416
		1417	if (parametrosParaConsulta.getTipoOrdenacao().equals(TipoOrdenacaoPlanejamentoCompras.QUANTIDADE_COMPRAR.getValor())) {
		1418	return new ArrayList<RankingComprasTransferenciasDTO>(ordenador.ordenar(planejamentos));
		1419	}
		1420	return planejamentos;
		1421	}
		1422
		1423	private Boolean modeloNaoEstaPresenteNaLista(List<RankingModeloDTO> rankingModelos, Modelo modeloAtivo) {
		1424	for (RankingModeloDTO rankingModelo : rankingModelos) {
		1425	if (rankingModelo.getModelo().getSequencial().equals(modeloAtivo.getSequencial())) {
		1426	return false;
		1427	}
		1428	}
		1429	return true;
		1430	}
		1431
		1432	@Override
		1433	public List<RankingComprasTransferenciasEstiloDTO> consultarDetalhamentoPlanejamentoParaCompras(ParametrosConsultaParaComprasTransferenciasDTO parametrosParaConsulta, Modelo modelo) {
600	blopes	1434	List<RankingComprasTransferenciasEstiloDTO> consulta = new ArrayList<RankingComprasTransferenciasEstiloDTO>();
149	espaco	1435	for (TipoEstiloProduto estiloProduto : TipoEstiloProduto.values()) {
		1436	parametrosParaConsulta.setEstilo(StringUtil.setarUpperCase(estiloProduto.getValor()));
602	blopes	1437	parametrosParaConsulta.setSubtipo(null);
149	espaco	1438	RankingComprasTransferenciasEstiloDTO estilo = vendaRepository.consultarEstoqueEeVendasPorEstilo(parametrosParaConsulta, modelo);
		1439	estilo.setRankingsPorLoja(vendaRepository.consultarEstoqueEeVendasEstiloPorLoja(parametrosParaConsulta, modelo));
		1440	estilo.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
600	blopes	1441	consulta.add(estilo);
149	espaco	1442	}
600	blopes	1443	return consulta;
149	espaco	1444	}
600	blopes	1445
		1446	@Override
		1447	public List<RankingComprasTransferenciasSubtipoProdutoDTO> consultarDetalhamentoPlanejamentoParaCompras(List<SubtipoProduto> subtiposParaConsultar, ParametrosConsultaParaComprasTransferenciasDTO parametrosParaConsulta, Modelo modelo) {
		1448	List<RankingComprasTransferenciasSubtipoProdutoDTO> consulta = new ArrayList<RankingComprasTransferenciasSubtipoProdutoDTO>();
		1449	for (SubtipoProduto subtipoProduto : subtiposParaConsultar) {
		1450	parametrosParaConsulta.setSubtipo(subtipoProduto);
602	blopes	1451	parametrosParaConsulta.setEstilo(null);;
600	blopes	1452	RankingComprasTransferenciasSubtipoProdutoDTO subtipo = vendaRepository.consultarEstoqueEeVendasPorSubtipo(parametrosParaConsulta, modelo);
		1453	subtipo.setRankingsPorLoja(vendaRepository.consultarEstoqueEeVendasSubtipoPorLoja(parametrosParaConsulta, modelo));
		1454	subtipo.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
		1455	consulta.add(subtipo);
		1456	}
		1457	return consulta;
		1458	}
149	espaco	1459
		1460	@Override
356	espaco	1461	public List<RankingVendedorDTO> consultarRankingPromocaoInterna(Date dataInicial, Date dataFinal) {
149	espaco	1462	List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
356	espaco	1463	Vigencia vigencia = vigenciaService.consultarVigenciaDoPeriodo(dataInicial);
		1464	if (VerificadorUtil.naoEstaNulo(vigencia)) {
		1465	Avaliacao avaliacao = avaliacaoService.consultarAvaliacaoDaVigencia(vigencia);
		1466	if (VerificadorUtil.naoEstaNulo(avaliacao)) {
		1467	List<AvaliacaoProduto> produtosAvaliacaoPromocaoInterna = avaliacaoService.consultarProdutosPromocaoInterna(avaliacao.getSequencial());
		1468	List<Produto> produtosPromocaoInterna = new ArrayList<Produto>();
		1469	for (AvaliacaoProduto produtoAvaliacaoPromocaoInterna : produtosAvaliacaoPromocaoInterna) {
		1470	produtosPromocaoInterna.add(produtoAvaliacaoPromocaoInterna.getProduto());
		1471	}
		1472
		1473	List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradoresAtivos(null);
		1474	for (Vendedor vendedor : vendedores) {
		1475	RankingVendedorDTO ranking = consultarRankingPromocaoInternaDoVendedor(vendedor, dataInicial, dataFinal, produtosPromocaoInterna);
422	blopes	1476	rankingVendedores.add(ranking);
356	espaco	1477	}
149	espaco	1478	}
		1479	}
		1480	return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
		1481	}
		1482
		1483	@Override
252	espaco	1484	public RankingVendedorDTO consultarRankingPromocaoInternaDoVendedor(Vendedor vendedor, Date dataInicial, Date dataFinal,
356	espaco	1485	List<Produto> produtosPromocaoInterna) {
149	espaco	1486	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1487	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1488	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1489	parametrosConsultaVendas.setVendedor(vendedor);
		1490	RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
		1491	rankingVendedor.setVendedor(vendedor);
		1492
252	espaco	1493	parametrosConsultaVendas.setProdutosPromocaoInterna(produtosPromocaoInterna);
		1494	rankingVendedor.setQuantidadeProdutosPromocaoInterna(lancamentoService.obterQuantidadeVendasDosProdutosDaPromocaoInterna(parametrosConsultaVendas));
		1495
		1496	parametrosConsultaVendas.setProdutosPromocaoInterna(null);
		1497	parametrosConsultaVendas.setIndicadorPesquisarPeliculasTpuSoft(true);
		1498	parametrosConsultaVendas.setIndicadorPesquisarPeliculasTpuSoftCameras(false);
		1499	rankingVendedor.setQuantidadeTpuSoftNormal(lancamentoService.obterQuantidadeVendasDosProdutosDaPromocaoInterna(parametrosConsultaVendas));
		1500
		1501	parametrosConsultaVendas.setProdutosPromocaoInterna(null);
		1502	parametrosConsultaVendas.setIndicadorPesquisarPeliculasTpuSoft(true);
		1503	parametrosConsultaVendas.setIndicadorPesquisarPeliculasTpuSoftCameras(true);
		1504	rankingVendedor.setQuantidadeTpuSoftCamera(lancamentoService.obterQuantidadeVendasDosProdutosDaPromocaoInterna(parametrosConsultaVendas));
		1505
149	espaco	1506	// if (rankingVendedor.getQuantidadePedidos() >= ConstantesSEC.ProdutosPromocaoInterna.QUANTIDADE_MINIMA_RECEBIMENTO) {
		1507	rankingVendedor.setValorTotalVendido(lancamentoService.obterValorTotalVendidoDosProdutosDaPromocaoInterna(parametrosConsultaVendas) * ConstantesSEC.ProdutosPromocaoInterna.PERCENTUAL);
		1508	// } else {
		1509	// rankingVendedor.setValorTotalVendido(new Double(0.0));
		1510	// }
		1511
		1512	ParametrosConsultaVendasDTO parametrosConsultaVendasDoDia = new ParametrosConsultaVendasDTO();
		1513	parametrosConsultaVendasDoDia.setDataInicial(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()));
		1514	parametrosConsultaVendasDoDia.setDataFinal(DataUtils.getDataComHorarioMaximo(DataUtils.getDataAtual()));
		1515	parametrosConsultaVendasDoDia.setVendedor(vendedor);
		1516	rankingVendedor.setValorTotalVendidoDoDia(lancamentoService.obterValorTotalVendidoDosProdutosDaPromocaoInterna(parametrosConsultaVendasDoDia));
		1517	return rankingVendedor;
		1518	}
		1519
		1520	@Override
		1521	public List<VendasDTO> consultarVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
		1522	return vendaRepository.consultarVendas(parametrosConsultaVendasDTO);
		1523	}
		1524
		1525	/*
		1526	@Override
		1527	public List<RankingVendedorDTO> consultarRankingVendedores(Date dataInicial, Date dataFinal) {
		1528	List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
		1529	List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradores();
		1530	for (Vendedor vendedor : vendedores) {
		1531	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1532	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1533	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1534	parametrosConsultaVendas.setVendedor(vendedor);
		1535	RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
		1536	rankingVendedor.setVendedor(vendedor);
		1537	rankingVendedor.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas));
		1538	rankingVendedor.setQuantidadePedidos(obterQuantidadePedidos(vendedor, dataInicial, dataFinal));
		1539	rankingVendedores.add(rankingVendedor);
		1540	}
		1541	return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
		1542	}
		1543	*/
		1544
		1545	}

Subversion Repositories Integrator Subversion

(root)/projeto/espacocase/src/main/java/br/com/ec/domain/service/venda/impl/VendaServiceImpl.java - Rev 690