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

Subversion Repositories Integrator Subversion

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