WebSVN - Integrator Subversion - Blame - Rev 689 - /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()) {
		365	if (pagamento.getFormaPagamento().formaPagamentoEhCredito() \|\|
		366	pagamento.getFormaPagamento().formaPagamentoEhDebito() \|\|
		367	pagamento.getFormaPagamento().formaPagamentoEhPagseguro()) {
		368	return true;
		369	}
		370	}
		371	}
		372	return null;
		373	}
		374
		375	private void alterarSituacaoPedido(Pedido pedidoVinculado, Venda venda) {
		376	if (VerificadorUtil.naoEstaNulo(pedidoVinculado)) {
		377	PedidoHistorico pedidoHistorico = new PedidoHistorico();
		378	pedidoHistorico.setDataHistorico(DataUtils.getDataAtual());
		379	pedidoHistorico.setObservacao("VENDA: " + venda.getSequencial());
		380	pedidoHistorico.setTipoSituacao(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor());
		381	pedidoHistorico.setUsuario(venda.getUsuario());
		382	pedidoHistorico.setPedido(pedidoVinculado);
		383	if (VerificadorUtil.estaNulo(pedidoVinculado.getHistorico())) {
		384	pedidoVinculado.setHistorico(new ArrayList<PedidoHistorico>());
		385	}
		386	pedidoVinculado.getHistorico().add(pedidoHistorico);
		387	pedidoVinculado.setTipoSituacao(TipoSituacaoPedido.FINALIZADO_COM_VENDAS.getValor());
		388	pedidoVinculado.setDataUltimaAlteracaoSituacao(DataUtils.getDataAtual());
165	espaco	389	pedidoVinculado.setVenda(venda);
149	espaco	390	pedidoService.alterar(pedidoVinculado);
		391	}
		392	}
		393
		394	private void enviarAlertasPorEmail(ParametrosVendaDTO parametrosVenda, Venda venda) {
577	blopes	395	Boolean enviarAlerta = false;
		396	String emailsDestino = "";
		397	String assuntoAlerta = "";
149	espaco	398	if (descontosEmProdutosSuperiores(parametrosVenda)) {
577	blopes	399	enviarAlerta = true;
		400	emailsDestino = ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO;
		401	assuntoAlerta = "ESPAÇO CASE - VENDA COM DESCONTO SUPERIOR : " + DataUtils.converterDataParaString(DataUtils.getDataAtual());
149	espaco	402	}
		403	if (produtosComDescontoECupom(parametrosVenda)) {
577	blopes	404	enviarAlerta = true;
		405	emailsDestino = ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO;
		406	assuntoAlerta = "ESPAÇO CASE - VENDA COM PRODUTO COM DESCONTO E CUPOM PROMOCIONAL : " + DataUtils.converterDataParaString(DataUtils.getDataAtual());
		407	}
		408	if (possuiMaisDeDuasFormasDePagamento(parametrosVenda)) {
		409	enviarAlerta = true;
		410	emailsDestino = ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO;
		411	assuntoAlerta = "ESPAÇO CASE - VENDA SUSPEITA COM MAIS DE 2 FORMAS DE PAGAMENTO : " + DataUtils.converterDataParaString(DataUtils.getDataAtual());
		412	}
		413	if (enviarAlerta) {
149	espaco	414	new GerenciadorEmailImpl()
577	blopes	415	.comEmailsDestino(emailsDestino)
		416	.comAssunto(assuntoAlerta)
149	espaco	417	.comConteudo(montarDadosDaVenda(venda, venda.getUsuario(), parametrosVenda.getLancamentos(), parametrosVenda.getLancamentosPagamentos()))
		418	.enviar();
		419	}
		420	}
		421
577	blopes	422	private Boolean possuiMaisDeDuasFormasDePagamento(ParametrosVendaDTO parametrosVenda) {
		423	return parametrosVenda.getLancamentosPagamentos().size() > 2;
		424	}
		425
149	espaco	426	/*
		427	private void enviarAlertasPorEmail(ParametrosVendaDTO parametrosVenda, Venda venda) {
		428	if (pagamentoDividido(parametrosVenda)) {
		429	if (descontoEmProdutos(parametrosVenda)) {
		430	String diaAtual = DataUtils.converterDataParaString(DataUtils.getDataAtual());
		431	new GerenciadorEmailImpl()
		432	.comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_DIRECAO)
		433	.comAssunto("ESPAÇO CASE - VENDA DIVIDIDA E COM DESCONTO : " + diaAtual)
		434	.comConteudo(montarDadosDaVenda(venda, venda.getUsuario(), parametrosVenda.getLancamentos(), parametrosVenda.getLancamentosPagamentos()))
		435	.enviar();
		436	}
		437	}
		438	}
320	espaco	439
149	espaco	440
		441	private Boolean pagamentoDividido(ParametrosVendaDTO parametrosVenda) {
		442	for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
		443	if (pagamento.getFormaPagamento().formaPagamentoEhCreditoDividido()) {
		444	return true;
		445	}
		446	}
		447	return false;
		448	}
		449
		450	private boolean descontoEmProdutos(ParametrosVendaDTO parametrosVenda) {
		451	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		452	if (lancamento.comDescontos()) {
		453	return true;
		454	}
		455	}
		456	return false;
		457	}
320	espaco	458	*/
149	espaco	459
		460	private boolean descontosEmProdutosSuperiores(ParametrosVendaDTO parametrosVenda) {
320	espaco	461	if (produtoJBLComDesconto(parametrosVenda.getLancamentos())) {
		462	return true;
		463	}
		464
		465	Double totalDescontoPermitido = 0.0;
		466	Double totalDescontoConcebido = 0.0;
149	espaco	467	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
320	espaco	468	if (VerificadorUtil.naoEstaNulo(lancamento.getValorVarejo()) && VerificadorUtil.naoEstaNulo(lancamento.getValorVenda())) {
		469	totalDescontoConcebido = totalDescontoConcebido + (lancamento.getValorVarejo() - lancamento.getValorVenda());
		470	if (lancamento.getValorVarejo() < 100) {
		471	totalDescontoPermitido = totalDescontoPermitido + 5.0;
		472	} else {
		473	totalDescontoPermitido = totalDescontoPermitido + (lancamento.getValorVarejo()*10/100);
		474	}
		475	}
		476	}
		477	if (totalDescontoConcebido > totalDescontoPermitido) {
		478	return true;
		479	}
		480	return false;
		481	}
		482
		483	private boolean produtoJBLComDesconto(List<Lancamento> lancamentos) {
		484	for (Lancamento lancamento : lancamentos) {
		485	if (lancamento.getProduto().getDescricaoCompleta().contains("JBL") && lancamento.comDescontos()) {
149	espaco	486	return true;
		487	}
		488	}
		489	return false;
		490	}
320	espaco	491
149	espaco	492	private boolean produtosComDescontoECupom(ParametrosVendaDTO parametrosVenda) {
		493	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		494	if (VerificadorUtil.naoEstaNulo(lancamento.getCupom()) && lancamento.comDescontos()) {
		495	return true;
		496	}
		497	}
		498	return false;
		499	}
		500
		501	@Override
		502	public void alterarVenda(ParametrosVendaDTO parametrosVenda, Usuario usuario, Boolean verificarJustificativa) {
		503	verificarLancamentos(parametrosVenda.getLancamentos());
577	blopes	504	lancarExcecaoSeUsuarioNaoTiverPermissao(parametrosVenda, usuario, verificarJustificativa);
149	espaco	505	lancarExcecaoCasoNaoSejaInformadoCamposObrigatorios(parametrosVenda);
		506	lancarExcecaoSeValoresNaoSaoIguais(parametrosVenda);
		507	if (verificarJustificativa) {enviarEmailAlteracoes(parametrosVenda, usuario);}
		508	atualizarDadosDaVenda(parametrosVenda);
		509	alterarLancamentos(parametrosVenda);
		510	alterarPagamentos(parametrosVenda);
		511	alterar(parametrosVenda.getVenda());
		512	alterarSituacaoPedido(parametrosVenda.getPedidoVinculado(), parametrosVenda.getVenda());
		513	}
		514
577	blopes	515	private void lancarExcecaoSeUsuarioNaoTiverPermissao(ParametrosVendaDTO parametrosVenda, Usuario usuario, Boolean verificarJustificativa) {
		516	if (verificarJustificativa) {
		517	for (UsuarioPerfil usuarioPerfil : usuario.getPerfis()) {
		518	if (usuarioPerfil.getPerfil().getCodigo().equals(ConstantesSEC.PERFIL_LOJA_9)) {
		519	throw new NegocioException("USUÁRIO SEM PERMISSÃO PARA ESTA OPERAÇÃO");
		520	}
		521	}
		522
		523	if (!parametrosVenda.getVendedor().equals(parametrosVenda.getVenda().getVendedor())) {
		524	Usuario usuarioDetalhe = usuarioService.detalhar(usuario);
		525	if (VerificadorUtil.naoEstaNulo(usuarioDetalhe.getPessoa())) {
		526	if (!parametrosVenda.getVenda().getVendedor().getPessoa().equals(usuarioDetalhe.getPessoa())) {
		527	throw new NegocioException("OPERAÇÃO SÓ PODE SER REALIZADA PELO VENDEDOR ATUAL");
		528	}
		529	} else {
		530	throw new NegocioException("USUÁRIO SEM PERMISSÃO PARA ESTA OPERAÇÃO");
		531	}
		532	}
		533	}
		534	}
		535
149	espaco	536	private void enviarEmailAlteracoes(ParametrosVendaDTO parametrosVenda, Usuario usuario) {
		537	String diaAtual = DataUtils.converterDataParaString(DataUtils.getDataAtual());
		538	StringBuilder conteudo = new StringBuilder();
		539	conteudo.append("OPERAÇÃO REALIZADA POR: " + usuario.getNome() + "\n");
		540	conteudo.append("ID: " + parametrosVenda.getVenda().getSequencial() + "\n");
		541	conteudo.append("DATA DA VENDA: " + DataUtils.converterDataComHorarioParaString(parametrosVenda.getVenda().getDataVenda()) + "\n");
		542	conteudo.append("ALTERAÇÕES:\n");
		543	if (!parametrosVenda.getLoja().equals(parametrosVenda.getVenda().getLoja())) {
		544	conteudo.append("LOJA: " + parametrosVenda.getVenda().getLoja().getDescricao() + " -> " + parametrosVenda.getLoja().getDescricao() + "\n");
		545	}
		546	if (!parametrosVenda.getVendedor().equals(parametrosVenda.getVenda().getVendedor())) {
		547	conteudo.append("VENDEDOR: " + parametrosVenda.getVenda().getVendedor().getNomeDaPessoa() + " -> " + parametrosVenda.getVendedor().getNomeDaPessoa() + "\n");
		548	}
		549
		550	String indicacao = "NÃO INFORMADO";
		551	String novaIndicacao = "NÃO INFORMADO";
		552	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getVenda().getIndicacao())) {
		553	indicacao = parametrosVenda.getVenda().getIndicacao().getNome();
		554	}
		555	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getIndicacao())) {
		556	novaIndicacao = parametrosVenda.getIndicacao().getNome();
		557	}
		558	if (!indicacao.equals(novaIndicacao)) {
		559	conteudo.append("INDICAÇÃO: " + indicacao + " -> " + novaIndicacao + "\n");
		560	}
		561
		562	String cliente = "NÃO INFORMADO";
		563	String novoCliente = "NÃO INFORMADO";
		564	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getVenda().getCliente())) {
		565	cliente = parametrosVenda.getVenda().getCliente().getNome();
		566	}
		567	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getCliente())) {
		568	novoCliente = parametrosVenda.getCliente().getNome();
		569	}
		570	if (!cliente.equals(novoCliente)) {
		571	conteudo.append("CLIENTE: " + cliente + " -> " + novoCliente + "\n");
		572	}
		573
		574	if (!parametrosVenda.getObservacao().equals(parametrosVenda.getVenda().getObservacao())) {
		575	conteudo.append("OBS: " + parametrosVenda.getVenda().getObservacao() + " -> " + parametrosVenda.getObservacao() + "\n");
		576	}
		577
		578	String formasPagamento = "";
		579	String novasFormasPagamento = "";
		580	List<VendaFormaPagamento> pagamentosAnteriores = consultarPagamentosCadastrados(parametrosVenda);
		581	if (!VerificadorUtil.isListaNulaOuVazia(pagamentosAnteriores)) {
		582	for (VendaFormaPagamento pagamento : pagamentosAnteriores) {
		583	formasPagamento = formasPagamento + " R$" + pagamento.getValorPagamento() + " (" + pagamento.getFormaPagamento().getDescricao();
		584	if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
		585	formasPagamento = formasPagamento + " - " + pagamento.getBandeiraCartao().getTipoCartaoDescricao() + " - " + pagamento.getDescricaoDaBandeiraCartao();
		586	}
		587	formasPagamento = formasPagamento + "); ";
		588	}
		589	}
		590	if (!VerificadorUtil.isListaNulaOuVazia(parametrosVenda.getLancamentosPagamentos())) {
		591	for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
		592	novasFormasPagamento = novasFormasPagamento + " R$" + pagamento.getValorPagamento() + " (" + pagamento.getFormaPagamento().getDescricao();
		593	if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
		594	novasFormasPagamento = novasFormasPagamento + " - " + pagamento.getBandeiraCartao().getTipoCartaoDescricao() + " - " + pagamento.getDescricaoDaBandeiraCartao();
		595	}
		596	novasFormasPagamento = novasFormasPagamento + "); ";
		597	}
		598	}
		599	if (!formasPagamento.equals(novasFormasPagamento)) {
		600	conteudo.append("FORMAS DE PAGAMENTO: " + formasPagamento + " -> " + novasFormasPagamento + "\n");
		601	}
		602
		603	conteudo.append("\n");
		604	conteudo.append("JUSTIFICATIVA: " + parametrosVenda.getVenda().getJustificativaParaExcluir() + "\n");
		605	new GerenciadorEmailImpl()
		606	.comEmailsDestino(ConstantesSEC.DESTINATARIOS_EMAIL_SUPERVISAO)
		607	.comAssunto("ESPAÇO CASE - ALTERAÇÃO DE VENDA: " + diaAtual)
		608	.comConteudo(conteudo.toString())
		609	.enviar();
		610	}
		611
		612	private String montarDadosDaVenda(Venda venda, Usuario usuario, List<Lancamento> lancamentos, List<VendaFormaPagamento> pagamentos) {
		613	StringBuilder conteudo = new StringBuilder();
		614	conteudo.append("OPERAÇÃO REALIZADA POR: " + usuario.getNome() + "\n");
		615	conteudo.append("ID: " + venda.getSequencial() + "\n");
		616	conteudo.append("DATA DA VENDA: " + DataUtils.converterDataComHorarioParaString(venda.getDataVenda()) + "\n");
		617	conteudo.append("LOJA: " + venda.getLoja().getDescricao() + "\n");
		618	conteudo.append("VENDEDOR: " + venda.getVendedor().getNomeDaPessoa() + "\n");
		619	conteudo.append("TOTAL: " + valorTotalVenda(lancamentos) + "\n");
		620	conteudo.append("OBS.: " + venda.getObservacao() + "\n");
		621	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getJustificativaParaExcluir())) {
		622	conteudo.append("JUSTIFICATIVA: " + venda.getJustificativaParaExcluir() + "\n");
		623	} else {
		624	conteudo.append("SEM JUSTIFICATIVA\n");
		625	}
		626	conteudo.append("--------------------------------------------------\n");
		627	for (Lancamento lancamento : lancamentos) {
		628	conteudo.append(lancamento.getProduto().getCodigoProdutoPadrao() + " \| ");
		629	conteudo.append(lancamento.getProduto().getDescricaoComModeloCompleta() + ", ");
		630	conteudo.append("R$" + lancamento.getValorVenda());
		631	if (lancamento.comDescontos()) {
		632	conteudo.append(" (COM DESCONTO DE R$" + lancamento.valorDescontos());
		633	conteudo.append(" [" + lancamento.valorPercentualDescontos() + "])");
		634	}
		635	if (VerificadorUtil.naoEstaNuloOuVazio(lancamento.getObservacao())) {
		636	conteudo.append(" (OBS.: " + lancamento.getObservacao() + ")");
		637	}
		638	if (VerificadorUtil.naoEstaNulo(lancamento.getCupom())) {
		639	String descricaoCupom = lancamento.getCupom().getCodigo();
		640	if (VerificadorUtil.naoEstaNulo(lancamento.getCupom().getDescricao())) {
		641	descricaoCupom = descricaoCupom + " - " + lancamento.getCupom().getDescricao();
		642	}
		643	conteudo.append(" (CUPOM: " + descricaoCupom + ")");
		644	}
		645	conteudo.append("\n");
		646	}
		647	conteudo.append("--------------------------------------------------\n");
		648	for (VendaFormaPagamento pagamento : pagamentos) {
		649	if (VerificadorUtil.naoEstaNulo(pagamento.getBandeiraCartao())) {
		650	conteudo.append(pagamento.getFormaPagamento().getDescricao() + " - " + pagamento.getBandeiraCartao().getDescricao() + ": R$" + pagamento.getValorPagamento() + "\n");
		651	} else {
		652	conteudo.append(pagamento.getFormaPagamento().getDescricao() + ": R$" + pagamento.getValorPagamento() + "\n");
		653	}
		654	conteudo.append("\n");
		655	}
		656	conteudo.append("--------------------------------------------------\n");
		657	if (VerificadorUtil.naoEstaNulo(venda.getCliente())) {
		658	conteudo.append("DADOS DO CLIENTE:\n");
		659	conteudo.append(venda.getCliente().getNome() + "\n");
		660	conteudo.append(venda.getCliente().getCpfCnpjFormatado() + "\n");
		661	}
		662	return conteudo.toString();
		663	}
		664
		665	private Double valorTotalVenda(List<Lancamento> lancamentos) {
		666	Double total = new Double(0.0);
		667	for (Lancamento lancamento : lancamentos) {
		668	if (lancamento.getAtivo()) {
		669	total = total + lancamento.getValorVenda();
		670	}
		671	}
		672	return total;
		673	}
		674
		675	private void atualizarDadosDaVenda(ParametrosVendaDTO parametrosVenda) {
		676	parametrosVenda.getVenda().setVendedor(parametrosVenda.getVendedor());
		677	parametrosVenda.getVenda().setIndicacao(parametrosVenda.getIndicacao());
		678	parametrosVenda.getVenda().setCliente(parametrosVenda.getCliente());
		679	parametrosVenda.getVenda().setObservacao(parametrosVenda.getObservacao());
		680	parametrosVenda.getVenda().setNotaFiscal(parametrosVenda.getNotaFiscal());
		681	parametrosVenda.getVenda().setMaquineta(parametrosVenda.getMaquineta());
		682	if (!parametrosVenda.getVenda().getLoja().equals(parametrosVenda.getLoja())) {
		683	for (Lancamento lancamento : parametrosVenda.getVenda().getLancamentos()) {
305	espaco	684	alterarEstoqueProduto(1, parametrosVenda.getVenda().getLoja(), lancamento.getProduto().getCodigo(), lancamento.getTipoPersonalizacao());
		685	alterarEstoqueProduto(-1, parametrosVenda.getLoja(), lancamento.getProduto().getCodigo(), lancamento.getTipoPersonalizacao());
149	espaco	686	}
		687	parametrosVenda.getVenda().setLoja(parametrosVenda.getLoja());
		688	parametrosVenda.getVenda().setMaquineta(parametrosVenda.getLoja().getMaquineta());
		689	}
		690	parametrosVenda.getVenda().setTipoSituacao(parametrosVenda.getTipoSituacao());
		691	parametrosVenda.getVenda().setDataVenda(parametrosVenda.getDataVenda());
		692	}
		693
		694	@Override
		695	public List<Venda> consultarVendasDoDia(Long sequencialLoja, Date dataVendas) {
		696	return vendaRepository.consultarVendasDoDia(sequencialLoja, dataVendas);
		697	}
		698
		699	@Override
		700	public Integer obterQuantidadeDeVendasPorLojaEePeriodo(Venda venda, Date dataInicial, Date dataFinal) {
		701	return vendaRepository.obterQuantidadeDeVendasPorLojaEePeriodo(venda, dataInicial, dataFinal);
		702	}
		703
		704	@Override
		705	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodo(Loja loja, Date dataInicial, Date dataFinal) {
		706	Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodo(loja, dataInicial, dataFinal);
689	blopes	707	valorTotal = valorTotal - vendaRepository.obterValorDeCuponsOuCashbackUtilizadosPorLojaEePeriodo(new ParametrosConsultaVendasDTO(loja, dataInicial, dataFinal));
149	espaco	708	return valorTotal;
		709	}
		710
		711	@Override
		712	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		713	Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsulta);
689	blopes	714	valorTotal = valorTotal - vendaRepository.obterValorDeCuponsOuCashbackUtilizadosPorLojaEePeriodo(parametrosConsulta);
149	espaco	715	return valorTotal;
		716	}
		717
		718	@Override
		719	public Double obterValorTotalDeDescontosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		720	return vendaRepository.obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsulta);
		721	}
		722
		723	@Override
		724	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodoEeFormasDePagamento(ParametrosConsultaVendasDTO parametrosConsultaVendas, List<FormaPagamento> formasDePagamento) {
		725	return vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodoEeFormasDePagamento(parametrosConsultaVendas, formasDePagamento);
		726	}
		727
		728	@Override
		729	public Double obterValorTotalLiquidoDeVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		730	return vendaRepository.obterValorTotalLiquidoDeVendasPorLojaEePeriodo(parametrosConsulta);
		731	}
		732
		733	@Override
		734	public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		735	return vendaRepository.obterQuantidadeProdutosVendidosPorLojaEePeriodo(parametrosConsultaVendas);
		736	}
		737
		738	@Override
		739	public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		740	return vendaRepository.obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(parametrosConsultaVendas);
		741	}
		742
		743	@Override
		744	public Integer obterQuantidadeProdutosVendidosPorEstiloEeGenero(Date dataInicial, Date dataFinal, Long sequencialLoja, Long sequencialModelo, String tipoProduto, String estiloProduto, String tipoGenero) {
		745	return vendaRepository.obterQuantidadeProdutosVendidosPorEstiloEeGenero(dataInicial, dataFinal, sequencialLoja, sequencialModelo, tipoProduto, estiloProduto, tipoGenero);
		746	}
		747
		748	@Override
		749	public Double obterValorProdutosUtilizadosEmVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		750	return vendaRepository.obterValorProdutosUtilizadosEmVendasPorLojaEePeriodo(parametrosConsulta);
		751	}
		752
		753	private void verificarLancamentos(List<Lancamento> lancamentos) {
		754	if (lancamentos.isEmpty()) {
		755	throw new NegocioException("Obrigatório informar ao menos um produto");
		756	}
		757	}
		758
		759	// TODO: EM DESENVOLVIMENTO
		760	/*
		761	private void lancarExcecaoCasoFreteContraditorio(ParametrosVendaDTO parametrosVenda) {
		762	if (VerificadorUtil.naoEstaNulo(parametrosVenda.getTipoFrete())) {
		763	if (parametrosVenda.getTipoFrete().equals(ConstantesSEC.NotaFiscal.Transporte.SEM_OCORRENCIA_TRANSPORTE_9)
		764	&& parametrosVenda.getValorFrete() > 0.0) {
		765	throw new NegocioException("Não é possível informar o frete sem a ocorrência.");
		766	}
		767	if (parametrosVenda.getTipoFrete().equals(ConstantesSEC.NotaFiscal.Transporte.FRETE_POR_CONTA_REMETENTE_TRANSPORTE_PROPRIO_3)
		768	&& parametrosVenda.getValorFrete() == 0.0) {
		769	throw new NegocioException("É necessário informar o valor do frete.");
		770	}
		771
		772	}
		773	// CASO TENHA VALOR E: FRETE CIF, FRETE DE TERCEIROS, FRETE REMETENTE (TP) OU SEM OCORRÊNCIA
		774	// CASO NÃO TENHA VALOR E: FRETE FOB.
		775	}
		776	*/
		777
		778	private void lancarExcecaoCasoNaoSejaInformadoCamposObrigatorios(ParametrosVendaDTO parametrosVenda) {
		779	if (VerificadorUtil.isListaNulaOuVazia(parametrosVenda.getLancamentosPagamentos()) && VerificadorUtil.estaNuloOuVazio(parametrosVenda.getObservacao())) {
		780	throw new NegocioException("Obrigatório informar as observações em vendas sem pagamentos");
		781	}
		782	if (VerificadorUtil.estaNulo(parametrosVenda.getLoja())) {
		783	throw new NegocioException("Informe a loja");
		784	}
277	espaco	785	for (VendaFormaPagamento vendaFormaPagamento : parametrosVenda.getLancamentosPagamentos()) {
		786	if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCartao()) {
		787	if (VerificadorUtil.estaNulo(parametrosVenda.getMaquineta())) {
		788	throw new NegocioException("Informe a maquineta");
		789	}
		790	}
		791	}
305	espaco	792	if (possuiLancamentoPersonalizacao(parametrosVenda.getLancamentos())) {
		793	if (VerificadorUtil.estaNulo(parametrosVenda.getCliente()) && VerificadorUtil.estaNuloOuVazio(parametrosVenda.getObservacao())) {
		794	throw new NegocioException("Informe o cliente ou o contato do cliente nas observações");
		795	}
		796	}
		797	if (VerificadorUtil.estaNulo(parametrosVenda.getLoja())) {
		798	throw new NegocioException("Informe a loja");
		799	}
149	espaco	800	}
305	espaco	801
		802	private Boolean possuiLancamentoPersonalizacao(List<Lancamento> lancamentos) {
		803	for (Lancamento lancamento : lancamentos) {
		804	if (VerificadorUtil.naoEstaNuloOuVazio(lancamento.getTipoPersonalizacao())) {
		805	return true;
		806	}
		807	}
		808	return false;
		809	}
149	espaco	810
		811	private void lancarExcecaoSeValoresNaoSaoIguais(ParametrosVendaDTO parametrosVenda) {
		812	final double TOLERANCE = 0.01;
		813	if(Math.abs(parametrosVenda.valorTotalLancamentos() /+ parametrosVenda.getValorFrete() /- parametrosVenda.valorTotalPago()) > TOLERANCE) {
		814	throw new NegocioException("Valores pagos não corresponde ao valor vendido.");
		815	}
		816	}
		817
		818	private void cadastrarLancamentos(ParametrosVendaDTO parametrosVenda, Venda venda) {
		819	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		820	cadastrarLancamento(parametrosVenda.getLoja(), venda, lancamento);
		821	}
		822	}
		823
		824	private void alterarLancamentos(ParametrosVendaDTO parametrosVenda) {
		825	excluirLancamentosRetiradosDaLista(parametrosVenda, consultarLancamentosCadastrados(parametrosVenda));
		826	cadastrarNovosLancamentos(parametrosVenda);
		827	}
		828
		829	private void excluirLancamentosRetiradosDaLista(ParametrosVendaDTO parametrosVenda, List<Lancamento> lancamentosAntigos) {
		830	for (Lancamento lancamentoAntigo : lancamentosAntigos) {
		831	if (!parametrosVenda.getLancamentos().contains(lancamentoAntigo)) {
		832	lancamentoService.excluir(lancamentoAntigo);
305	espaco	833	alterarEstoqueProduto(1, parametrosVenda.getLoja(), lancamentoAntigo.getProduto().getCodigo(), lancamentoAntigo.getTipoPersonalizacao());
149	espaco	834	}
		835	}
		836	}
		837
		838	private void cadastrarNovosLancamentos(ParametrosVendaDTO parametrosVenda) {
		839	for (Lancamento lancamento : parametrosVenda.getLancamentos()) {
		840	if (VerificadorUtil.estaNulo(lancamento.getSequencial())) {
		841	cadastrarLancamento(parametrosVenda.getLoja(), parametrosVenda.getVenda(), lancamento);
		842	}
		843	}
		844	}
		845
		846	private List<Lancamento> consultarLancamentosCadastrados(ParametrosVendaDTO parametrosVenda) {
		847	Lancamento lancamentoDaVenda = new Lancamento();
		848	lancamentoDaVenda.setVenda(parametrosVenda.getVenda());
		849	return lancamentoService.consultarPassandoEntidade(lancamentoDaVenda, 0, lancamentoService.obterQuantidadeDeRegistrosPassandoEntidade(lancamentoDaVenda));
		850	}
		851
		852	private void cadastrarLancamento(Loja loja, Venda venda, Lancamento lancamento) {
		853	lancamento.setVenda(venda);
		854	igualarValorVarejoComCompraSeProdutoForPadrao(lancamento);
		855	acrescentarValorIPISeHouver(lancamento);
		856	lancamentoService.cadastrar(lancamento);
305	espaco	857	alterarEstoqueProduto(-1, loja, lancamento.getProduto().getCodigo(), lancamento.getTipoPersonalizacao());
149	espaco	858	utilizarCupom(lancamento.getCupom());
		859
		860	}
		861
		862	private void igualarValorVarejoComCompraSeProdutoForPadrao(Lancamento lancamento) {
		863	if (VerificadorUtil.naoEstaNulo(lancamento.getProduto())) {
		864	if (lancamento.getProduto().getCodigo().equals(ConstantesSEC.CODIGO_PRODUTO_PADRAO_000000)) {
		865	lancamento.setValorVarejo(lancamento.getValorVenda());
		866	}
		867	}
		868	}
		869
		870	private void acrescentarValorIPISeHouver(Lancamento lancamento) {
		871	if (VerificadorUtil.naoEstaNulo(lancamento.getProduto())) {
212	espaco	872	lancamento.setValorCompra(lancamento.getProduto().getValorCompra());
		873	// lancamento.setValorCompra(lancamento.getProduto().calculoOperacao());
149	espaco	874	}
		875	}
		876
		877	private void cadastrarPagamentos(ParametrosVendaDTO parametrosVenda, Venda venda) {
		878	for (VendaFormaPagamento vendaFormaPagamento : parametrosVenda.getLancamentosPagamentos()) {
		879	adicionarMaquineta(vendaFormaPagamento, parametrosVenda, venda);
		880	vendaFormaPagamento.setVenda(venda);
		881	vendaFormaPagamentoService.cadastrar(vendaFormaPagamento);
		882	utilizarCupom(vendaFormaPagamento.getCupom());
		883	}
		884	}
635	blopes	885
149	espaco	886	private void adicionarMaquineta(VendaFormaPagamento vendaFormaPagamento, ParametrosVendaDTO parametrosVenda, Venda venda) {
		887	if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCartao()) {
		888	if (VerificadorUtil.estaNulo(parametrosVenda.getMaquineta())) {
		889	parametrosVenda.setMaquineta(parametrosVenda.getLoja().getMaquineta());
		890	}
		891	venda.setMaquineta(parametrosVenda.getMaquineta());
		892	}
		893	}
		894
635	blopes	895	private void cadastrarPosVenda(Venda venda) {
		896	posVendaService.iniciarPosVenda(venda);
		897	}
		898
686	blopes	899	private void atualizarCashback(ParametrosVendaDTO parametrosVenda, Venda venda) {
		900	// RETIRAR DO SALDO O CASHBACK
689	blopes	901	Double valorCashback = 0.0;
		902	for (VendaFormaPagamento vendaFormaPagamento : parametrosVenda.getLancamentosPagamentos()) {
		903	if (vendaFormaPagamento.getFormaPagamento().formaPagamentoEhCashback()) {
		904	valorCashback += vendaFormaPagamento.getValorPagamento();
		905	}
		906	}
		907	if (valorCashback > 0.0) {
		908	cashbackService.utilizarCashback(venda, valorCashback);
		909	} else {
		910	// GERAR SE NÃO HOUVER UTILIZAÇÃO DO CASHBACK
		911	cashbackService.gerarCashback(parametrosVenda, venda);
		912	}
686	blopes	913
685	blopes	914	}
		915
149	espaco	916	private void alterarPagamentos(ParametrosVendaDTO parametrosVenda) {
		917	excluirPagamentosRetiradosDaLista(parametrosVenda, consultarPagamentosCadastrados(parametrosVenda));
		918	cadastrarNovosPagamentos(parametrosVenda);
		919	}
		920
		921	private void excluirPagamentosRetiradosDaLista(ParametrosVendaDTO parametrosVenda, List<VendaFormaPagamento> pagamentosAntigos) {
		922	for (VendaFormaPagamento pagamentoAntigo : pagamentosAntigos) {
		923	if (!parametrosVenda.getLancamentosPagamentos().contains(pagamentoAntigo)) {
		924	vendaFormaPagamentoService.excluir(pagamentoAntigo);
		925	}
		926	// if (verificarSePagamentoFoiRetiradoDaLista(parametrosVenda.getLancamentosPagamentos(), pagamentoAntigo)) {
		927	// vendaFormaPagamentoService.excluirPorId(pagamentoAntigo);
		928	// }
		929	}
		930	}
		931
		932	private boolean verificarSePagamentoFoiRetiradoDaLista(List<VendaFormaPagamento> pagamentos, VendaFormaPagamento pagamentoAntigo) {
		933	boolean pagamentoRetirado = true;
		934	for (VendaFormaPagamento pagamento : pagamentos) {
		935	if (pagamento.getCodigoDaFormaPagamento().equals(pagamentoAntigo.getCodigoDaFormaPagamento())) {
		936	if (verificarSeBandeiraCartaoEhIgual(pagamento.getCodigoDaBandeiraCartao(), pagamentoAntigo.getCodigoDaBandeiraCartao()) &&
		937	pagamento.getValorPagamento().equals(pagamentoAntigo.getValorPagamento())) {
		938	return false;
		939	} else {
		940	pagamento.setVenda(pagamentoAntigo.getVenda());
		941	vendaFormaPagamentoService.alterar(pagamento);
		942	return false;
		943	}
		944	}
		945	}
		946	return pagamentoRetirado;
		947	}
		948
		949	private boolean verificarSeBandeiraCartaoEhIgual(Long codigoDaBandeiraCartao, Long codigoDaBandeiraCartaoSegundo) {
		950	if (VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartao) && VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartaoSegundo)) {
		951	return codigoDaBandeiraCartao.equals(codigoDaBandeiraCartaoSegundo);
		952	}
		953	if ((VerificadorUtil.estaNulo(codigoDaBandeiraCartao) && VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartaoSegundo)) \|\|
		954	(VerificadorUtil.naoEstaNulo(codigoDaBandeiraCartao) && VerificadorUtil.estaNulo(codigoDaBandeiraCartaoSegundo))) {
		955	return false;
		956	}
		957	return true;
		958	}
		959
		960	private void cadastrarNovosPagamentos(ParametrosVendaDTO parametrosVenda) {
		961	for (VendaFormaPagamento pagamento : parametrosVenda.getLancamentosPagamentos()) {
		962	if (VerificadorUtil.estaNulo(pagamento.getSequencial())) {
		963	adicionarMaquineta(pagamento, parametrosVenda, parametrosVenda.getVenda());
		964	pagamento.setVenda(parametrosVenda.getVenda());
		965	vendaFormaPagamentoService.cadastrar(pagamento);
		966	utilizarCupom(pagamento.getCupom());
		967	}
		968	}
		969	}
		970
		971	private List<VendaFormaPagamento> consultarPagamentosCadastrados(ParametrosVendaDTO parametrosVenda) {
		972	VendaFormaPagamento pagamentoDaVenda = new VendaFormaPagamento();
		973	pagamentoDaVenda.setVenda(parametrosVenda.getVenda());
		974	return vendaFormaPagamentoService.consultarPassandoEntidade(pagamentoDaVenda, 0, vendaFormaPagamentoService.obterQuantidadeDeRegistrosPassandoEntidade(pagamentoDaVenda));
		975	}
		976
305	espaco	977	private void alterarEstoqueProduto(Integer quantidadeAlterar, Loja loja, String codigoProduto, String tipoPersonalizacao) {
149	espaco	978	if (VerificadorUtil.naoEstaNulo(codigoProduto)) {
		979	Produto produto = produtoService.consultarProdutoPorCodigo(codigoProduto);
305	espaco	980	Loja lojaAlterarEstoque = retornarLojaParaAlteracaoEstoque(loja, tipoPersonalizacao);
		981	produtoLojaService.alterarEstoqueAcrescentandoQuantidadeInformada(quantidadeAlterar, produto, lojaAlterarEstoque);
149	espaco	982	}
		983	}
		984
305	espaco	985	private Loja retornarLojaParaAlteracaoEstoque(Loja loja, String tipoPersonalizacao) {
		986	if (VerificadorUtil.naoEstaNulo(tipoPersonalizacao)) {
		987	return new Loja(ConstantesSEC.Personalizacao.SEQUENCIAL_LOJA_PERSONALIZACAO);
		988	}
		989	return loja;
		990	}
		991
149	espaco	992	private void utilizarCupom(Cupom cupom) {
		993	if (VerificadorUtil.naoEstaNulo(cupom)) {
		994	Cupom cupomUtilizado = cupomService.consultarPorId(cupom);
		995	cupomUtilizado.setDataHoraUtilizado(DataUtils.getDataAtual());
		996	if (VerificadorUtil.estaNulo(cupomUtilizado.getQuantidadeUtilizada())) {
		997	cupomUtilizado.setQuantidadeUtilizada(0);
		998	}
		999	cupomUtilizado.setQuantidadeUtilizada(cupomUtilizado.getQuantidadeUtilizada() + 1);
		1000	cupomService.alterar(cupomUtilizado);
		1001	}
		1002	}
		1003
		1004	@Override
		1005	public List<Venda> consultarVendasPorDemanda(ParametrosConsulta<Venda> parametrosConsulta, Integer primeiroRegistro,
		1006	Integer tamanhoPagina, String sortField, String orderSort, Map<String, Object> filters) {
		1007	return vendaRepository.consultarVendasPorDemanda(parametrosConsulta, primeiroRegistro, tamanhoPagina, sortField, orderSort, filters);
		1008	}
		1009
		1010	@Override
		1011	public List<Venda> consultarVendaPorParametros(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1012	return vendaRepository.consultarVendaPorParametros(parametrosConsultaVendas);
		1013	}
		1014
		1015	@Override
		1016	public GraficoAcumuladoDTO consultarGrafico(String mes, String ano) {
		1017	return vendaRepository.consultarGrafico(mes, ano);
		1018	}
		1019
		1020	@Override
		1021	public List<RankingVendedorDTO> consultarRankingVendedores(Date dataInicial, Date dataFinal, Boolean produtosComissionados, Loja lojaSelecionada) {
		1022	List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
		1023	List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradoresAtivos(lojaSelecionada);
		1024	for (Vendedor vendedor : vendedores) {
		1025	RankingVendedorDTO vendedorConsultado = consultarRankingVendedor(vendedor, dataInicial, dataFinal, produtosComissionados);
		1026	rankingVendedores.add(vendedorConsultado);
		1027	}
		1028	return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
		1029	}
		1030
		1031	@Override
		1032	public RankingVendedorDTO consultarRankingVendedor(Vendedor vendedor, Vigencia vigencia, Boolean produtosComissionados) {
		1033	Avaliacao avaliacao = avaliacaoService.consultarAvaliacaoDaVigencia(vigencia);
		1034	RankingVendedorDTO rankingVendedor = consultarRankingVendedor(vendedor, vigencia.getDataInicio(), vigencia.getDataFim(), produtosComissionados);
		1035	rankingVendedor.setFuncionario(funcionarioService.consultarFuncionarioPorPessoa(vendedor.getPessoa()));
		1036	rankingVendedor.setQuantidadeBancoHoras(bancoHorasService.consultarQuantidadeHoras(rankingVendedor.getFuncionario()));
		1037	AvaliacaoFuncionario avaliacaoFuncionario = avaliacaoFuncionarioService.detalhar(vendedor.getPessoa(), avaliacao);
		1038	if (VerificadorUtil.naoEstaNuloOuVazio(avaliacaoFuncionario)) {
		1039	rankingVendedor.setAvaliacaoFuncionario(avaliacaoFuncionario);
337	espaco	1040	rankingVendedor.setPontuacaoGeral(avaliacaoFuncionario.getPontuacao());
149	espaco	1041	if (VerificadorUtil.naoEstaNulo(avaliacaoFuncionario.getPorcentagemComissao())) {
		1042	rankingVendedor.setComissao(calcularComissao(rankingVendedor.getValorTotalVendido(), avaliacaoFuncionario.getPorcentagemComissao()/100));
		1043	} else {
		1044	rankingVendedor.setComissao(calcularComissao(rankingVendedor.getValorTotalVendido(), avaliacaoFuncionario.retornarFaixaComissao(rankingVendedor.getValorTotalVendido(), rankingVendedor.getFuncionario().getTipoComissionamento())));
		1045	}
		1046	}
		1047	return rankingVendedor;
		1048	}
		1049
		1050	public Double calcularComissao(Double valorTotalVendido, Double porcentagemComissao) {
		1051	if (VerificadorUtil.naoEstaNuloOuVazio(porcentagemComissao)) {
		1052	return valorTotalVendido * porcentagemComissao;
		1053	}
		1054	return 0.0;
		1055	}
		1056
		1057	@Override
		1058	public RankingVendedorDTO consultarRankingVendedor(Vendedor vendedor, Date dataInicial, Date dataFinal, Boolean produtosComissionados) {
		1059	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1060	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1061	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1062	parametrosConsultaVendas.setVendedor(vendedor);
		1063	if (VerificadorUtil.naoEstaNulo(produtosComissionados)) {
		1064	parametrosConsultaVendas.setIndicadorComissionado(produtosComissionados);
		1065	}
		1066
		1067	RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
		1068	rankingVendedor.setVendedor(vendedor);
		1069	try {
		1070	rankingVendedor.setFuncionario(funcionarioService.consultarFuncionarioPorPessoa(vendedor.getPessoa()));
		1071	rankingVendedor.setQuantidadeBancoHoras(bancoHorasService.consultarQuantidadeHoras(rankingVendedor.getFuncionario()));
		1072	} catch (RuntimeException e) {
		1073	rankingVendedor.setFuncionario(null);
		1074	}
		1075
		1076	rankingVendedor.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas));
		1077	rankingVendedor.setValorTotalDescontos(obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsultaVendas));
		1078	rankingVendedor.setQuantidadeTotalProdutosVendidos(obterQuantidadeProdutosVendidosPorLojaEePeriodo(parametrosConsultaVendas));
		1079
		1080	Venda venda = new Venda();
		1081	venda.setVendedor(vendedor);
		1082	rankingVendedor.setQuantidadeVendas(obterQuantidadeDeVendasPorLojaEePeriodo(venda, dataInicial, dataFinal));
		1083	rankingVendedor.setQuantidadePedidos(obterQuantidadePedidosValidos(vendedor, null, dataInicial, dataFinal));
		1084	rankingVendedor.setQuantidadePedidosInvalidos(obterQuantidadePedidos(vendedor, null, dataInicial, dataFinal, TipoSituacaoPedido.INVALIDO.getValor()));
		1085	rankingVendedor.setQuantidadeContagens(obterQuantidadeDeContagens(vendedor, dataInicial, dataFinal));
		1086	rankingVendedor.setQuantidadeAtendimentos(obterQuantidadeDeAtendimentos(vendedor, dataInicial, dataFinal));
		1087	rankingVendedor.setValorTotalVendidoVivo(obterValorTotalBrutoDeVendasVivoPorLojaEePeriodo(parametrosConsultaVendas));
		1088
		1089	rankingVendedor.setAvaliacaoFuncionario(avaliacaoFuncionarioService.consultarAvaliacaoFuncionarioPelaData(vendedor, DataUtils.getDataComHorarioMinimo(dataFinal)));
		1090	if (VerificadorUtil.naoEstaNulo(rankingVendedor.getAvaliacaoFuncionario())) {
		1091	rankingVendedor.setPercentualDescontos(rankingVendedor.getAvaliacaoFuncionario().retornarPercentual(rankingVendedor.getValorTotalDescontos(), rankingVendedor.getValorTotalVendido()));
		1092	rankingVendedor.setPercentualMetaMensal(rankingVendedor.getAvaliacaoFuncionario().retornarPercentualRealizado(rankingVendedor.getValorTotalVendido()));
		1093	rankingVendedor.setPercentualMetaMensalVivo(rankingVendedor.getAvaliacaoFuncionario().retornarPercentualVivoRealizado(rankingVendedor.getValorTotalVendidoVivo()));
333	espaco	1094	rankingVendedor.setPercentualMetaTicketMedio(rankingVendedor.getAvaliacaoFuncionario().retornarPercentualTicketMedioRealizado(rankingVendedor.getTicketMedio()));
149	espaco	1095	}
		1096
		1097	ParametrosConsultaVendasDTO parametrosConsultaVendasDoDia = new ParametrosConsultaVendasDTO();
		1098	parametrosConsultaVendasDoDia.setDataInicial(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()));
		1099	parametrosConsultaVendasDoDia.setDataFinal(DataUtils.getDataComHorarioMaximo(DataUtils.getDataAtual()));
		1100	parametrosConsultaVendasDoDia.setVendedor(vendedor);
		1101	if (VerificadorUtil.naoEstaNulo(produtosComissionados)) {
		1102	parametrosConsultaVendasDoDia.setIndicadorComissionado(produtosComissionados);
		1103	}
		1104	rankingVendedor.setValorTotalVendidoDoDia(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendasDoDia));
		1105
		1106	return rankingVendedor;
		1107	}
		1108
		1109	private Integer obterQuantidadePedidos(Vendedor vendedor, Loja loja, Date dataInicial, Date dataFinal, String tipoSituacao) {
		1110	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1111	if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
		1112	return 0;
		1113	}
		1114	}
		1115	ParametrosConsultaPedidoDTO parametrosPedidos = new ParametrosConsultaPedidoDTO();
		1116	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1117	parametrosPedidos.setPessoa(vendedor.getPessoa());
		1118	}
		1119	parametrosPedidos.setEntidade(new Pedido());
		1120	parametrosPedidos.getEntidade().setTipoSituacao(tipoSituacao);
		1121	parametrosPedidos.getEntidade().setLoja(loja);
		1122	parametrosPedidos.setDataInicial(dataInicial);
		1123	parametrosPedidos.setDataFinal(dataFinal);
		1124	return pedidoService.obterQuantidadeDeRegistrosParametrosConsulta(parametrosPedidos);
		1125	}
		1126
		1127	private Integer obterQuantidadePedidosValidos(Vendedor vendedor, Loja loja, Date dataInicial, Date dataFinal) {
		1128	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1129	if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
		1130	return 0;
		1131	}
		1132	}
		1133	ParametrosConsultaPedidoDTO parametrosPedidos = new ParametrosConsultaPedidoDTO();
		1134	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1135	parametrosPedidos.setPessoa(vendedor.getPessoa());
		1136	}
		1137	parametrosPedidos.setEntidade(new Pedido());
		1138	parametrosPedidos.getEntidade().setLoja(loja);
		1139	parametrosPedidos.setDataInicial(dataInicial);
		1140	parametrosPedidos.setDataFinal(dataFinal);
		1141	parametrosPedidos.setValidos(true);
		1142	return pedidoService.obterQuantidadeDeRegistrosParametrosConsulta(parametrosPedidos);
		1143	}
		1144
		1145	private Integer obterQuantidadeDeContagens(Vendedor vendedor, Date dataInicial, Date dataFinal) {
		1146	if (VerificadorUtil.naoEstaNulo(vendedor)) {
		1147	if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
		1148	return 0;
		1149	}
		1150	}
		1151	return produtoLojaService.obterQuantidadeDeContagens(vendedor.getPessoa(), dataInicial, dataFinal);
		1152	}
		1153
		1154	private Integer obterQuantidadeDeAtendimentos(Vendedor vendedor, Date dataInicial, Date dataFinal) {
		1155	if (VerificadorUtil.estaNulo(vendedor.getPessoa())) {
		1156	return 0;
		1157	}
		1158	return produtoLojaService.obterQuantidadeDeAtendimentos(vendedor.getPessoa(), dataInicial, dataFinal);
		1159	}
		1160
		1161	private Integer obterQuantidadeDeAtendimentos(Loja loja, Date dataInicial, Date dataFinal) {
		1162	return produtoLojaService.obterQuantidadeDeAtendimentos(loja, dataInicial, dataFinal);
		1163	}
		1164
		1165	private Double obterValorTotalBrutoDeVendasVivoPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1166	ParametrosConsultaVendasVivoDTO parametrosConsultaVendasVivo = new ParametrosConsultaVendasVivoDTO();
		1167	parametrosConsultaVendasVivo.setVendedor(parametrosConsultaVendas.getVendedor());
		1168	parametrosConsultaVendasVivo.setDataInicial(parametrosConsultaVendas.getDataInicial());
		1169	parametrosConsultaVendasVivo.setDataFinal(parametrosConsultaVendas.getDataFinal());
		1170	return vendaVivoService.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendasVivo);
		1171	}
		1172
		1173	@Override
		1174	public List<RankingLojaDTO> consultarRankingLojas(Date dataInicial, Date dataFinal) {
		1175	List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
		1176	List<Loja> lojas = lojaService.listarLojasAtivas();
		1177	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1178	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1179	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1180	for (Loja loja : lojas) {
		1181	if (!loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)
		1182	&& !loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_RESTAURANTE_16)) {
		1183	parametrosConsultaVendas.setLoja(loja);
		1184
		1185	RankingLojaDTO rankingLoja = new RankingLojaDTO();
		1186	rankingLoja.setLoja(loja);
		1187	rankingLoja.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas)
		1188	- obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
		1189	rankingLoja.setAvaliacaoLoja(avaliacaoLojaService.consultarAvaliacaoLojaPelaData(loja, DataUtils.getDataComHorarioMinimo(dataFinal)));
		1190	if (VerificadorUtil.naoEstaNulo(rankingLoja.getAvaliacaoLoja())) {
		1191	rankingLoja.setValorMetaMensal(rankingLoja.getAvaliacaoLoja().getValorMetaMensal());
		1192	}
		1193	rankingLojas.add(rankingLoja);
		1194	}
		1195	}
		1196	return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojas);
		1197	}
		1198
		1199	@Override
		1200	public List<RankingLojaDTO> consultarRankingLojasCompleto(Date dataInicial, Date dataFinal) {
		1201	List<RankingLojaDTO> rankingLojasCompleto = new ArrayList<RankingLojaDTO>();
		1202	List<RankingLojaDTO> rankingLojas = consultarRankingLojas(dataInicial, dataFinal);
		1203	for (RankingLojaDTO rankingLoja : rankingLojas) {
		1204	rankingLoja.setQuantidadeVendas(obterQuantidadeDeVendasPorLojaEePeriodo(new Venda(rankingLoja.getLoja(), null), dataInicial, dataFinal));
		1205	rankingLoja.setQuantidadeAtendimentos(obterQuantidadeDeAtendimentos(rankingLoja.getLoja(), dataInicial, dataFinal));
		1206	rankingLoja.setQuantidadePedidos(obterQuantidadePedidosValidos(null, rankingLoja.getLoja(), dataInicial, dataFinal));
		1207	rankingLoja.setQuantidadePedidosInvalidos(obterQuantidadePedidos(null, rankingLoja.getLoja(), dataInicial, dataFinal, TipoSituacaoPedido.INVALIDO.getValor()));
		1208
		1209	ParametrosConsultaPorPeriodoDTO parametrosConsulta = new ParametrosConsultaPorPeriodoDTO();
		1210	((ParametrosConsultaPorPeriodoDTO)parametrosConsulta).setDataInicial(dataInicial);
		1211	((ParametrosConsultaPorPeriodoDTO)parametrosConsulta).setDataFinal(dataFinal);
		1212	EstoqueAuditoria estoqueAuditoria = new EstoqueAuditoria();
		1213	estoqueAuditoria.setLoja(rankingLoja.getLoja());
		1214	estoqueAuditoria.setTipoEstoqueAuditoria(TipoEstoqueAuditoria.AVARIA.getValor());
		1215	parametrosConsulta.setEntidade(estoqueAuditoria);
		1216	rankingLoja.setQuantidadeAvarias(estoqueAuditoriaService.obterQuantidadeTotalAuditoria(parametrosConsulta));
		1217
		1218	estoqueAuditoria.setTipoEstoqueAuditoria(TipoEstoqueAuditoria.TROCA.getValor());
		1219	parametrosConsulta.setEntidade(estoqueAuditoria);
		1220	rankingLoja.setQuantidadeTrocas(estoqueAuditoriaService.obterQuantidadeTotalAuditoria(parametrosConsulta));
		1221
		1222	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1223	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1224	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1225	parametrosConsultaVendas.setLoja(rankingLoja.getLoja());
		1226	rankingLoja.setValorTotalDescontos(obterValorTotalDeDescontosPorLojaEePeriodo(parametrosConsultaVendas));
		1227	rankingLoja.setCustoProdutosVendidos(obterValorProdutosUtilizadosEmVendasPorLojaEePeriodo(parametrosConsultaVendas));
		1228	rankingLoja.setValorTotalEstoque(produtoService.valorTotalEstoque(rankingLoja.getLoja(), null));
		1229	rankingLoja.setQuantidadeTotalEstoque(produtoService.quantidadeTotalEstoque(rankingLoja.getLoja()));
		1230
		1231	ParametrosConsultaLancamentosDTO parametros = new ParametrosConsultaLancamentosDTO();
		1232	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_ALUGUEL_11));
		1233	parametros.setCentroDeCustos(rankingLoja.getLoja());
		1234	parametros.setPagamentoRealizado(true);
		1235	parametros.setDataInicial(dataInicial);
		1236	parametros.setDataFinal(dataFinal);
		1237	Double valorCac = 0.0;
		1238
		1239	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1240	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_HORA_EXTRA_2));
		1241	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1242	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_SALARIO_9));
		1243	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1244	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_FERIAS_12));
		1245	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1246	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_COMISSOES_8));
		1247	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1248	parametros.setCategoria(new Categoria(ConstantesSEC.Categoria.SEQUENCIAL_CATEGORIA_VALE_TRANSPORTE_46));
		1249	valorCac = somarValor(valorCac, parcelaService.obterValorPassandoParametrosConsulta(parametros));
		1250	valorCac = valorCac / rankingLoja.getQuantidadeVendas();
		1251	rankingLoja.setValorCac(valorCac);
		1252
		1253	rankingLojasCompleto.add(rankingLoja);
		1254	}
		1255	return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojasCompleto);
		1256	}
		1257
		1258	private Double somarValor(Double valor, Double valorAcrescentar) {
		1259	if (VerificadorUtil.naoEstaNulo(valorAcrescentar)) {
		1260	return valor + valorAcrescentar;
		1261	}
		1262	return valor;
		1263	}
		1264
		1265	@Override
		1266	public List<RankingLojaDTO> consultarRankingLojasExtras(Date dataInicial, Date dataFinal) {
		1267	List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
164	espaco	1268
149	espaco	1269	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1270	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1271	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
164	espaco	1272	// rankingLojas.addAll(preenchendoLojasExtras(parametrosConsultaVendas));
		1273
		1274	parametrosConsultaVendas.setLoja(null);
		1275	// rankingLojas.add(preencherLojaAssistencia(parametrosConsultaVendas));
		1276
		1277	return (List<RankingLojaDTO>) ordenador.ordenar(rankingLojas);
		1278	}
		1279
		1280	private RankingLojaDTO preencherLojaAssistencia(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1281	RankingLojaDTO rankingLojaServico = new RankingLojaDTO();
		1282	Loja lojaServico = new Loja();
		1283	lojaServico.setDescricao("ASSISTÊNCIA");
		1284	rankingLojaServico.setValorMetaMensal(new Double(0.0));
		1285	rankingLojaServico.setLoja(lojaServico);
		1286	rankingLojaServico.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
		1287	return rankingLojaServico;
		1288	}
		1289
		1290	private RankingLojaDTO preencherVendasComPedidos(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1291	RankingLojaDTO rankingLojaServico = new RankingLojaDTO();
		1292	Loja lojaServico = new Loja();
		1293	lojaServico.setDescricao("E-COMMERCE");
		1294	rankingLojaServico.setValorMetaMensal(new Double(0.0));
		1295	rankingLojaServico.setLoja(lojaServico);
		1296	rankingLojaServico.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
		1297	return rankingLojaServico;
		1298	}
		1299
		1300	private List<RankingLojaDTO> preenchendoLojasExtras(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1301	List<RankingLojaDTO> rankingLojas = new ArrayList<RankingLojaDTO>();
		1302	List<Loja> lojas = lojaService.listarLojasAtivas();
149	espaco	1303	for (Loja loja : lojas) {
		1304	if (loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_LOJA_FARMACIA_7)
		1305	\|\| loja.getSequencial().equals(ConstantesSEC.SEQUENCIAL_RESTAURANTE_16)) {
		1306	parametrosConsultaVendas.setLoja(loja);
		1307
		1308	RankingLojaDTO rankingLoja = new RankingLojaDTO();
		1309	rankingLoja.setLoja(loja);
		1310	rankingLoja.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas)
		1311	- obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(parametrosConsultaVendas));
164	espaco	1312	rankingLoja.setAvaliacaoLoja(avaliacaoLojaService.consultarAvaliacaoLojaPelaData(loja, DataUtils.getDataComHorarioMinimo(parametrosConsultaVendas.getDataFinal())));
149	espaco	1313	if (VerificadorUtil.naoEstaNulo(rankingLoja.getAvaliacaoLoja())) {
		1314	rankingLoja.setValorMetaMensal(rankingLoja.getAvaliacaoLoja().getValorMetaMensal());
		1315	}
		1316	rankingLojas.add(rankingLoja);
		1317	}
		1318	}
164	espaco	1319	return rankingLojas;
149	espaco	1320	}
		1321
		1322	@Override
		1323	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodoServicos(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		1324	parametrosConsultaVendas.setTipoProduto(TipoProduto.SERVICO.getValor());
		1325	Double valorTotal = vendaRepository.obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas);
		1326	parametrosConsultaVendas.setTipoProduto(null);
		1327	return VerificadorUtil.estaNulo(valorTotal)? new Double(0.0) : valorTotal;
		1328	}
		1329
		1330	@Override
		1331	public List<RankingProdutoDTO> consultarProdutosVendidos(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1332	List<RankingProdutoDTO> produtosVendidosConsultados = vendaRepository.consultarProdutosVendidos(parametrosConsulta);
		1333	for (RankingProdutoDTO produtoVendido : produtosVendidosConsultados) {
		1334	produtoVendido.atualizarTempoEstoque(parametrosConsulta.getDataInicial(), parametrosConsulta.getDataFinal());
		1335	}
		1336	return produtosVendidosConsultados;
		1337	}
		1338
		1339	@Override
		1340	public List<RankingProdutoDTO> consultarProdutosVendidosResumido(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1341	return vendaRepository.consultarProdutosVendidosResumido(parametrosConsulta);
		1342	}
		1343
		1344	@Override
		1345	public List<RankingProdutoDTO> consultarProdutosParaTransferir(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1346	return vendaRepository.consultarProdutosParaTransferir(parametrosConsulta);
		1347	}
		1348
		1349	@Override
		1350	public List<RankingProdutoDTO> consultarRankingProdutos(Date dataInicial, Date dataFinal, Integer quantidadeProdutos, String tipoOrdenacao, Long sequencialLoja, String tipoProduto, Produto produto, Marca marca) {
		1351	return vendaRepository.consultarProdutosMaisVendidos(dataInicial, dataFinal, quantidadeProdutos, tipoOrdenacao, sequencialLoja, tipoProduto, produto, marca);
		1352	}
		1353
		1354	@Override
		1355	public List<RankingModeloDTO> consultarRankingModelos(ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta) {
		1356	return vendaRepository.consultarModelosMaisVendidos(parametrosConsulta);
		1357	}
		1358
		1359	@Override
		1360	public List<RankingModeloDTO> consultarRankingModelos(Date dataInicial, Date dataFinal, Integer quantidadeModelos, String tipoOrdenacao, String tipoProduto, Long sequencialLoja) {
151	espaco	1361	ParametrosConsultaModelosMaisVendidosDTO parametros = new ParametrosConsultaModelosMaisVendidosDTO(dataInicial, dataFinal, quantidadeModelos, tipoOrdenacao, tipoProduto, sequencialLoja);
		1362	return this.consultarRankingModelos(parametros);
149	espaco	1363	}
		1364
		1365	@Override
		1366	public List<RankingComprasTransferenciasDTO> consultarPlanejamentoParaCompras(ParametrosConsultaParaComprasTransferenciasDTO parametrosParaConsulta) {
		1367	Integer limite = parametrosParaConsulta.getQuantidadeModelos();
		1368	if (parametrosParaConsulta.getIndicadorConsultarTodosModelos()) {
		1369	limite = null;
		1370	}
		1371	List<RankingComprasTransferenciasDTO> planejamentos = new ArrayList<RankingComprasTransferenciasDTO>();
		1372	ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta = new ParametrosConsultaModelosMaisVendidosDTO(parametrosParaConsulta.getDataInicial(), parametrosParaConsulta.getDataFinal(), limite,
		1373	parametrosParaConsulta.getTipoOrdenacao(), parametrosParaConsulta.getTipoProduto(), parametrosParaConsulta.getSequencialLoja(), parametrosParaConsulta.getModelo(), parametrosParaConsulta.getEstilo());
		1374	List<RankingModeloDTO> modelos = vendaRepository.consultarModelosMaisVendidos(parametrosConsulta);
		1375	for (RankingModeloDTO modelo : modelos) {
		1376	RankingComprasTransferenciasDTO planejamento = new RankingComprasTransferenciasDTO();
		1377	planejamento.setModelo(modelo.getModelo());
		1378	planejamento.setValorTotalVendido(modelo.getValorTotalVendido());
		1379	planejamento.setValorTotalComprado(modelo.getValorTotalComprado());
		1380	planejamento.setQuantidadeVendas(modelo.getQuantidadeVendas());
		1381	planejamento.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
		1382	if (VerificadorUtil.naoEstaNuloOuVazio(modelo.getQuantidadeEstoqueLocal())) {
		1383	planejamento.setQuantidadeEstoqueLocal(modelo.getQuantidadeEstoqueLocal().intValue());
		1384	}
		1385	planejamento.setQuantidadeEstoqueGeral(modelo.getQuantidadeEstoqueGeral().intValue());
		1386	planejamentos.add(planejamento);
		1387	}
		1388
		1389	if (parametrosParaConsulta.getIndicadorConsultarTodosModelos()) {
		1390	List<Modelo> modelosAtivos = new ArrayList<Modelo>();
		1391	if (VerificadorUtil.estaNulo(parametrosParaConsulta.getModelo())) {
		1392	modelosAtivos = modeloService.consultarTodosAtivos();
		1393	} else {
		1394	modelosAtivos = modeloService.consultarPassandoEntidade(parametrosParaConsulta.getModelo(), 0, modeloService.obterQuantidadeDeRegistrosPassandoEntidade(parametrosParaConsulta.getModelo()));
		1395	}
		1396	for (Modelo modeloAtivo : modelosAtivos) {
		1397	if (modeloNaoEstaPresenteNaLista(modelos, modeloAtivo)) {
		1398	RankingComprasTransferenciasDTO planejamento = new RankingComprasTransferenciasDTO();
		1399	planejamento.setModelo(modeloAtivo);
		1400	planejamento.setValorTotalVendido(new Double(0.0));
		1401	planejamento.setValorTotalComprado(new Double(0.0));
		1402	planejamento.setQuantidadeVendas(new Long(0));
		1403	planejamento.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
		1404	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosParaConsulta.getSequencialLoja())) {
		1405	planejamento.setQuantidadeEstoqueLocal(produtoLojaService.consultarEstoqueModeloEeLoja(modeloAtivo, parametrosParaConsulta.getSequencialLoja(), null, parametrosParaConsulta.getTipoProduto(), null, null));
		1406	}
		1407	planejamento.setQuantidadeEstoqueGeral(produtoLojaService.consultarEstoqueModeloEeLoja(modeloAtivo, null, null, parametrosParaConsulta.getTipoProduto(), null, null));
		1408	if (planejamento.getQuantidadeEstoqueGeral() > 0) {
		1409	planejamentos.add(planejamento);
		1410	}
		1411	}
		1412	}
		1413	}
		1414
		1415	if (parametrosParaConsulta.getTipoOrdenacao().equals(TipoOrdenacaoPlanejamentoCompras.QUANTIDADE_COMPRAR.getValor())) {
		1416	return new ArrayList<RankingComprasTransferenciasDTO>(ordenador.ordenar(planejamentos));
		1417	}
		1418	return planejamentos;
		1419	}
		1420
		1421	private Boolean modeloNaoEstaPresenteNaLista(List<RankingModeloDTO> rankingModelos, Modelo modeloAtivo) {
		1422	for (RankingModeloDTO rankingModelo : rankingModelos) {
		1423	if (rankingModelo.getModelo().getSequencial().equals(modeloAtivo.getSequencial())) {
		1424	return false;
		1425	}
		1426	}
		1427	return true;
		1428	}
		1429
		1430	@Override
		1431	public List<RankingComprasTransferenciasEstiloDTO> consultarDetalhamentoPlanejamentoParaCompras(ParametrosConsultaParaComprasTransferenciasDTO parametrosParaConsulta, Modelo modelo) {
600	blopes	1432	List<RankingComprasTransferenciasEstiloDTO> consulta = new ArrayList<RankingComprasTransferenciasEstiloDTO>();
149	espaco	1433	for (TipoEstiloProduto estiloProduto : TipoEstiloProduto.values()) {
		1434	parametrosParaConsulta.setEstilo(StringUtil.setarUpperCase(estiloProduto.getValor()));
602	blopes	1435	parametrosParaConsulta.setSubtipo(null);
149	espaco	1436	RankingComprasTransferenciasEstiloDTO estilo = vendaRepository.consultarEstoqueEeVendasPorEstilo(parametrosParaConsulta, modelo);
		1437	estilo.setRankingsPorLoja(vendaRepository.consultarEstoqueEeVendasEstiloPorLoja(parametrosParaConsulta, modelo));
		1438	estilo.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
600	blopes	1439	consulta.add(estilo);
149	espaco	1440	}
600	blopes	1441	return consulta;
149	espaco	1442	}
600	blopes	1443
		1444	@Override
		1445	public List<RankingComprasTransferenciasSubtipoProdutoDTO> consultarDetalhamentoPlanejamentoParaCompras(List<SubtipoProduto> subtiposParaConsultar, ParametrosConsultaParaComprasTransferenciasDTO parametrosParaConsulta, Modelo modelo) {
		1446	List<RankingComprasTransferenciasSubtipoProdutoDTO> consulta = new ArrayList<RankingComprasTransferenciasSubtipoProdutoDTO>();
		1447	for (SubtipoProduto subtipoProduto : subtiposParaConsultar) {
		1448	parametrosParaConsulta.setSubtipo(subtipoProduto);
602	blopes	1449	parametrosParaConsulta.setEstilo(null);;
600	blopes	1450	RankingComprasTransferenciasSubtipoProdutoDTO subtipo = vendaRepository.consultarEstoqueEeVendasPorSubtipo(parametrosParaConsulta, modelo);
		1451	subtipo.setRankingsPorLoja(vendaRepository.consultarEstoqueEeVendasSubtipoPorLoja(parametrosParaConsulta, modelo));
		1452	subtipo.setQuantidadeMinimaComprar(parametrosParaConsulta.getQuantidadeMinimaComprar());
		1453	consulta.add(subtipo);
		1454	}
		1455	return consulta;
		1456	}
149	espaco	1457
		1458	@Override
356	espaco	1459	public List<RankingVendedorDTO> consultarRankingPromocaoInterna(Date dataInicial, Date dataFinal) {
149	espaco	1460	List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
356	espaco	1461	Vigencia vigencia = vigenciaService.consultarVigenciaDoPeriodo(dataInicial);
		1462	if (VerificadorUtil.naoEstaNulo(vigencia)) {
		1463	Avaliacao avaliacao = avaliacaoService.consultarAvaliacaoDaVigencia(vigencia);
		1464	if (VerificadorUtil.naoEstaNulo(avaliacao)) {
		1465	List<AvaliacaoProduto> produtosAvaliacaoPromocaoInterna = avaliacaoService.consultarProdutosPromocaoInterna(avaliacao.getSequencial());
		1466	List<Produto> produtosPromocaoInterna = new ArrayList<Produto>();
		1467	for (AvaliacaoProduto produtoAvaliacaoPromocaoInterna : produtosAvaliacaoPromocaoInterna) {
		1468	produtosPromocaoInterna.add(produtoAvaliacaoPromocaoInterna.getProduto());
		1469	}
		1470
		1471	List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradoresAtivos(null);
		1472	for (Vendedor vendedor : vendedores) {
		1473	RankingVendedorDTO ranking = consultarRankingPromocaoInternaDoVendedor(vendedor, dataInicial, dataFinal, produtosPromocaoInterna);
422	blopes	1474	rankingVendedores.add(ranking);
356	espaco	1475	}
149	espaco	1476	}
		1477	}
		1478	return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
		1479	}
		1480
		1481	@Override
252	espaco	1482	public RankingVendedorDTO consultarRankingPromocaoInternaDoVendedor(Vendedor vendedor, Date dataInicial, Date dataFinal,
356	espaco	1483	List<Produto> produtosPromocaoInterna) {
149	espaco	1484	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1485	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1486	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1487	parametrosConsultaVendas.setVendedor(vendedor);
		1488	RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
		1489	rankingVendedor.setVendedor(vendedor);
		1490
252	espaco	1491	parametrosConsultaVendas.setProdutosPromocaoInterna(produtosPromocaoInterna);
		1492	rankingVendedor.setQuantidadeProdutosPromocaoInterna(lancamentoService.obterQuantidadeVendasDosProdutosDaPromocaoInterna(parametrosConsultaVendas));
		1493
		1494	parametrosConsultaVendas.setProdutosPromocaoInterna(null);
		1495	parametrosConsultaVendas.setIndicadorPesquisarPeliculasTpuSoft(true);
		1496	parametrosConsultaVendas.setIndicadorPesquisarPeliculasTpuSoftCameras(false);
		1497	rankingVendedor.setQuantidadeTpuSoftNormal(lancamentoService.obterQuantidadeVendasDosProdutosDaPromocaoInterna(parametrosConsultaVendas));
		1498
		1499	parametrosConsultaVendas.setProdutosPromocaoInterna(null);
		1500	parametrosConsultaVendas.setIndicadorPesquisarPeliculasTpuSoft(true);
		1501	parametrosConsultaVendas.setIndicadorPesquisarPeliculasTpuSoftCameras(true);
		1502	rankingVendedor.setQuantidadeTpuSoftCamera(lancamentoService.obterQuantidadeVendasDosProdutosDaPromocaoInterna(parametrosConsultaVendas));
		1503
149	espaco	1504	// if (rankingVendedor.getQuantidadePedidos() >= ConstantesSEC.ProdutosPromocaoInterna.QUANTIDADE_MINIMA_RECEBIMENTO) {
		1505	rankingVendedor.setValorTotalVendido(lancamentoService.obterValorTotalVendidoDosProdutosDaPromocaoInterna(parametrosConsultaVendas) * ConstantesSEC.ProdutosPromocaoInterna.PERCENTUAL);
		1506	// } else {
		1507	// rankingVendedor.setValorTotalVendido(new Double(0.0));
		1508	// }
		1509
		1510	ParametrosConsultaVendasDTO parametrosConsultaVendasDoDia = new ParametrosConsultaVendasDTO();
		1511	parametrosConsultaVendasDoDia.setDataInicial(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()));
		1512	parametrosConsultaVendasDoDia.setDataFinal(DataUtils.getDataComHorarioMaximo(DataUtils.getDataAtual()));
		1513	parametrosConsultaVendasDoDia.setVendedor(vendedor);
		1514	rankingVendedor.setValorTotalVendidoDoDia(lancamentoService.obterValorTotalVendidoDosProdutosDaPromocaoInterna(parametrosConsultaVendasDoDia));
		1515	return rankingVendedor;
		1516	}
		1517
		1518	@Override
		1519	public List<VendasDTO> consultarVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
		1520	return vendaRepository.consultarVendas(parametrosConsultaVendasDTO);
		1521	}
		1522
		1523	/*
		1524	@Override
		1525	public List<RankingVendedorDTO> consultarRankingVendedores(Date dataInicial, Date dataFinal) {
		1526	List<RankingVendedorDTO> rankingVendedores = new ArrayList<RankingVendedorDTO>();
		1527	List<Vendedor> vendedores = vendedorService.consultarVendedoresColaboradores();
		1528	for (Vendedor vendedor : vendedores) {
		1529	ParametrosConsultaVendasDTO parametrosConsultaVendas = new ParametrosConsultaVendasDTO();
		1530	parametrosConsultaVendas.setDataInicial(DataUtils.getDataComHorarioMinimo(dataInicial));
		1531	parametrosConsultaVendas.setDataFinal(DataUtils.getDataComHorarioMaximo(dataFinal));
		1532	parametrosConsultaVendas.setVendedor(vendedor);
		1533	RankingVendedorDTO rankingVendedor = new RankingVendedorDTO();
		1534	rankingVendedor.setVendedor(vendedor);
		1535	rankingVendedor.setValorTotalVendido(obterValorTotalBrutoDeVendasPorLojaEePeriodo(parametrosConsultaVendas));
		1536	rankingVendedor.setQuantidadePedidos(obterQuantidadePedidos(vendedor, dataInicial, dataFinal));
		1537	rankingVendedores.add(rankingVendedor);
		1538	}
		1539	return (List<RankingVendedorDTO>) ordenador.ordenar(rankingVendedores);
		1540	}
		1541	*/
		1542
		1543	}

Subversion Repositories Integrator Subversion

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