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

Subversion Repositories Integrator Subversion

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