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

Subversion Repositories Integrator Subversion

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