WebSVN - Integrator Subversion - Blame - Rev 450 - /projeto-novo/espacocase-novo/src/main/java/br/com/ec/repository/jpa/VendaRepositoryJpaImpl.java

Rev	Author	Line No.	Line
229	espaco	1	package br.com.ec.repository.jpa;
		2
		3	import java.util.Date;
261	espaco	4	import java.util.List;
229	espaco	5
230	espaco	6	import javax.persistence.Query;
229	espaco	7	import javax.persistence.TypedQuery;
		8
		9	import org.springframework.stereotype.Repository;
		10
		11	import br.com.ec.core.util.DataUtils;
230	espaco	12	import br.com.ec.core.util.VerificadorUtil;
450	blopes	13	import br.com.ec.domain.dto.AuditoriaVendaDTO;
261	espaco	14	import br.com.ec.domain.dto.FormaPagamentoDTO;
264	espaco	15	import br.com.ec.domain.dto.LojaDTO;
230	espaco	16	import br.com.ec.domain.dto.consulta.ParametrosConsultaVendasDTO;
259	espaco	17	import br.com.ec.domain.model.Venda;
261	espaco	18	import br.com.ec.domain.shared.ConstantesSEC;
229	espaco	19	import br.com.ec.repository.SistemaAbstractRepository;
		20	import br.com.ec.repository.VendaRepository;
		21
		22	@Repository
		23	public class VendaRepositoryJpaImpl extends SistemaAbstractRepository<Venda> implements VendaRepository {
		24
		25	@Override
		26	protected String getColunaOrdenadora() {
		27	return "dataVenda";
		28	}
		29
		30	@Override
296	espaco	31	public Integer obterQuantidadeDeVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
229	espaco	32	StringBuilder sql = new StringBuilder();
296	espaco	33	sql.append("SELECT COUNT(*) FROM Venda e ");
230	espaco	34	sql.append("WHERE 1=1 ");
		35	setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
229	espaco	36	try {
230	espaco	37	TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
		38	setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
		39	return query.getSingleResult().intValue();
229	espaco	40	} catch(Exception ex) {
		41	ex.printStackTrace();
		42	return null;
		43	}
		44	}
		45
230	espaco	46	@Override
296	espaco	47	public Double obterValorTotalBrutoDeVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
230	espaco	48	StringBuilder sql = new StringBuilder();
296	espaco	49	sql.append("SELECT SUM(l.valorVenda) FROM Venda e ");
		50	sql.append("LEFT JOIN e.listaLancamentos l ");
230	espaco	51	sql.append("WHERE l.ativo IS TRUE ");
		52	setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
		53	try {
		54	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
		55	setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
		56	Double total = query.getSingleResult();
		57	if (VerificadorUtil.estaNulo(total)) {
		58	return new Double(0.0);
		59	}
		60	return total;
		61	} catch(Exception ex) {
		62	ex.printStackTrace();
		63	return null;
		64	}
		65	}
		66
		67	@Override
		68	public Double obterValorDeCuponsUtilizadosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
		69	StringBuilder sql = new StringBuilder();
268	espaco	70	sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
296	espaco	71	sql.append("LEFT JOIN vp.venda e ");
268	espaco	72	sql.append("WHERE vp.formaPagamento.codigo = 16 ");
230	espaco	73	setarStringParametrosConsulta(sql, parametrosConsultaVendasDTO);
		74	// parametrosConsulta.setIndicadorComissionado(null);
		75	// parametrosConsulta.setTipoProduto(null);
		76	try {
		77	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
		78	setarQueryParametrosConsulta(query, parametrosConsultaVendasDTO);
		79	Double total = query.getSingleResult();
		80	if (VerificadorUtil.estaNulo(total)) {
		81	return new Double(0.0);
		82	}
		83	return total;
		84	} catch(Exception ex) {
		85	ex.printStackTrace();
		86	return null;
		87	}
		88	}
		89
265	espaco	90	@Override
		91	public Double obterValorDeMaquinetasPorPessoa(Long sequencialPessoaMaquineta, Date dataInicio, Date dataFim) {
		92	StringBuilder sql = new StringBuilder();
268	espaco	93	sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
296	espaco	94	sql.append("LEFT JOIN vp.venda e ");
268	espaco	95	sql.append("WHERE vp.formaPagamento.codigo IN :formasDePagamento ");
296	espaco	96	sql.append("AND e.maquineta.pessoa.sequencial = :sequencialPessoaMaquineta ");
		97	sql.append("AND (e.dataVenda BETWEEN :dataInicial AND :dataFinal OR e.dataVenda = :dataInicial OR e.dataVenda = :dataFinal) ");
265	espaco	98	try {
		99	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
		100	query.setParameter("formasDePagamento", FormaPagamentoDTO.codigosFormasDePagamentoViaCartao());
		101	query.setParameter("sequencialPessoaMaquineta", sequencialPessoaMaquineta);
		102	query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicio));
		103	query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFim));
		104
		105	Double total = query.getSingleResult();
		106	if (VerificadorUtil.estaNulo(total)) {
		107	return new Double(0.0);
		108	}
		109	return total;
		110	} catch(Exception ex) {
		111	ex.printStackTrace();
		112	return null;
		113	}
		114	}
		115
230	espaco	116	private void setarStringParametrosConsulta(StringBuilder sql, ParametrosConsultaVendasDTO parametros) {
		117	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialLoja())) {
296	espaco	118	sql.append("AND e.loja.sequencial = :sequencialLoja ");
230	espaco	119	}
253	espaco	120	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoSituacaoVenda())) {
296	espaco	121	sql.append("AND e.tipoSituacao = :tipoSituacao ");
230	espaco	122	}
264	espaco	123	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVendedor())) {
296	espaco	124	sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
230	espaco	125	}
264	espaco	126	/*
230	espaco	127	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicacao())) {
		128	sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
		129	}
		130	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicadorComissionado())) {
		131	sql.append("AND l.produto.indicadorComissionado = :indicadorComissionado ");
		132	}
		133	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoProduto())) {
		134	sql.append("AND l.produto.tipo = :tipoProduto ");
		135	}
		136	//TODO: VERIFICAR LANÇAMENTOS COM MAIS PAGAMENTOS QUE LANÇAMENTOS
		137	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSituacaoFinanceiraVenda())) {
		138	if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.NENHUMA.getValor())) {
		139	sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e) = 0 ");
		140	// sql.append("AND ((SELECT COUNT(vf) FROM VendaFormaPagamento vf WHERE vf.venda = e) > (SELECT COUNT(cr) FROM ContaAReceber cr WHERE cr.venda = e)) ");
		141	}
		142	if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.QUITADO.getValor())) {
		143	sql.append("AND (SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) = 0 ");
		144	sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) > 0 ");
		145	}
		146	if (parametros.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.PENDENCIAS.getValor())) {
		147	sql.append("AND ((SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) > 0 ");
		148	sql.append("OR (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) = 0) ");
		149	}
		150	}
		151	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getFormaPagamento())) {
		152	sql.append("AND (SELECT COUNT(p) FROM VendaFormaPagamento p WHERE p.venda = e AND p.formaPagamento.codigo = :codigoFormaPagamento) > 0 ");
		153	}
		154	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getBandeiraCartao())) {
		155	sql.append("AND (SELECT COUNT(b) FROM VendaFormaPagamento b WHERE b.venda = e AND b.bandeiraCartao.codigo = :codigoBandeiraCartao) > 0 ");
		156	}
		157	*/
		158	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVenda())) {
296	espaco	159	sql.append("AND e.sequencial = :sequencialVenda ");
261	espaco	160	} else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataSelecionada())
		161	\|\| VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataInicial())
		162	\|\| VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataFinal())) {
296	espaco	163	sql.append("AND e.dataVenda >= :dataInicial ");
		164	sql.append("AND e.dataVenda <= :dataFinal ");
230	espaco	165	}
		166	/*
		167	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getCodigoCupom())) {
		168	sql.append("AND (SELECT COUNT(cl) FROM Lancamento cl WHERE cl.venda = e AND cl.cupom.codigo = :codigoCupom) > 0) ");
		169	}
		170	*/
		171	}
		172
		173	private void setarQueryParametrosConsulta(Query query, ParametrosConsultaVendasDTO parametros) {
		174	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialLoja())) {
		175	query.setParameter("sequencialLoja", parametros.getSequencialLoja());
		176	}
253	espaco	177	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoSituacaoVenda())) {
		178	query.setParameter("tipoSituacao", parametros.getTipoSituacaoVenda());
		179	}
264	espaco	180	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVendedor())) {
		181	query.setParameter("sequencialVendedor", parametros.getSequencialVendedor());
		182	}
230	espaco	183	/*
		184	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicacao())) {
		185	query.setParameter("sequencialIndicacao", parametros.getIndicacao().getSequencial());
		186	}
		187	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getIndicadorComissionado())) {
		188	query.setParameter("indicadorComissionado", parametros.getIndicadorComissionado());
		189	}
		190	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getTipoProduto())) {
		191	query.setParameter("tipoProduto", parametros.getTipoProduto());
		192	}
		193	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getFormaPagamento())) {
		194	query.setParameter("codigoFormaPagamento", parametros.getFormaPagamento().getCodigo());
		195	}
		196	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getBandeiraCartao())) {
		197	query.setParameter("codigoBandeiraCartao", parametros.getBandeiraCartao().getCodigo());
		198	}
		199	*/
		200	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getSequencialVenda())) {
		201	query.setParameter("sequencialVenda", parametros.getSequencialVenda());
261	espaco	202	} else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataInicial())
		203	&& VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataFinal())) {
		204	Date dataInicial = DataUtils.getDataComHorarioMinimo(parametros.getParametrosPeriodoDTO().getDataInicial());
		205	Date dataFinal = DataUtils.getDataComHorarioMaximo(parametros.getParametrosPeriodoDTO().getDataFinal());
230	espaco	206	query.setParameter("dataInicial", dataInicial);
		207	query.setParameter("dataFinal", dataFinal);
261	espaco	208	} else if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getParametrosPeriodoDTO().getDataSelecionada())) {
		209	Date dataInicial = DataUtils.getDataComHorarioMinimo(parametros.getParametrosPeriodoDTO().getDataSelecionada());
		210	Date dataFinal = DataUtils.getDataComHorarioMaximo(parametros.getParametrosPeriodoDTO().getDataSelecionada());
230	espaco	211	query.setParameter("dataInicial", dataInicial);
		212	query.setParameter("dataFinal", dataFinal);
		213	}
		214	/*
		215	if (VerificadorUtil.naoEstaNuloOuVazio(parametros.getCodigoCupom())) {
		216	query.setParameter("codigoCupom", parametros.getCodigoCupom());
		217	}
		218	*/
		219	}
		220
229	espaco	221	/*
		222	private void setarParametrosStringConsultarVendaPorLojaEePeriodo(StringBuilder sql, Venda venda, Date dataInicial, Date dataFinal) {
		223	setarStringParametrosConsultar(sql, venda);
		224	if (VerificadorUtil.naoEstaNuloOuVazio(dataInicial) && VerificadorUtil.naoEstaNuloOuVazio(dataFinal)) {
		225	sql.append("AND e.dataVenda >= :dataInicial AND e.dataVenda <= :dataFinal ");
		226	}
		227	}
		228	*/
		229	/*
		230	@Override
		231	protected void setarStringParametrosConsultar(StringBuilder sql, Venda venda) {
		232	if (VerificadorUtil.naoEstaNuloOuVazio(venda)) {
		233	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDaLoja())) {
		234	sql.append("AND e.loja.sequencial = :sequencialLoja ");
		235	}
		236	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getVendedor())) {
		237	sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
		238	}
		239	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getIndicacao())) {
		240	sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
		241	}
		242	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getTipoSituacao())) {
		243	sql.append("AND e.tipoSituacao = :tipoSituacao ");
		244	}
		245	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getDataVenda())) {
		246	sql.append("AND e.dataVenda >= :dataInicial ");
		247	sql.append("AND e.dataVenda <= :dataFinal ");
		248	}
		249	}
		250	}
		251
		252	@Override
		253	protected void setarQueryParametrosConsultar(Query query, Venda venda) {
		254	if (VerificadorUtil.naoEstaNuloOuVazio(venda)) {
		255	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDaLoja())) {
		256	query.setParameter("sequencialLoja", venda.getSequencialDaLoja());
		257	}
		258	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getSequencialDoVendedor())) {
		259	query.setParameter("sequencialVendedor", venda.getSequencialDoVendedor());
		260	}
		261	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getIndicacao())) {
		262	query.setParameter("sequencialIndicacao", venda.getIndicacao());
		263	}
		264	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getTipoSituacao())) {
		265	query.setParameter("tipoSituacao", venda.getTipoSituacao());
		266	}
		267	if (VerificadorUtil.naoEstaNuloOuVazio(venda.getDataVenda())) {
		268	Date dataInicial = DataUtils.getDataComHorarioMinimo(venda.getDataVenda());
		269	Date dataFinal = DataUtils.getDataComHorarioMaximo(venda.getDataVenda());
		270	query.setParameter("dataInicial", dataInicial);
		271	query.setParameter("dataFinal", dataFinal);
		272	}
		273	}
		274	}
		275
		276	@Override
		277	public List<Venda> consultarVendasPorDemanda(ParametrosConsulta<Venda> parametrosConsulta, Integer primeiroRegistro,
		278	Integer tamanhoPagina, String sortField, String orderSort, Map<String, Object> filters) {
		279	StringBuilder sql = new StringBuilder();
		280	sql.append("SELECT DISTINCT e FROM Venda e ");
		281	sql.append("LEFT JOIN FETCH e.listaLancamentos l ");
		282	sql.append("LEFT JOIN FETCH e.listaVendaFormaPagamentos p ");
		283	sql.append("WHERE 1=1 ");
		284
		285	try {
		286	setarStringParametrosConsulta(sql, parametrosConsulta);
		287	sql.append("ORDER BY e.dataVenda");
		288	TypedQuery<Venda> query = (TypedQuery<Venda>) getEntityManager().createQuery(sql.toString(), Venda.class);
		289	setarQueryParametrosConsulta(query, parametrosConsulta);
		290
		291	return query.setFirstResult(primeiroRegistro).setMaxResults(tamanhoPagina).getResultList();
		292	} catch(Exception ex) {
		293	ex.printStackTrace();
		294	return null;
		295	}
		296	}
		297
		298	@Override
		299	public List<Venda> consultarVendaPorParametros(ParametrosConsultaVendasDTO parametrosConsultaVendas) {
		300	StringBuilder sql = new StringBuilder();
		301	sql.append("SELECT DISTINCT e FROM Venda e ");
		302	sql.append("LEFT JOIN FETCH e.listaLancamentos l ");
		303	sql.append("LEFT JOIN FETCH e.listaVendaFormaPagamentos p ");
		304	sql.append("WHERE 1=1 ");
		305
		306	try {
		307	setarStringParametrosConsulta(sql, parametrosConsultaVendas);
		308	sql.append("ORDER BY e.dataVenda");
		309	TypedQuery<Venda> query = (TypedQuery<Venda>) getEntityManager().createQuery(sql.toString(), Venda.class);
		310	setarQueryParametrosConsulta(query, parametrosConsultaVendas);
		311	return query.getResultList();
		312	} catch(Exception ex) {
		313	ex.printStackTrace();
		314	return null;
		315	}
		316	}
		317
		318	@Override
		319	public Venda detalharVenda(Venda venda) {
		320	StringBuilder jpql = new StringBuilder();
		321	try {
		322	jpql.append("SELECT c FROM Venda c ");
		323	//jpql.append("LEFT JOIN FETCH c.listaPedidos p ");
		324	//jpql.append("LEFT JOIN FETCH c.listaVendas v ");
		325	jpql.append("WHERE c = :venda");
		326	return getEntityManager().createQuery(jpql.toString(), Venda.class).setParameter("venda", venda).getSingleResult();
		327	} catch (NoResultException e) {
		328	return null;
		329	}
		330	}
		331
		332	@Override
		333	public Venda detalharVendaCompleta(Venda venda) {
		334	StringBuilder jpql = new StringBuilder();
		335	try {
		336	jpql.append("SELECT c FROM Venda c ");
		337	jpql.append("LEFT JOIN FETCH c.listaLancamentos l ");
		338	jpql.append("LEFT JOIN FETCH c.listaVendaFormaPagamentos p ");
		339	jpql.append("WHERE c = :venda");
		340	return getEntityManager().createQuery(jpql.toString(), Venda.class).setParameter("venda", venda).getSingleResult();
		341	} catch (NoResultException e) {
		342	return null;
		343	}
		344	}
		345
		346	@Override
		347	public List<Venda> consultarVendasDoDia(Long sequencialLoja, Date data) {
		348	StringBuilder sql = new StringBuilder();
		349	sql.append("SELECT DISTINCT v FROM Venda v ");
		350	sql.append("LEFT JOIN FETCH v.listaVendaFormaPagamentos p ");
		351	sql.append("WHERE v.loja.sequencial = :sequencialLoja ");
		352	sql.append("AND v.dataVenda >= :dataInicial AND v.dataVenda <= :dataFinal ");
		353	try {
		354	sql.append("ORDER BY v.dataVenda");
		355	return getEntityManager().createQuery(sql.toString(), Venda.class)
		356	.setParameter("sequencialLoja", sequencialLoja)
		357	.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(data))
		358	.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(data))
		359	.getResultList();
		360	} catch(Exception ex) {
		361	ex.printStackTrace();
		362	return null;
		363	}
		364	}
		365
		366
		367	private void setarParametrosQueryConsultarVendaPorLojaEePeriodo(Query query, Venda venda, Date dataInicial, Date dataFinal) {
		368	setarQueryParametrosConsultar(query, venda);
		369	if (VerificadorUtil.naoEstaNuloOuVazio(dataInicial) && VerificadorUtil.naoEstaNuloOuVazio(dataFinal)) {
		370	query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial));
		371	query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
		372	}
		373	}
		374
		375	@Override
		376	public Double obterValorTotalBrutoDeVendasPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		377	StringBuilder sql = new StringBuilder();
		378	sql.append("SELECT SUM(l.valorVenda) FROM Venda e ");
		379	sql.append("LEFT JOIN e.listaLancamentos l ");
		380	sql.append("WHERE l.ativo IS TRUE ");
		381	try {
		382	setarStringParametrosConsulta(sql, parametrosConsulta);
		383	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
		384	setarQueryParametrosConsulta(query, parametrosConsulta);
		385	Double total = query.getSingleResult();
		386	if (VerificadorUtil.estaNulo(total)) {
		387	return new Double(0.0);
		388	}
		389	return total;
		390	} catch(Exception ex) {
		391	ex.printStackTrace();
		392	return null;
		393	}
		394	}
		395
		396	@Override
		397	public Double obterValorDeCuponsUtilizadosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		398	StringBuilder sql = new StringBuilder();
		399	sql.append("SELECT SUM(p.valorPagamento) FROM VendaFormaPagamento p ");
		400	sql.append("LEFT JOIN p.venda e ");
		401	sql.append("WHERE p.formaPagamento.codigo = 16 ");
		402
		403	parametrosConsulta.setIndicadorComissionado(null);
		404	parametrosConsulta.setTipoProduto(null);
		405
		406	setarStringParametrosConsulta(sql, parametrosConsulta);
		407	*/
		408	/*
		409	sql.append("AND (SELECT COUNT(l) FROM Lancamento l WHERE l.venda = e AND l.ativo = true) > 0 ");
		410	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getLoja())) {
		411	sql.append("AND e.loja.sequencial = :sequencialLoja ");
		412	}
		413	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getVendedor())) {
		414	sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
		415	}
		416	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataVendas())
		417	\|\| VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicial())
		418	\|\| VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinal())) {
		419	sql.append("AND e.dataVenda >= :dataInicial ");
		420	sql.append("AND e.dataVenda <= :dataFinal ");
		421	}
		422	*/
		423	/*
		424	try {
		425	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
		426	setarQueryParametrosConsulta(query, parametrosConsulta);
		427	*/
		428	/*
		429	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getLoja())) {
		430	query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
		431	}
		432	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getVendedor())) {
		433	query.setParameter("sequencialVendedor", parametrosConsulta.getVendedor().getSequencial());
		434	}
		435	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicial())
		436	&& VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinal())) {
		437	Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial());
		438	Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal());
		439	query.setParameter("dataInicial", dataInicial);
		440	query.setParameter("dataFinal", dataFinal);
		441	} else if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataVendas())) {
		442	Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataVendas());
		443	Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataVendas());
		444	query.setParameter("dataInicial", dataInicial);
		445	query.setParameter("dataFinal", dataFinal);
		446	}
		447	*/
		448	/*
		449	Double total = query.getSingleResult();
		450	if (VerificadorUtil.estaNulo(total)) {
		451	return new Double(0.0);
		452	}
		453	return total;
		454	} catch(Exception ex) {
		455	ex.printStackTrace();
		456	return null;
		457	}
		458	}
		459
		460	@Override
		461	public Double obterValorTotalDeDescontosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
		462	StringBuilder sql = new StringBuilder();
		463	sql.append("SELECT SUM(l.valorVarejo - l.valorVenda) FROM Venda e ");
		464	sql.append("LEFT JOIN e.listaLancamentos l ");
		465	sql.append("WHERE l.ativo IS TRUE ");
		466	try {
		467	setarStringParametrosConsulta(sql, parametrosConsulta);
		468	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
		469	setarQueryParametrosConsulta(query, parametrosConsulta);
		470	Double total = query.getSingleResult();
		471	if (VerificadorUtil.estaNulo(total)) {
		472	return new Double(0.0);
		473	}
		474	return total;
		475	} catch(Exception ex) {
		476	ex.printStackTrace();
		477	return null;
		478	}
		479	}
261	espaco	480	*/
229	espaco	481	@Override
296	espaco	482	public Double obterValorTotalBrutoDeVendasPorParametrosEeFormasDePagamento(ParametrosConsultaVendasDTO parametrosConsultaVendas, List<FormaPagamentoDTO> formasDePagamento) {
229	espaco	483	StringBuilder sql = new StringBuilder();
268	espaco	484	sql.append("SELECT SUM(vp.valorPagamento) FROM VendaFormaPagamento vp ");
296	espaco	485	sql.append("LEFT JOIN vp.venda e ");
268	espaco	486	sql.append("LEFT JOIN vp.formaPagamento f ");
		487	sql.append("WHERE vp.formaPagamento.codigo != ");
261	espaco	488	sql.append(ConstantesSEC.FormasDePagamento.FORMAPAGAMENTO_CUPOM);
		489	sql.append(" ");
229	espaco	490	try {
		491	sql = setarParametrosFormasDePagamento(sql, formasDePagamento);
264	espaco	492	sql = setarParametrosLojasSelecionadas(sql, parametrosConsultaVendas.getLojasSelecionadasDTO());
268	espaco	493	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendas.getVendedorSelecionado())) {
296	espaco	494	sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
268	espaco	495	}
229	espaco	496	setarStringParametrosConsulta(sql, parametrosConsultaVendas);
		497	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
		498	setarQueryParametrosConsulta(query, parametrosConsultaVendas);
268	espaco	499	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendas.getVendedorSelecionado())) {
		500	query.setParameter("sequencialVendedor", parametrosConsultaVendas.getVendedorSelecionado().getSequencial());
		501	}
229	espaco	502	Double total = query.getSingleResult();
		503	if (VerificadorUtil.estaNulo(total)) {
		504	return new Double(0.0);
		505	}
		506	return total;
		507	} catch(Exception ex) {
		508	ex.printStackTrace();
		509	return null;
		510	}
		511	}
264	espaco	512
261	espaco	513	private StringBuilder setarParametrosFormasDePagamento(StringBuilder sql, List<FormaPagamentoDTO> formasPagamento) {
		514	if (VerificadorUtil.naoEstaNuloOuVazio(formasPagamento)) {
268	espaco	515	sql.append("AND vp.formaPagamento.codigo IN (");
261	espaco	516	for (FormaPagamentoDTO formaPagamento : formasPagamento) {
		517	if (!formaPagamento.formaPagamentoEhCupom()) {
		518	sql.append(formaPagamento.getCodigo() + ",");
		519	}
229	espaco	520	}
		521	sql.append(") ");
		522	}
		523	return new StringBuilder(sql.toString().replace(",)", ")"));
		524	}
264	espaco	525
		526	private StringBuilder setarParametrosLojasSelecionadas(StringBuilder sql, List<LojaDTO> lojasSelecionadas) {
		527	if (VerificadorUtil.naoEstaNuloOuVazio(lojasSelecionadas)) {
268	espaco	528	sql.append("AND vp.venda.loja.sequencial IN (");
264	espaco	529	for (LojaDTO loja : lojasSelecionadas) {
		530	sql.append(loja.getSequencial() + ",");
		531	}
		532	sql.append(") ");
		533	}
		534	return new StringBuilder(sql.toString().replace(",)", ")"));
		535	}
		536
229	espaco	537	@Override
296	espaco	538	public Double obterValorTotalLiquidoDeVendas(ParametrosConsultaVendasDTO parametrosConsulta) {
229	espaco	539	StringBuilder sql = new StringBuilder();
		540	sql.append("SELECT SUM(e.valor) FROM Parcela e ");
		541	sql.append("INNER JOIN e.conta c ");
		542	sql.append("WHERE e.indicadorAtivo IS TRUE ");
		543	try {
296	espaco	544	setarParametrosStringConsultarValorTotalLiquidoVenda(sql, parametrosConsulta);
229	espaco	545	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
296	espaco	546	setarParametrosQueryConsultarValorTotalLiquidoVenda(query, parametrosConsulta);
229	espaco	547
		548	Double total = query.getSingleResult();
		549	if (VerificadorUtil.estaNulo(total)) {
		550	return new Double(0.0);
		551	}
		552	return total;
		553	} catch(Exception ex) {
		554	ex.printStackTrace();
		555	return null;
		556	}
		557	}
296	espaco	558
		559	private void setarParametrosStringConsultarValorTotalLiquidoVenda(StringBuilder sql, ParametrosConsultaVendasDTO parametrosConsulta) {
		560	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialLoja())) {
229	espaco	561	sql.append("AND e.conta.venda.loja.sequencial = :sequencialLoja ");
		562	}
296	espaco	563	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialVendedor())) {
229	espaco	564	sql.append("AND e.conta.venda.vendedor.sequencial = :sequencialVendedor ");
		565	}
296	espaco	566	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicialDoPeriodo()) && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinalDoPeriodo())) {
		567	sql.append("AND e.conta.venda.dataVenda >= :dataInicial AND e.conta.venda.dataVenda <= :dataFinal ");
		568	}
		569	/*
229	espaco	570	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicacao())) {
		571	sql.append("AND e.conta.venda.indicacao.sequencial = :sequencialIndicacao ");
		572	}
296	espaco	573	*/
229	espaco	574	}
		575
296	espaco	576	private void setarParametrosQueryConsultarValorTotalLiquidoVenda(Query query, ParametrosConsultaVendasDTO parametrosConsulta) {
		577	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialLoja())) {
		578	query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
229	espaco	579	}
296	espaco	580	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getSequencialVendedor())) {
		581	query.setParameter("sequencialVendedor", parametrosConsulta.getSequencialVendedor());
229	espaco	582	}
296	espaco	583	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataInicialDoPeriodo()) && VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getDataFinalDoPeriodo())) {
		584	query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicialDoPeriodo()));
		585	query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinalDoPeriodo()));
		586	}
		587	/*
229	espaco	588	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicacao())) {
		589	query.setParameter("sequencialIndicacao", parametrosConsulta.getIndicacao().getSequencial());
		590	}
296	espaco	591	*/
229	espaco	592	}
		593
		594	@Override
296	espaco	595	public Double obterValorProdutosUtilizadosEmVendas(ParametrosConsultaVendasDTO parametrosConsulta) {
229	espaco	596	StringBuilder sql = new StringBuilder();
296	espaco	597	sql.append("SELECT SUM(l.valorCompra) FROM Venda e ");
229	espaco	598	sql.append("LEFT JOIN e.listaLancamentos l ");
		599	sql.append("WHERE l.ativo IS TRUE ");
		600	try {
		601	setarStringParametrosConsulta(sql, parametrosConsulta);
296	espaco	602	TypedQuery<Double> query = getEntityManager().createQuery(sql.toString(), Double.class);
229	espaco	603	setarQueryParametrosConsulta(query, parametrosConsulta);
296	espaco	604	Double total = query.getSingleResult();
		605	if (VerificadorUtil.estaNulo(total)) {
		606	return new Double(0.0);
		607	}
		608	return total;
229	espaco	609	} catch(Exception ex) {
		610	ex.printStackTrace();
		611	return null;
		612	}
		613	}
		614
450	blopes	615	@Override
		616	public List<AuditoriaVendaDTO> consultarAuditoriaVenda(Date dataSelecionada, Long sequencialLojaSelecionada) {
		617	StringBuilder sql = new StringBuilder();
		618	// (Long sequencialVenda, Long sequencialLoja, Date dataHoraVenda, Double valorTotal, Double valorTrocaCancelamento)
		619	sql.append("SELECT new br.com.ec.domain.dto.AuditoriaVendaDTO(");
		620	sql.append("v.sequencial, v.loja.sequencial, v.dataVenda, SUM(vfp.valorPagamento), ");
		621	sql.append("(SELECT SUM(vfpcupom.valorPagamento) FROM VendaFormaPagamento vfpcupom WHERE ");
		622	sql.append("vfpcupom.venda.sequencial = v.sequencial AND vfpcupom.formaPagamento.codigo = 16)");
		623	sql.append(") FROM Venda v ");
		624	sql.append("LEFT JOIN v.listaVendaFormaPagamentos vfp ON vfp.formaPagamento.codigo <> 16 ");
		625	sql.append("WHERE v.loja.sequencial = :sequencialLojaSelecionada ");
		626	sql.append("AND v.dataVenda >= :dataInicial AND v.dataVenda <= :dataFinal ");
		627	sql.append("GROUP BY (v.sequencial) ");
		628	sql.append("ORDER BY (v.dataVenda) ");
		629	try {
		630	TypedQuery<AuditoriaVendaDTO> query = getEntityManager().createQuery(sql.toString(), AuditoriaVendaDTO.class);
		631	query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataSelecionada));
		632	query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataSelecionada));
		633	query.setParameter("sequencialLojaSelecionada", sequencialLojaSelecionada);
		634	return query.getResultList();
		635	} catch(Exception ex) {
		636	ex.printStackTrace();
		637	return null;
		638	}
		639	}
		640
296	espaco	641	/*
		642
229	espaco	643	@Override
296	espaco	644	public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodo(ParametrosConsultaVendasDTO parametrosConsulta) {
229	espaco	645	StringBuilder sql = new StringBuilder();
		646	sql.append("SELECT COUNT(l) FROM Venda e ");
		647	sql.append("LEFT JOIN e.listaLancamentos l ");
296	espaco	648	sql.append("WHERE l.ativo IS TRUE ");
229	espaco	649	try {
		650	setarStringParametrosConsulta(sql, parametrosConsulta);
		651	TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
		652	setarQueryParametrosConsulta(query, parametrosConsulta);
		653	return query.getSingleResult().intValue();
		654	} catch(Exception ex) {
		655	ex.printStackTrace();
		656	return null;
		657	}
		658	}
		659
		660	@Override
296	espaco	661	public Integer obterQuantidadeProdutosVendidosPorLojaEePeriodoNaoVivo(ParametrosConsultaVendasDTO parametrosConsulta) {
229	espaco	662	StringBuilder sql = new StringBuilder();
296	espaco	663	sql.append("SELECT COUNT(l) FROM Venda e ");
229	espaco	664	sql.append("LEFT JOIN e.listaLancamentos l ");
296	espaco	665	sql.append("WHERE l.ativo IS TRUE AND l.produto.tipo not like 'V' ");
229	espaco	666	try {
		667	setarStringParametrosConsulta(sql, parametrosConsulta);
296	espaco	668	TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
229	espaco	669	setarQueryParametrosConsulta(query, parametrosConsulta);
296	espaco	670	return query.getSingleResult().intValue();
229	espaco	671	} catch(Exception ex) {
		672	ex.printStackTrace();
		673	return null;
		674	}
		675	}
		676
		677	@Override
		678	public GraficoAcumuladoDTO consultarGrafico(String mes, String ano) {
		679	StringBuilder sql = new StringBuilder();
		680	sql.append("SELECT ");
		681	Calendar data = DataUtils.obterCalendario(DataUtils.obterData(1, new Integer(mes)-1, new Integer(ano)));
		682	int qntMaximaDias = data.getActualMaximum(Calendar.DAY_OF_MONTH);
		683	for (int i = 1; i <= qntMaximaDias; i++) {
		684	String dia = String.format("%02d", i);
		685	sql.append("SUM(D.DIA" + dia + ") AS dia" + dia);
		686	if (i < qntMaximaDias) {
		687	sql.append(", ");
		688	} else {
		689	sql.append(" ");
		690	}
		691	}
		692	sql.append(" FROM ");
		693	sql.append("(SELECT ");
		694	for (int i = 1; i <= qntMaximaDias; i++) {
		695	String dia = String.format("%02d", i);
		696	sql.append("CASE date(v.dth_venda) WHEN '" + ano + "-" + mes + "-" + dia + "' THEN SUM(l.val_venda) END AS DIA" + dia);
		697	if (i < qntMaximaDias) {
		698	sql.append(", ");
		699	} else {
		700	sql.append(" ");
		701	}
		702	}
		703	sql.append("FROM sc_sec.sec_lancamento l, sc_sec.sec_venda v ");
		704	sql.append("WHERE l.seq_venda = v.seq_venda AND l.ind_ativo is true ");
		705	sql.append("GROUP BY date(v.dth_venda) ");
		706	sql.append(") AS D ");
		707
		708	try {
		709	Query query = getEntityManager().createNativeQuery(sql.toString());
		710	Object[] valores = new Object[31];
		711	Object[] resultado = (Object[]) query.getSingleResult();
		712	for (int i = 0; i < resultado.length; i++) {
		713	valores[i] = resultado[i];
		714	}
		715	GraficoAcumuladoDTO grafico = new GraficoAcumuladoDTO();
		716	grafico.setDIA_01(retornarValorEmString(valores[0]));
		717	grafico.setDIA_02(retornarValorEmString(valores[1]));
		718	grafico.setDIA_03(retornarValorEmString(valores[2]));
		719	grafico.setDIA_04(retornarValorEmString(valores[3]));
		720	grafico.setDIA_05(retornarValorEmString(valores[4]));
		721	grafico.setDIA_06(retornarValorEmString(valores[5]));
		722	grafico.setDIA_07(retornarValorEmString(valores[6]));
		723	grafico.setDIA_08(retornarValorEmString(valores[7]));
		724	grafico.setDIA_09(retornarValorEmString(valores[8]));
		725	grafico.setDIA_10(retornarValorEmString(valores[9]));
		726	grafico.setDIA_11(retornarValorEmString(valores[10]));
		727	grafico.setDIA_12(retornarValorEmString(valores[11]));
		728	grafico.setDIA_13(retornarValorEmString(valores[12]));
		729	grafico.setDIA_14(retornarValorEmString(valores[13]));
		730	grafico.setDIA_15(retornarValorEmString(valores[14]));
		731	grafico.setDIA_16(retornarValorEmString(valores[15]));
		732	grafico.setDIA_17(retornarValorEmString(valores[16]));
		733	grafico.setDIA_18(retornarValorEmString(valores[17]));
		734	grafico.setDIA_19(retornarValorEmString(valores[18]));
		735	grafico.setDIA_20(retornarValorEmString(valores[19]));
		736	grafico.setDIA_21(retornarValorEmString(valores[20]));
		737	grafico.setDIA_22(retornarValorEmString(valores[21]));
		738	grafico.setDIA_23(retornarValorEmString(valores[22]));
		739	grafico.setDIA_24(retornarValorEmString(valores[23]));
		740	grafico.setDIA_25(retornarValorEmString(valores[24]));
		741	grafico.setDIA_26(retornarValorEmString(valores[25]));
		742	grafico.setDIA_27(retornarValorEmString(valores[26]));
		743	grafico.setDIA_28(retornarValorEmString(valores[27]));
		744	grafico.setDIA_29(retornarValorEmString(valores[28]));
		745	grafico.setDIA_30(retornarValorEmString(valores[29]));
		746	grafico.setDIA_31(retornarValorEmString(valores[30]));
		747	return grafico;
		748	} catch(Exception ex) {
		749	return null;
		750	}
		751	}
		752
		753	private Double retornarValorEmString(Object objeto) {
		754	try {
		755	return new Double(objeto.toString());
		756	} catch (Exception e) {
		757	return new Double(0.0);
		758	}
		759	}
		760
		761	private String adicionarEstoque(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		762	StringBuilder sql = new StringBuilder();
		763	sql.append(", (SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl WHERE pl.produto = l.produto ");
		764	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
		765	sql.append("AND pl.loja.sequencial = :sequencialLoja ");
		766	}
		767	sql.append(")");
		768	return sql.toString();
		769	}
		770	*/
		771	/*private String adicionarConsumoMedioDiario(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		772	StringBuilder sql = new StringBuilder();
		773	sql.append(", (SELECT COUNT(*) FROM Lancamento lc WHERE lc.produto = l.produto AND lc.ativo = true ");
		774	sql.append("WHERE lc.venda.dataVenda >= :dataInicial AND lc.venda.dataVenda <= :dataFinal) ");
		775	// String dataAnterior = DataUtil.retornarDataFormatadaEmFormatoTexto("yyyy-MM-dd", DataUtils.acrescentarMeses(DataUtils.getDataAtual(), -2));
		776	// sql.append("AND lc.venda.dataVenda >= :dataDoisMesesAnterior) ");
		777	return sql.toString();
		778	}*/
		779	/*
		780	private String adicionarSolicitacaoCompraProduto() {
		781	StringBuilder sql = new StringBuilder();
		782	// sql.append(", (SELECT COUNT(*) > 0 FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
		783	// sql.append(", (SELECT ppc.status, ppc.quantidadeParaComprar FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
		784	// sql.append(", (SELECT (ppc) FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
		785	sql.append(", (SELECT ppc.status FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
		786	sql.append(", (SELECT ppc.quantidadeParaComprar FROM ProdutoPedidoCompra ppc WHERE ppc.produto = l.produto)");
		787	return sql.toString();
		788	}
		789
		790	@Override
		791	public List<RankingProdutoDTO> consultarProdutosVendidos(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		792	StringBuilder sql = new StringBuilder();
		793	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
		794	if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
		795	sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, l.venda, l.valorVenda, l.valorVarejo - l.valorVenda");
		796	sql.append(adicionarEstoque(parametrosConsulta));
		797	sql.append(adicionarSolicitacaoCompraProduto());
		798	sql.append(") FROM Lancamento l ");
		799	} else {
		800	sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, SUM(l.valorVenda), SUM(l.valorCompra), SUM(l.valorVarejo - l.valorVenda), COUNT(l.produto), MAX(l.venda.dataVenda)");
		801	sql.append(adicionarEstoque(parametrosConsulta));
		802	sql.append(adicionarSolicitacaoCompraProduto());
		803	sql.append(") FROM Lancamento l ");
		804	}
		805	} else {
		806	sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, l.venda, l.valorVenda, l.valorVarejo - l.valorVenda");
		807	sql.append(adicionarEstoque(parametrosConsulta));
		808	sql.append(adicionarSolicitacaoCompraProduto());
		809	sql.append(") FROM Lancamento l ");
		810	}
		811	sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
		812	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
		813	sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
		814	}
		815	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		816	sql.append("AND l.produto.tipo = :tipoProduto ");
		817	}
		818	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
		819	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
		820	sql.append("AND l.produto.codigo = :codigo ");
		821	}
		822	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
		823	sql.append("AND ");
		824	sql.append(sqlConsultarSemAcento("l.produto.descricao"));
		825	sql.append(" like upper(:descricao) ");
		826	}
		827	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
		828	sql.append("AND l.produto.estilo = :tipoEstilo ");
		829	}
		830	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
		831	sql.append("AND l.produto.cor = :tipoCor ");
		832	}
		833	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
		834	sql.append("AND l.produto.genero = :tipoGenero ");
		835	}
		836	}
		837	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
		838	sql.append("AND l.produto.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
		839	}
		840	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
		841	sql.append("AND l.produto.modelo.sequencial = :sequencialModelo ");
		842	}
		843	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
		844	sql.append("AND :fornecedor in (SELECT fp.fornecedor FROM FornecedorProduto fp WHERE fp.produto.sequencial = l.produto.sequencial) ");
		845	}
		846	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
		847	sql.append("AND l.venda.vendedor = :vendedor ");
		848	}
		849
		850	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
		851	if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
		852	sql.append("ORDER BY l.venda.dataVenda DESC ");
		853	} else {
		854	sql.append("GROUP BY l.produto ");
		855	if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
		856	sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
		857	} else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
		858	sql.append("ORDER BY COUNT(l.produto) DESC ");
		859	} else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
		860	sql.append("ORDER BY SUM(l.valorVenda) DESC ");
		861	}
		862	}
		863	} else {
		864	sql.append("ORDER BY l.venda.dataVenda DESC ");
		865	}
		866	try {
		867	TypedQuery<RankingProdutoDTO> query = getEntityManager().createQuery(sql.toString(), RankingProdutoDTO.class)
		868	.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
		869	.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()))
		870	.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
		871	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
		872	query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
		873	}
		874	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		875	query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
		876	}
		877	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
		878	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
		879	query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
		880	}
		881	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
		882	query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
		883	}
		884	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
		885	query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
		886	}
		887	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
		888	query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
		889	}
		890	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
		891	query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
		892	}
		893	}
		894	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
		895	query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
		896	}
		897	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
		898	query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
		899	}
		900	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getFornecedor())) {
		901	query.setParameter("fornecedor", parametrosConsulta.getFornecedor());
		902	}
		903	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getVendedor())) {
		904	query.setParameter("vendedor", parametrosConsulta.getVendedor());
		905	}
		906	*/
		907	/*if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSomenteParaComprar())) {
		908	query.setParameter("quantidadeMinimaComprar", parametrosConsulta.getQuantidadeMinimaComprar());
		909	}*/
		910	/*if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getTipoOrdenacao())) {
		911	if (!parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.DATA.getValor())) {
		912	query.setParameter("dataDoisMesesAnterior", DataUtils.acrescentarMeses(DataUtils.getDataComHorarioMinimo(DataUtils.getDataAtual()), -2));
		913	}
		914	}*/
		915	/*
		916	return query.getResultList();
		917	} catch(Exception ex) {
		918	ex.printStackTrace();
		919	return null;
		920	}
		921	}
		922
		923	@Override
		924	public List<RankingProdutoDTO> consultarProdutosVendidosResumido(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		925	StringBuilder sql = new StringBuilder();
		926	sql.append("SELECT CAST(l.seq_produto AS VARCHAR), COUNT(l.seq_produto) ");
		927	sql.append(adicionarEstoqueSqlNativo(parametrosConsulta));
		928	sql.append(" FROM sc_sec.sec_lancamento l ");
		929	sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = l.seq_venda ");
		930	sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
		931	sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = l.seq_produto ");
		932	sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
		933	sql.append("LEFT JOIN sc_sec.sec_marca ma ON ma.seq_marca = m.seq_marca ");
		934	sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
		935	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
		936	sql.append("AND lj.seq_loja = :sequencialLoja ");
		937	}
		938	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		939	sql.append("AND p.tip_produto = :tipoProduto ");
		940	}
		941
		942	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
		943	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
		944	sql.append("AND p.seq_produto = :sequencialProduto ");
		945	}
		946	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
		947	sql.append("AND p.cod_produto = :codigo ");
		948	}
		949	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
		950	sql.append("AND ");
		951	sql.append(sqlConsultarSemAcento("p.dsc_produto"));
		952	sql.append(" like upper(:descricao) ");
		953	}
		954	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
		955	sql.append("AND p.tip_estilo = :tipoEstilo ");
		956	}
		957	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
		958	sql.append("AND p.tip_cor = :tipoCor ");
		959	}
		960	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
		961	sql.append("AND p.tip_genero = :tipoGenero ");
		962	}
		963	}
		964	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
		965	sql.append("AND ma.seq_marcal = :sequencialMarcaDoModelo ");
		966	}
		967	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
		968	sql.append("AND m.seq_modelo = :sequencialModelo ");
		969	}
		970
		971	sql.append("GROUP BY l.seq_produto ");
		972	// if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
		973	// sql.append("ORDER BY COUNT(l.seq_produto) DESC ");
		974	// }
		975	try {
		976	Query query = getEntityManager().createNativeQuery(sql.toString())
		977	.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
		978	.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
		979	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getPrimeiroRegistro())) {
		980	if (parametrosConsulta.getPrimeiroRegistro() > 0) {
		981	query.setFirstResult(parametrosConsulta.getPrimeiroRegistro());
		982	}
		983	}
		984	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTamanhoPagina())) {
		985	if (parametrosConsulta.getTamanhoPagina() > 0) {
		986	query.setMaxResults(parametrosConsulta.getTamanhoPagina());
		987	} else {
		988	query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
		989	}
		990	} else {
		991	query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
		992	}
		993	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
		994	query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
		995	}
		996	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		997	query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
		998	}
		999	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
		1000	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
		1001	query.setParameter("sequencialProduto", parametrosConsulta.getProduto().getSequencial());
		1002	}
		1003	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
		1004	query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
		1005	}
		1006	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
		1007	query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
		1008	}
		1009	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
		1010	query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
		1011	}
		1012	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
		1013	query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
		1014	}
		1015	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
		1016	query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
		1017	}
		1018	}
		1019	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
		1020	query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
		1021	}
		1022	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
		1023	query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
		1024	}
		1025	List<Object[]> resultList = query.getResultList();
		1026	List<RankingProdutoDTO> produtos = new ArrayList<RankingProdutoDTO>();
		1027	for (Object[] objects : resultList) {
		1028	RankingProdutoDTO rankingProduto = new RankingProdutoDTO();
		1029	Produto produto = new Produto();
		1030	if (VerificadorUtil.naoEstaNulo(objects[0])) {
		1031	produto.setSequencial(Long.parseLong(objects[0].toString()));
		1032	}
		1033	rankingProduto.setProduto(produto);
		1034	if (VerificadorUtil.naoEstaNulo(objects[1])) {
		1035	rankingProduto.setQuantidadeVendas(Long.parseLong(objects[1].toString()));
		1036	}
		1037	if (VerificadorUtil.naoEstaNulo(objects[2])) {
		1038	rankingProduto.setQuantidadeEstoque(Long.parseLong(objects[2].toString()));
		1039	}
		1040	produtos.add(rankingProduto);
		1041	}
		1042	return produtos;
		1043	} catch(Exception ex) {
		1044	ex.printStackTrace();
		1045	return null;
		1046	}
		1047	}
		1048
		1049	@Override
		1050	public List<RankingProdutoDTO> consultarProdutosParaTransferir(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1051	StringBuilder sql = new StringBuilder();
		1052	sql.append("SELECT CAST(l.seq_produto AS VARCHAR) AS produto, COUNT(l.seq_produto) AS vendas ");
		1053	sql.append(" FROM sc_sec.sec_lancamento l ");
		1054	sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = l.seq_venda ");
		1055	sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
		1056	sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = l.seq_produto ");
		1057	sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
		1058	sql.append("LEFT JOIN sc_sec.sec_marca ma ON ma.seq_marca = m.seq_marca ");
		1059	sql.append("WHERE ");
		1060	sql.append(adicionarParametrosSqlNativo(parametrosConsulta));
		1061	sql.append("GROUP BY l.seq_produto, ma.dsc_marca, m.dsc_modelo ");
		1062	sql.append("HAVING ");
		1063	for (Loja loja : parametrosConsulta.getLojasParaConsulta()) {
		1064	sql.append(adicionarHavingSqlNativo(parametrosConsulta, loja.getSequencial()));
		1065	sql.append(" OR ");
		1066	}
		1067	sql.append(" (SELECT SUM(pl.qtd_estoque) AS estoque FROM sc_sec.sec_produto_loja pl WHERE pl.seq_produto = l.seq_produto AND pl.seq_loja in (");
		1068	for (Loja loja : parametrosConsulta.getLojasParaConsulta()) {
		1069	sql.append(" ").append(loja.getSequencial()).append(", ");
		1070	}
		1071	sql.deleteCharAt(sql.length()-1);
		1072	sql.deleteCharAt(sql.length()-1);
		1073	sql.append(" )) = 0 ");
		1074	sql.append("ORDER BY ma.dsc_marca, m.dsc_modelo ");
		1075	try {
		1076	Query query = getEntityManager().createNativeQuery(sql.toString())
		1077	.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
		1078	.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
		1079	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getPrimeiroRegistro())) {
		1080	if (parametrosConsulta.getPrimeiroRegistro() > 0) {
		1081	query.setFirstResult(parametrosConsulta.getPrimeiroRegistro());
		1082	}
		1083	}
		1084	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTamanhoPagina())) {
		1085	if (parametrosConsulta.getTamanhoPagina() > 0) {
		1086	query.setMaxResults(parametrosConsulta.getTamanhoPagina());
		1087	} else {
		1088	query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
		1089	}
		1090	} else {
		1091	query.setMaxResults(parametrosConsulta.getQuantidadeProdutos());
		1092	}
		1093	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
		1094	query.setParameter("sequencialLoja", parametrosConsulta.getLoja().getSequencial());
		1095	}
		1096	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1097	query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
		1098	}
		1099	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
		1100	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
		1101	query.setParameter("sequencialProduto", parametrosConsulta.getProduto().getSequencial());
		1102	}
		1103	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
		1104	query.setParameter("codigo", parametrosConsulta.getProduto().getCodigoProdutoPadrao());
		1105	}
		1106	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
		1107	query.setParameter("descricao", "%" + removerAcentuacao(parametrosConsulta.getProduto().getDescricao()) + "%");
		1108	}
		1109	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
		1110	query.setParameter("tipoEstilo", parametrosConsulta.getProduto().getEstilo());
		1111	}
		1112	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
		1113	query.setParameter("tipoCor", parametrosConsulta.getProduto().getCor());
		1114	}
		1115	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
		1116	query.setParameter("tipoGenero", parametrosConsulta.getProduto().getGenero());
		1117	}
		1118	}
		1119	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
		1120	query.setParameter("sequencialMarcaDoModelo", parametrosConsulta.getMarca().getSequencial());
		1121	}
		1122	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
		1123	query.setParameter("sequencialModelo", parametrosConsulta.getModelo().getSequencial());
		1124	}
274	espaco	1125	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicadorModeloFavorito())) {
		1126	query.setParameter("indicadorModeloFavorito", parametrosConsulta.getIndicadorModeloFavorito());
		1127	}
229	espaco	1128	List<Object[]> resultList = query.getResultList();
		1129	List<RankingProdutoDTO> produtos = new ArrayList<RankingProdutoDTO>();
		1130	for (Object[] objects : resultList) {
		1131	RankingProdutoDTO rankingProduto = new RankingProdutoDTO();
		1132	Produto produto = new Produto();
		1133	if (VerificadorUtil.naoEstaNulo(objects[0])) {
		1134	System.out.println(objects[0].toString());
		1135	produto.setSequencial(Long.parseLong(objects[0].toString()));
		1136	}
		1137	rankingProduto.setProduto(produto);
		1138	produtos.add(rankingProduto);
		1139	}
		1140	return produtos;
		1141	} catch(Exception ex) {
		1142	ex.printStackTrace();
		1143	return null;
		1144	}
		1145	}
		1146
		1147	private String adicionarVendasSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
		1148	StringBuilder sql = new StringBuilder("");
		1149	sql.append(", (SELECT COUNT(lanc.seq_produto) FROM sc_sec.sec_lancamento lanc ");
		1150	sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = lanc.seq_venda ");
		1151	sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
		1152	sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
		1153	sql.append("AND lanc.seq_produto = l.seq_produto AND lj.seq_loja = ");
		1154	sql.append(sequencialLoja);
		1155	sql.append(" GROUP BY lanc.seq_produto) AS vendas" + sequencialLoja + " ");
		1156	return sql.toString();
		1157	}
		1158
		1159	private String adicionarEstoqueSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
		1160	StringBuilder sql = new StringBuilder();
		1161	sql.append(", (SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
		1162	sql.append("WHERE pl.seq_produto = l.seq_produto ");
		1163	sql.append("AND pl.seq_loja = ");
		1164	sql.append(sequencialLoja);
		1165	sql.append(") AS estoque" + sequencialLoja + " ");
		1166	return sql.toString();
		1167	}
		1168
		1169	private String adicionarHavingSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta, Long sequencialLoja) {
		1170	StringBuilder sql = new StringBuilder();
		1171	sql.append("((SELECT SUM(pl.qtd_estoque) AS estoque FROM sc_sec.sec_produto_loja pl WHERE pl.seq_produto = l.seq_produto AND pl.seq_loja = ");
		1172	sql.append(sequencialLoja);
		1173	sql.append(") - (");
		1174	sql.append("SELECT COUNT(lanc.seq_produto) FROM sc_sec.sec_lancamento lanc ");
		1175	sql.append("LEFT JOIN sc_sec.sec_venda v ON v.seq_venda = lanc.seq_venda ");
		1176	sql.append("LEFT JOIN sc_sec.sec_loja lj ON v.seq_loja = lj.seq_loja ");
		1177	sql.append("WHERE v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal AND lanc.seq_produto = l.seq_produto ");
		1178	sql.append("AND lj.seq_loja = ");
		1179	sql.append(sequencialLoja);
		1180	sql.append(" GROUP BY lanc.seq_produto) ");
		1181	sql.append("* 1) * -1 > 0 ");
		1182	return sql.toString();
		1183	}
		1184
		1185	private String adicionarEstoqueSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1186	StringBuilder sql = new StringBuilder();
		1187	sql.append(", (");
		1188	sql.append("SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
		1189	sql.append("WHERE pl.seq_produto = l.seq_produto ");
		1190	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
		1191	sql.append("AND pl.seq_loja = :sequencialLoja ");
		1192	}
		1193	sql.append(") ");
		1194	return sql.toString();
		1195	}
		1196
		1197	private String adicionarParametrosSqlNativo(ParametrosConsultaProdutosVendidosDTO parametrosConsulta) {
		1198	StringBuilder sql = new StringBuilder("v.dth_venda >= :dataInicial AND v.dth_venda <= :dataFinal ");
		1199
		1200	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLojaSelecionada()) &&
		1201	VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstoqueMinimo())) {
		1202	sql.append("AND (");
		1203	sql.append("SELECT SUM(pl.qtd_estoque) FROM sc_sec.sec_produto_loja pl ");
		1204	sql.append("WHERE pl.seq_produto = l.seq_produto ");
		1205	sql.append("AND pl.seq_loja = ");
		1206	sql.append(parametrosConsulta.getLojaSelecionada().getSequencial());
		1207	sql.append(") >= ");
		1208	sql.append(parametrosConsulta.getEstoqueMinimo());
		1209	sql.append(" ");
		1210	}
		1211
		1212	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getLoja())) {
		1213	sql.append("AND lj.seq_loja = :sequencialLoja ");
		1214	}
		1215	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1216	sql.append("AND p.tip_produto = :tipoProduto ");
		1217	}
		1218
		1219	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getProduto())) {
		1220	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getSequencial())) {
		1221	sql.append("AND p.seq_produto = :sequencialProduto ");
		1222	}
		1223	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCodigo())) {
		1224	sql.append("AND p.cod_produto = :codigo ");
		1225	}
		1226	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getDescricao())) {
		1227	sql.append("AND ");
		1228	sql.append(sqlConsultarSemAcento("p.dsc_produto"));
		1229	sql.append(" like upper(:descricao) ");
		1230	}
		1231	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getEstilo())) {
		1232	sql.append("AND p.tip_estilo = :tipoEstilo ");
		1233	}
		1234	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getCor())) {
		1235	sql.append("AND p.tip_cor = :tipoCor ");
		1236	}
		1237	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getProduto().getGenero())) {
		1238	sql.append("AND p.tip_genero = :tipoGenero ");
		1239	}
		1240	}
		1241	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getMarca())) {
		1242	sql.append("AND ma.seq_marcal = :sequencialMarcaDoModelo ");
		1243	}
		1244	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
		1245	sql.append("AND m.seq_modelo = :sequencialModelo ");
		1246	}
274	espaco	1247	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsulta.getIndicadorModeloFavorito())) {
		1248	sql.append("AND m.ind_favorito = :indicadorModeloFavorito ");
		1249	}
229	espaco	1250	return sql.toString();
		1251	}
		1252
		1253	@Override
		1254	public List<RankingProdutoDTO> consultarProdutosMaisVendidos(Date dataInicial, Date dataFinal, Integer quantidadeProdutos, String tipoOrdenacao, Long sequencialLoja, String tipoProduto,
		1255	Produto produto, Marca marca) {
		1256	StringBuilder sql = new StringBuilder();
		1257	sql.append("SELECT new br.com.ec.domain.dto.RankingProdutoDTO(l.produto, SUM(l.valorVenda), SUM(l.valorCompra), SUM(l.valorVarejo - l.valorVenda), COUNT(l.produto)) FROM Lancamento l ");
		1258	sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
		1259	if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
		1260	sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
		1261	}
		1262	if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
		1263	sql.append("AND l.produto.tipo = :tipoProduto ");
		1264	}
		1265	if (VerificadorUtil.naoEstaNulo(produto)) {
		1266	if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigo())) {
		1267	sql.append("AND l.produto.codigo = :codigo ");
		1268	}
		1269	if (VerificadorUtil.naoEstaNuloOuVazio(produto.getDescricao())) {
		1270	sql.append("AND ");
		1271	sql.append(sqlConsultarSemAcento("l.produto.descricao"));
		1272	sql.append(" like upper(:descricao) ");
		1273	}
		1274	if (VerificadorUtil.naoEstaNuloOuVazio(produto.getEstilo())) {
		1275	sql.append("AND l.produto.estilo = :tipoEstilo ");
		1276	}
		1277	if (VerificadorUtil.naoEstaNuloOuVazio(produto.getGenero())) {
		1278	sql.append("AND l.produto.genero = :tipoGenero ");
		1279	}
		1280	}
		1281	if (VerificadorUtil.naoEstaNulo(marca)) {
		1282	sql.append("AND l.produto.modelo.marca.sequencial = :sequencialMarcaDoModelo ");
		1283	}
		1284
		1285	sql.append("GROUP BY l.produto ");
		1286	if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
		1287	sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
		1288	} else if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
		1289	sql.append("ORDER BY COUNT(l.produto) DESC ");
		1290	} else if (tipoOrdenacao.equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
		1291	sql.append("ORDER BY SUM(l.valorVenda) DESC ");
		1292	}
		1293	try {
		1294	TypedQuery<RankingProdutoDTO> query = getEntityManager().createQuery(sql.toString(), RankingProdutoDTO.class)
		1295	.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial))
		1296	.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal))
		1297	.setMaxResults(quantidadeProdutos);
		1298	if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
		1299	query.setParameter("sequencialLoja", sequencialLoja);
		1300	}
		1301	if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
		1302	query.setParameter("tipoProduto", tipoProduto);
		1303	}
		1304	if (VerificadorUtil.naoEstaNulo(produto)) {
		1305	if (VerificadorUtil.naoEstaNuloOuVazio(produto.getCodigo())) {
		1306	query.setParameter("codigo", produto.getCodigoProdutoPadrao());
		1307	}
		1308	if (VerificadorUtil.naoEstaNuloOuVazio(produto.getDescricao())) {
		1309	query.setParameter("descricao", "%" + removerAcentuacao(produto.getDescricao()) + "%");
		1310	}
		1311	if (VerificadorUtil.naoEstaNuloOuVazio(produto.getEstilo())) {
		1312	query.setParameter("tipoEstilo", produto.getEstilo());
		1313	}
		1314	if (VerificadorUtil.naoEstaNuloOuVazio(produto.getGenero())) {
		1315	query.setParameter("tipoGenero", produto.getGenero());
		1316	}
		1317	}
		1318	if (VerificadorUtil.naoEstaNulo(marca)) {
		1319	query.setParameter("sequencialMarcaDoModelo", marca.getSequencial());
		1320	}
		1321	return query.getResultList();
		1322	} catch(Exception ex) {
		1323	ex.printStackTrace();
		1324	return null;
		1325	}
		1326	}
		1327
		1328	@Override
		1329	public List<RankingModeloDTO> consultarModelosMaisVendidos(ParametrosConsultaModelosMaisVendidosDTO parametrosConsulta) {
		1330	StringBuilder sql = new StringBuilder();
		1331	sql.append("SELECT new br.com.ec.domain.dto.RankingModeloDTO(l.produto.modelo, SUM(l.valorVenda), SUM(l.valorCompra), COUNT(l.produto.modelo), ");
		1332	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
		1333	sql.append("(");
		1334	sql.append(adicionarConsultaDoEstoque(parametrosConsulta.getSequencialLoja(), "l.produto.modelo", parametrosConsulta.getTipoProduto(), parametrosConsulta.getEstiloProduto()));
		1335	sql.append("), ");
		1336	}
		1337	sql.append("(");
		1338	sql.append(adicionarConsultaDoEstoque(null, "l.produto.modelo", parametrosConsulta.getTipoProduto(), parametrosConsulta.getEstiloProduto()));
		1339	sql.append(")) FROM Lancamento l ");
		1340	sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
		1341	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
		1342	sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
		1343	}
		1344	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1345	sql.append("AND l.produto.tipo = :tipoProduto ");
		1346	}
		1347	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
		1348	sql.append("AND l.produto.modelo = :modelo ");
		1349	}
		1350	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstiloProduto())) {
		1351	sql.append("AND l.produto.estilo = :estiloProduto ");
		1352	}
		1353	sql.append("GROUP BY l.produto.modelo ");
		1354	if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.LUCRO.getValor())) {
		1355	sql.append("ORDER BY SUM(l.valorVenda - l.valorCompra) DESC ");
		1356	} else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.QUANTIDADE.getValor())) {
		1357	sql.append("ORDER BY COUNT(l.produto.modelo) DESC ");
		1358	} else if (parametrosConsulta.getTipoOrdenacao().equals(TipoOrdenacaoMaisVendidos.VALOR_VENDIDO.getValor())) {
		1359	sql.append("ORDER BY SUM(l.valorVenda) DESC ");
		1360	}
		1361	try {
		1362	TypedQuery<RankingModeloDTO> query = getEntityManager().createQuery(sql.toString(), RankingModeloDTO.class)
		1363	.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
		1364	.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
		1365	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getQuantidadeModelos())) {
		1366	query.setMaxResults(parametrosConsulta.getQuantidadeModelos());
		1367	}
		1368	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
		1369	query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
		1370	}
		1371	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1372	query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
		1373	}
		1374	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getModelo())) {
		1375	query.setParameter("modelo", parametrosConsulta.getModelo());
		1376	}
		1377	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getEstiloProduto())) {
		1378	query.setParameter("estiloProduto", parametrosConsulta.getEstiloProduto());
		1379	}
		1380	return query.getResultList();
		1381	} catch(Exception ex) {
		1382	ex.printStackTrace();
		1383	return null;
		1384	}
		1385	}
		1386
		1387	private String adicionarConsultaDoEstoque(Long sequencialLoja, String modelo, String tipoProduto, String estiloProduto) {
		1388	StringBuilder sql = new StringBuilder();
		1389	sql.append("SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl ");
		1390	sql.append("WHERE pl.produto.modelo = " + modelo + " ");
		1391	if (VerificadorUtil.naoEstaNuloOuVazio(sequencialLoja)) {
		1392	sql.append("AND pl.loja.sequencial = :sequencialLoja ");
		1393	}
		1394	if (VerificadorUtil.naoEstaNuloOuVazio(tipoProduto)) {
		1395	sql.append("AND pl.produto.tipo = :tipoProduto ");
		1396	}
		1397	if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
		1398	sql.append("AND pl.produto.estilo = :estiloProduto ");
		1399	}
		1400	return sql.toString().trim();
		1401	}
		1402	*/
		1403	/*
		1404	private String adicionarQueryConsultaDoEstoque(Long sequencialLoja, Modelo modelo, String tipoProduto, String estiloProduto) {
		1405	try {
		1406	TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class);
		1407	if (VerificadorUtil.naoEstaNuloOuVazio(sequencialLoja)) {
		1408	query.setParameter("sequencialLoja", sequencialLoja);
		1409	}
		1410	if (VerificadorUtil.naoEstaNuloOuVazio(tipoProduto)) {
		1411	query.setParameter("tipoProduto", tipoProduto);
		1412	}
		1413	if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
		1414	query.setParameter("estiloProduto", estiloProduto);
		1415	}
		1416	// if (VerificadorUtil.naoEstaNuloOuVazio(genero)) {
		1417	// query.setParameter("tipoGenero", genero);
		1418	// }
		1419	query.setParameter("sequencialModelo", modelo.getSequencial());
		1420	// if (VerificadorUtil.naoEstaNuloOuVazio(descricaoProduto)) {
		1421	// query.setParameter("descricaoProduto", "%" + removerAcentuacao(descricaoProduto) + "%");
		1422	// }
		1423	return sql.toString();
		1424	}
		1425	*/
		1426	/*
		1427	@Override
		1428	public List<VendasDTO> consultarVendas(ParametrosConsultaVendasDTO parametrosConsultaVendasDTO) {
		1429	StringBuilder sql = new StringBuilder();
		1430	try {
		1431	sql.append("SELECT ");
		1432	sql.append("v.seq_venda, ");
		1433	sql.append("l.dsc_loja, v.dth_venda, ");
		1434	sql.append("(SELECT SUM(lc.val_venda) FROM sc_sec.sec_lancamento lc WHERE lc.seq_venda = v.seq_venda AND lc.ind_ativo = true), ");
		1435	sql.append("v.tip_situacao, ");
		1436	sql.append("us.dsc_nome, v.dsc_observacao, ");
		1437	sql.append("p.cod_produto, m.dsc_modelo, p.dsc_produto, lanc.val_venda ");
		1438	sql.append("FROM sc_sec.sec_venda v ");
		1439	sql.append("LEFT JOIN sc_sec.sec_loja l ON l.seq_loja = v.seq_loja ");
		1440	sql.append("LEFT JOIN sc_sec.sec_vendedor ve ON ve.seq_vendedor = v.seq_vendedor ");
		1441	sql.append("LEFT JOIN sc_sec.sec_usuario us ON us.seq_pessoa = ve.seq_pessoa ");
		1442	sql.append("LEFT JOIN sc_sec.sec_lancamento lanc ON lanc.seq_venda = v.seq_venda ");
		1443	sql.append("LEFT JOIN sc_sec.sec_produto p ON p.seq_produto = lanc.seq_produto ");
		1444	sql.append("LEFT JOIN sc_sec.sec_modelo m ON m.seq_modelo = p.seq_modelo ");
		1445	sql.append("WHERE 1=1 ");
		1446	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getLoja())) {
		1447	sql.append("AND l.seq_loja.sequencial = :sequencialLoja ");
		1448	}
		1449	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoVenda())) {
		1450	sql.append("AND v.tip_situacao = :tipoSituacao ");
		1451	}
		1452	// if (VerificadorUtil.naoEstaNuloOuVazio(((ParametrosConsultaVendasDTO)parametros).getVendedor())) {
		1453	// sql.append("AND e.vendedor.sequencial = :sequencialVendedor ");
		1454	// }
		1455	// if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getIndicacao())) {
		1456	// sql.append("AND e.indicacao.sequencial = :sequencialIndicacao ");
		1457	// }
		1458	*/
		1459	//TODO: VERIFICAR LANÇAMENTOS COM MAIS PAGAMENTOS QUE LANÇAMENTOS
		1460	/*
		1461	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda())) {
		1462	if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.NENHUMA.getValor())) {
		1463	sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e) = 0 ");
		1464	// sql.append("AND ((SELECT COUNT(vf) FROM VendaFormaPagamento vf WHERE vf.venda = e) > (SELECT COUNT(cr) FROM ContaAReceber cr WHERE cr.venda = e)) ");
		1465	}
		1466	if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.QUITADO.getValor())) {
		1467	sql.append("AND (SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) = 0 ");
		1468	sql.append("AND (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) > 0 ");
		1469	}
		1470	if (parametrosConsultaVendasDTO.getSituacaoFinanceiraVenda().equals(br.com.ec.domain.model.tipos.TipoSituacaoFinanceira.PENDENCIAS.getValor())) {
		1471	sql.append("AND ((SELECT COUNT(p) FROM Parcela p WHERE p.conta.venda = e AND p.dataPagamento is null AND p.indicadorAtivo = true) > 0 ");
		1472	sql.append("OR (SELECT COUNT(c) FROM Conta c WHERE c.venda = e AND c.indicadorAtivo = true) = 0) ");
		1473	}
		1474	}
		1475	*/
		1476	/*
		1477	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataVendas())
		1478	\|\| VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataInicial())
		1479	\|\| VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataFinal())) {
		1480	sql.append("AND v.dth_venda >= :dataInicial ");
		1481	sql.append("AND v.dth_venda <= :dataFinal ");
		1482	}
		1483
		1484	sql.append("ORDER BY v.seq_venda ");
		1485
		1486	Query query = getEntityManager().createNativeQuery(sql.toString());
		1487
		1488	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getLoja())) {
		1489	query.setParameter("sequencialLoja", parametrosConsultaVendasDTO.getLoja().getSequencial());
		1490	}
		1491	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getSituacaoVenda())) {
		1492	query.setParameter("tipoSituacao", parametrosConsultaVendasDTO.getSituacaoVenda());
		1493	}
		1494	// if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getVendedor())) {
		1495	// query.setParameter("sequencialVendedor", parametrosConsultaVendasDTO.getVendedor().getSequencial());
		1496	// }
		1497	// if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getIndicacao())) {
		1498	// query.setParameter("sequencialIndicacao", ((ParametrosConsultaVendasDTO)parametros).getIndicacao().getSequencial());
		1499	// }
		1500	if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataInicial())
		1501	&& VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataFinal())) {
		1502	Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaVendasDTO.getDataInicial());
		1503	Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaVendasDTO.getDataFinal());
		1504	query.setParameter("dataInicial", dataInicial);
		1505	query.setParameter("dataFinal", dataFinal);
		1506	} else if (VerificadorUtil.naoEstaNuloOuVazio(parametrosConsultaVendasDTO.getDataVendas())) {
		1507	Date dataInicial = DataUtils.getDataComHorarioMinimo(parametrosConsultaVendasDTO.getDataVendas());
		1508	Date dataFinal = DataUtils.getDataComHorarioMaximo(parametrosConsultaVendasDTO.getDataVendas());
		1509	query.setParameter("dataInicial", dataInicial);
		1510	query.setParameter("dataFinal", dataFinal);
		1511	}
		1512
		1513	List<Object[]> resultList = query.getResultList();
		1514
		1515	List<VendasDTO> vendas = new ArrayList<VendasDTO>();
		1516
		1517	// PREENCHER VENDAS
		1518	for (Object[] objects : resultList) {
		1519	VendasDTO venda = new VendasDTO();
		1520	venda.setSequencial(Long.parseLong(objects[0].toString()));
		1521	if (!vendas.contains(venda)) {
		1522	venda.setDescricaoLoja(objects[1].toString());
		1523	// System.out.println(objects[2].toString());
		1524	// venda.setDataVenda(new Date(objects[2].toString()));
		1525	venda.setValorVenda(Double.parseDouble(objects[3].toString()));
		1526	venda.setTipoSituacao(objects[4].toString());
		1527	venda.setNomeUsuario(objects[5].toString());
		1528	venda.setObservacao(objects[6].toString());
		1529	vendas.add(venda);
		1530	}
		1531	}
		1532
		1533	for (Object[] objects : resultList) {
		1534	VendasDTO venda = new VendasDTO();
		1535	venda.setSequencial(Long.parseLong(objects[0].toString()));
		1536
		1537	VendasLancamentoDTO lancamento = new VendasLancamentoDTO();
		1538	lancamento.setCodigoProduto(objects[7].toString());
		1539	if (VerificadorUtil.naoEstaNulo(objects[8])) {
		1540	lancamento.setDescricaoModelo(objects[8].toString());
		1541	}
		1542	lancamento.setDescricaoProduto(objects[9].toString());
		1543	lancamento.setValorVenda(Double.parseDouble(objects[10].toString()));
		1544
		1545	VendasDTO vendaCompleta = vendas.get(vendas.indexOf(venda));
		1546	vendaCompleta.getLancamentos().add(lancamento);
		1547	vendas.remove(vendas.indexOf(venda));
		1548	vendas.add(vendaCompleta);
		1549	}
		1550	return vendas;
		1551	} catch (NoResultException e) {
		1552	return null;
		1553	}
		1554	}
		1555
		1556	@Override
		1557	public Integer obterQuantidadeProdutosVendidosPorEstiloEeGenero(Date dataInicial, Date dataFinal, Long sequencialLoja, Long sequencialModelo, String tipoProduto, String estiloProduto, String tipoGenero) {
		1558	StringBuilder sql = new StringBuilder();
		1559	sql.append("SELECT COUNT(l) FROM Lancamento l ");
		1560	sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
		1561	if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
		1562	sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
		1563	}
		1564	if (VerificadorUtil.naoEstaNulo(sequencialModelo)) {
		1565	sql.append("AND l.produto.modelo.sequencial = :sequencialModelo ");
		1566	}
		1567	if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
		1568	sql.append("AND l.produto.tipo = :tipoProduto ");
		1569	}
		1570	if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
		1571	sql.append("AND l.produto.estilo = :tipoEstilo ");
		1572	}
		1573	if (VerificadorUtil.naoEstaNuloOuVazio(tipoGenero)) {
		1574	sql.append("AND l.produto.genero = :tipoGenero ");
		1575	}
		1576	*/
		1577	/sql.append("GROUP BY l.produto.estilo ");/
		1578	/*
		1579	try {
		1580	TypedQuery<Long> query = getEntityManager().createQuery(sql.toString(), Long.class)
		1581	.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(dataInicial))
		1582	.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(dataFinal));
		1583	if (VerificadorUtil.naoEstaNulo(sequencialLoja)) {
		1584	query.setParameter("sequencialLoja", sequencialLoja);
		1585	}
		1586	if (VerificadorUtil.naoEstaNulo(sequencialModelo)) {
		1587	query.setParameter("sequencialModelo", sequencialModelo);
		1588	}
		1589	if (VerificadorUtil.naoEstaNulo(tipoProduto)) {
		1590	query.setParameter("tipoProduto", tipoProduto);
		1591	}
		1592	if (VerificadorUtil.naoEstaNuloOuVazio(estiloProduto)) {
		1593	query.setParameter("tipoEstilo", estiloProduto);
		1594	}
		1595	if (VerificadorUtil.naoEstaNuloOuVazio(tipoGenero)) {
		1596	query.setParameter("tipoGenero", tipoGenero);
		1597	}
		1598	return query.getSingleResult().intValue();
		1599	} catch(Exception ex) {
		1600	ex.printStackTrace();
		1601	return null;
		1602	}
		1603	}
		1604	*/
		1605	/*
		1606	@Override
		1607	public RankingComprasTransferenciasEstiloDTO consultarVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
		1608	StringBuilder sql = new StringBuilder();
		1609	sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO(");
		1610	sql.append("l.produto.estilo");
		1611	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, null) + ")");
		1612	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor()) + ")");
		1613	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor()) + ")");
		1614	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor()) + ")");
		1615	sql.append(", COUNT(0), COUNT(0), COUNT(0), COUNT(0)");
		1616	sql.append(") FROM Lancamento l ");
		1617	sql.append("WHERE l.venda.dataVenda >= :dataInicial AND l.venda.dataVenda <= :dataFinal ");
		1618	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
		1619	sql.append("AND l.venda.loja.sequencial = :sequencialLoja ");
		1620	}
		1621	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1622	sql.append("AND l.produto.tipo = :tipoProduto ");
		1623	}
		1624	sql.append("AND l.produto.modelo = :modelo ");
		1625	sql.append("AND l.produto.estilo = :estiloProduto ");
		1626	sql.append("GROUP BY l.produto.estilo ");
		1627	try {
		1628	TypedQuery<RankingComprasTransferenciasEstiloDTO> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloDTO.class)
		1629	.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()))
		1630	.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
		1631	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
		1632	query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
		1633	}
		1634	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1635	query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
		1636	}
		1637	if (VerificadorUtil.naoEstaNulo(modelo)) {
		1638	query.setParameter("modelo", modelo);
		1639	}
		1640	query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
		1641	return query.getSingleResult();
		1642	} catch(NoResultException nr) {
		1643	RankingComprasTransferenciasEstiloDTO rankingComprasTransferenciasEstilo = new RankingComprasTransferenciasEstiloDTO();
		1644	rankingComprasTransferenciasEstilo.setEstilo(TipoEstiloProduto.parse(parametrosConsulta.getEstilo()));
		1645	return rankingComprasTransferenciasEstilo;
		1646	} catch(Exception ex) {
		1647	ex.printStackTrace();
		1648	return null;
		1649	}
		1650	}
		1651	*/
		1652	/*
		1653	private String adicionarConsultaQuantidadeVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero, Boolean consultarPorLoja) {
		1654	StringBuilder sql = new StringBuilder();
		1655	sql.append("SELECT COUNT(lanc) FROM Lancamento lanc ");
		1656	sql.append("WHERE lanc.venda.dataVenda >= :dataInicial AND lanc.venda.dataVenda <= :dataFinal ");
		1657	sql.append("AND lanc.produto.modelo = :modelo ");
		1658	sql.append("AND lanc.produto.estilo = :estiloProduto ");
		1659	if (consultarPorLoja) {
		1660	sql.append("AND lanc.venda.loja = l ");
		1661	}
		1662	sql.append("AND lanc.produto.genero = '" + genero + "' ");
		1663	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1664	sql.append("AND lanc.produto.tipo = :tipoProduto ");
		1665	}
		1666	return sql.toString().trim();
		1667	}
		1668
		1669	@Override
		1670	public RankingComprasTransferenciasEstiloDTO consultarEstoqueEeVendasPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
		1671	StringBuilder sql = new StringBuilder();
		1672	sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloDTO(");
		1673	sql.append("pLoja.produto.estilo");
		1674	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), false) + ")");
		1675	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), false) + ")");
		1676	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), false) + ")");
		1677	sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), false) + ")");
		1678	sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), false) + ")");
		1679	sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), false) + ")");
		1680	sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor()) + ")");
		1681	sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor()) + ")");
		1682	sql.append(", (" + adicionarConsultaPedidosCompraPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor()) + ")");
		1683	// ADICIONAR QUANTIDADE JÁ SOLCITADO PARA COMPRA (VERIFICADO + SOLICITADO)
		1684	sql.append(") FROM ProdutoLoja pLoja ");
		1685	sql.append("WHERE pLoja.produto.estilo = :estiloProduto ");
		1686	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
		1687	sql.append("AND pLoja.loja.sequencialLoja = :sequencialLoja ");
		1688	}
		1689	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1690	sql.append("AND pLoja.produto.tipo = :tipoProduto ");
		1691	}
		1692	sql.append("AND pLoja.produto.modelo = :modelo ");
		1693	sql.append("GROUP BY pLoja.produto.estilo ");
		1694	try {
		1695	TypedQuery<RankingComprasTransferenciasEstiloDTO> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloDTO.class);
		1696	query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()));
		1697	query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
		1698	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
		1699	query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
		1700	}
		1701	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1702	query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
		1703	}
		1704	if (VerificadorUtil.naoEstaNulo(modelo)) {
		1705	query.setParameter("modelo", modelo);
		1706	}
		1707	query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
		1708	return query.getSingleResult();
		1709	} catch(NoResultException nr) {
		1710	RankingComprasTransferenciasEstiloDTO rankingComprasTransferenciasEstilo = new RankingComprasTransferenciasEstiloDTO();
		1711	rankingComprasTransferenciasEstilo.setEstilo(TipoEstiloProduto.parse(parametrosConsulta.getEstilo()));
		1712	return rankingComprasTransferenciasEstilo;
		1713	} catch(Exception ex) {
		1714	ex.printStackTrace();
		1715	return null;
		1716	}
		1717	}
		1718
		1719	private String adicionarConsultaEstoquePorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero, Boolean consultarPorLoja) {
		1720	StringBuilder sql = new StringBuilder();
		1721	sql.append("SELECT SUM(pl.quantidadeEstoque) FROM ProdutoLoja pl ");
		1722	sql.append("WHERE pl.produto.modelo = :modelo ");
		1723	sql.append("AND pl.produto.estilo = :estiloProduto ");
		1724	if (consultarPorLoja) {
		1725	sql.append("AND pl.loja = l ");
		1726	}
		1727	sql.append("AND pl.produto.genero = '" + genero + "' ");
		1728	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1729	sql.append("AND pl.produto.tipo = :tipoProduto ");
		1730	}
		1731	return sql.toString().trim();
		1732	}
		1733
		1734	private String adicionarConsultaPedidosCompraPorEstilo(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, String genero) {
		1735	StringBuilder sql = new StringBuilder();
		1736	sql.append("SELECT SUM(ppc.quantidadeParaComprar) FROM ProdutoPedidoCompra ppc ");
		1737	sql.append("WHERE ppc.status IN ('" + TipoStatusPedidoCompra.VERIFICADO.getValor() + "','" + TipoStatusPedidoCompra.SOLICITADO.getValor() + "') ");
		1738	sql.append("AND ppc.produto.modelo = :modelo ");
		1739	sql.append("AND ppc.produto.estilo = :estiloProduto ");
		1740	sql.append("AND ppc.produto.genero = '" + genero + "' ");
		1741	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1742	sql.append("AND ppc.produto.tipo = :tipoProduto ");
		1743	}
		1744	return sql.toString().trim();
		1745	}
		1746
		1747	@Override
		1748	public List<RankingComprasTransferenciasEstiloPorLoja> consultarEstoqueEeVendasEstiloPorLoja(ParametrosConsultaParaComprasTransferenciasDTO parametrosConsulta, Modelo modelo) {
		1749	StringBuilder sql = new StringBuilder();
		1750	sql.append("SELECT new br.com.ec.domain.dto.RankingComprasTransferenciasEstiloPorLoja(");
		1751	sql.append("l");
		1752	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), true) + ")");
		1753	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), true) + ")");
		1754	sql.append(", (" + adicionarConsultaQuantidadeVendasPorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), true) + ")");
		1755	sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.UNISSEX.getValor(), true) + ")");
		1756	sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.MASCULINO.getValor(), true) + ")");
		1757	sql.append(", (" + adicionarConsultaEstoquePorEstilo(parametrosConsulta, TipoGenero.FEMININO.getValor(), true) + ")");
		1758	sql.append(", " + parametrosConsulta.getQuantidadeMinimaComprar());
		1759	// ADICIONAR QUANTIDADE JÁ SOLICITADO PARA COMPRA (VERIFICADO + SOLICITADO)
		1760	sql.append(") FROM Loja l ");
		1761	sql.append("WHERE l.ativo IS TRUE ");
		1762	sql.append("GROUP BY l, l.ordenador ");
		1763	sql.append("ORDER BY l.ordenador ");
		1764	try {
		1765	TypedQuery<RankingComprasTransferenciasEstiloPorLoja> query = getEntityManager().createQuery(sql.toString(), RankingComprasTransferenciasEstiloPorLoja.class);
		1766	query.setParameter("dataInicial", DataUtils.getDataComHorarioMinimo(parametrosConsulta.getDataInicial()));
		1767	query.setParameter("dataFinal", DataUtils.getDataComHorarioMaximo(parametrosConsulta.getDataFinal()));
		1768	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getSequencialLoja())) {
		1769	query.setParameter("sequencialLoja", parametrosConsulta.getSequencialLoja());
		1770	}
		1771	if (VerificadorUtil.naoEstaNulo(parametrosConsulta.getTipoProduto())) {
		1772	query.setParameter("tipoProduto", parametrosConsulta.getTipoProduto());
		1773	}
		1774	if (VerificadorUtil.naoEstaNulo(modelo)) {
		1775	query.setParameter("modelo", modelo);
		1776	}
		1777	query.setParameter("estiloProduto", parametrosConsulta.getEstilo());
		1778	return query.getResultList();
		1779	} catch(Exception ex) {
		1780	ex.printStackTrace();
		1781	return null;
		1782	}
		1783	}
		1784	*/
		1785	}

Subversion Repositories Integrator Subversion

(root)/projeto-novo/espacocase-novo/src/main/java/br/com/ec/repository/jpa/VendaRepositoryJpaImpl.java - Rev 450