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

Subversion Repositories Integrator Subversion

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