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

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

Subversion Repositories Integrator Subversion

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