Comparar dados antes de gravar e atualizar javaee/jsf

27/11/2018

9

Ola. Preciso de um auxilio. Estou estudando jsf e estou desenvolvolveno uma aplicação para fins de estudo mesmo. A questao é a seguinte. Ante de gravar no banco de dados, a aplcação analise o seguinte:

- Ao salvar, verifica antes se o nome do setor já exista no banco de dados (postgres), senão existir, grave, senao nao permita;
- Ao atualizar, tbem execute a mesma analise e atualize os dados, se alterar o nome, tem que analisar se este nome já existe no banco de dados pra nao salvar repetido.
- Data de cadastro deve ser em ao salvar e e data de alteração tem que ser em atualizar.
Arquivo entidade:
Arquivo entidade:
package entidades;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;

@SuppressWarnings("serial")
@Entity
public class Setor extends GenericDomain {
	
	@Column(name = "nome",length =20, nullable = false)
	private String nome;
	
	@Column( name = "status",length =10)
	private String status;

    @Temporal(TemporalType.TIMESTAMP)
    private Date dataCadastro;

    @Temporal(TemporalType.TIMESTAMP)
    private Date dataAlteracao;

    private Long usuarioAlteracao;

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public Date getDataCadastro() {
		return dataCadastro;
	}

	public void setDataCadastro(Date dataCadastro) {
		this.dataCadastro = dataCadastro;
	}

	public Date getDataAlteracao() {
		return dataAlteracao;
	}

	public void setDataAlteracao(Date dataAlteracao) {
		this.dataAlteracao = dataAlteracao;
	}

	public Long getUsuarioAlteracao() {
		return usuarioAlteracao;
	}

	public void setUsuarioAlteracao(Long usuarioAlteracao) {
		this.usuarioAlteracao = usuarioAlteracao;
	}

	public Setor(String nome, String status, Date dataCadastro, Date dataAlteracao, Long usuarioAlteracao) {
		super();
		this.nome = nome;
		this.status = status;
		this.dataCadastro = dataCadastro;
		this.dataAlteracao = dataAlteracao;
		this.usuarioAlteracao = usuarioAlteracao;
	}

	public Setor() {
		super();
	}

	@Override
	public String toString() {
		return "Area [nome=" + nome + ", status=" + status + ", dataCadastro=" + dataCadastro + ", dataAlteracao="
				+ dataAlteracao + ", usuarioAlteracao=" + usuarioAlteracao + "]";
	}

	
}

meubean:
public class SetorBean implements Serializable {
private Setor setor;
private List setores;

public Setor getSetor() {
	return setor;
}

public void setSetor(Setor setor) {
	this.setor = setor;
}

public List<Setor> getSetores() {
	return setores;
}

public void setSetores(List<Setor> setores) {
	this.setores = setores;
}

@PostConstruct
public void listar() {
	try {
		SetorDAO dao = new SetorDAO();
		setores = dao.listar();
	} catch (RuntimeException erro) {
		Messages.addGlobalError("Ocorreu um erro ao tentar listar os setores");
		erro.printStackTrace();
	}
}

public void novo() {
	setor = new Setor();
}

public void salvar() {
	try {

		SetorDAO dao = new SetorDAO();
		setor.setDataCadastro(new Date());
		dao.merge(setor);

		setor = new Setor();
		setores = dao.listar();

		Messages.addGlobalInfo("Setor salvo com sucesso");
	} catch (RuntimeException erro) {
		Messages.addGlobalError("Ocorreu um erro ao tentar salvar o setor");
		erro.printStackTrace();
	}
}

public void excluir(ActionEvent evento) {
	try {
		setor = (Setor) evento.getComponent().getAttributes().get("setorSelecionado");

		SetorDAO dao = new SetorDAO();
		dao.excluir(setor);
		setores = dao.listar();

		Messages.addGlobalInfo("Setor removido com sucesso");
	} catch (RuntimeException erro) {
		Messages.addFlashGlobalError("Ocorreu um erro ao tentar remover o setor");
		erro.printStackTrace();
	}
}

public void editar(ActionEvent evento) {
	setor = (Setor) evento.getComponent().getAttributes().get("setorSelecionado");
}

meu GenericDAO:
ublic class GenericDAO {
private Class classe;

@SuppressWarnings("unchecked")
public GenericDAO() {
	this.classe = (Class<Entidade>) ((ParameterizedType) getClass().getGenericSuperclass())
			.getActualTypeArguments()[0];
}

public void salvar(Entidade entidade) {
	Session sessao = HibernateUtil.getFabricaDeSessoes().openSession();
	Transaction transacao = null;

	try {
		transacao = sessao.beginTransaction();
		sessao.save(entidade);
		transacao.commit();
	} catch (RuntimeException erro) {
		if (transacao != null) {
			transacao.rollback();
		}
		throw erro;
	} finally {
		sessao.close();
	}
}

@SuppressWarnings("unchecked")
public List<Entidade> listar() {
	Session sessao = HibernateUtil.getFabricaDeSessoes().openSession();
	try {
		Criteria consulta = sessao.createCriteria(classe);
		List<Entidade> resultado = consulta.list();
		return resultado;
	} catch (RuntimeException erro) {
		throw erro;
	} finally {
		sessao.close();
	}
}

@SuppressWarnings("unchecked")
public Entidade buscar(Long codigo) {
	Session sessao = HibernateUtil.getFabricaDeSessoes().openSession();
	try {
		Criteria consulta = sessao.createCriteria(classe);
		consulta.add(Restrictions.idEq(codigo));
		Entidade resultado = (Entidade) consulta.uniqueResult();
		return resultado;
	} catch (RuntimeException erro) {
		throw erro;
	} finally {
		sessao.close();
	}
}

public void excluir(Entidade entidade) {
	Session sessao = HibernateUtil.getFabricaDeSessoes().openSession();
	Transaction transacao = null;

	try {
		transacao = sessao.beginTransaction();
		sessao.delete(entidade);
		transacao.commit();
	} catch (RuntimeException erro) {
		if (transacao != null) {
			transacao.rollback();
		}
		throw erro;
	} finally {
		sessao.close();
	}
}

public void editar(Entidade entidade) {
	Session sessao = HibernateUtil.getFabricaDeSessoes().openSession();
	Transaction transacao = null;

	try {
		transacao = sessao.beginTransaction();
		sessao.update(entidade);
		transacao.commit();
	} catch (RuntimeException erro) {
		if (transacao != null) {
			transacao.rollback();
		}
		throw erro;
	} finally {
		sessao.close();
	}
}

public void merge(Entidade entidade) {
	Session sessao = HibernateUtil.getFabricaDeSessoes().openSession();
	Transaction transacao = null;

	try {
		transacao = sessao.beginTransaction();
		sessao.merge(entidade);
		transacao.commit();
	} catch (RuntimeException erro) {
		if (transacao != null) {
			transacao.rollback();
		}
		throw erro;
	} finally {
		sessao.close();
	}
}

minha parte do pagina xhtml (botao salvar):
…
<h:panelGrid columns=“2”>
<p:commandButton value=“Salvar” icon=“ui-icon-circle-check"
actionListener=”#{setorBean.salvar()}“
update=”:mensagem :formCadastro:painel :formListagem:tabela" />
<p:commandButton value=“Fechar” oncomplete=“PF(‘dialogo’).hide();” />
</h:panelGrid>

minhar parte da pagina xhtml onde faz edição:
p:commandButton icon=“ui-icon-pencil"
actionListener=”#{setorBean.editar}“
update=”:formCadastro:painel" oncomplete=“PF(‘dialogo’).show();”>
<f:attribute name=“setorSelecionado” value="#" />
</p:commandButton>

É isso, se alguem puder me ajudar, agradeço.
Responder

Posts

11/12/2018

Kelvin A

Acho que deixando o campo como Unique resolveria a questão da comparação, caso não resolva você precisa chamar um método que percorra todos os valores da coluna, comparando um a um, e no fim dele chamar o método salvar. Creio que unique seja a melhor opção.
Responder