Buscar este blog

lunes, 28 de octubre de 2019

CRUD sencillo (codigo base)

Controller
 
 /*ingresar nueva categoria*/
    public void createCategory() {
        FacesContext context = FacesContext.getCurrentInstance();
        CategoryDao dao = new CategoryDao();

        if (dao.create(cat)) {
            RequestContext.getCurrentInstance().execute("PF('Wnew').hide();");
            RequestContext.getCurrentInstance().execute("newCategory();");
            context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "EXITO", "Categoria guardada"));
        } else {
            context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "ERROR", "No se pudo gaurdar la categoria"));
        }
    }
    
    //BUSCAR CATEGORIA
    public void find(int id) {
        CategoryDao dao = new CategoryDao();
        cat = dao.find(id);
    }

    /*actualizar una categoria*/
    public void editCategory() {
        FacesContext context = FacesContext.getCurrentInstance();
        CategoryDao dao = new CategoryDao();

        if (dao.edit(cat)) {
            RequestContext.getCurrentInstance().execute("PF('Wedit').hide();");
            context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "EXITO", "Categoria actualizada"));
        } else {
            context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "ERROR", "No se pudo actualizada categoria"));
        }
    }
 
//LISTA DE CATEGORIA POR ID
    private List<ViewProductCategory> listInventory;
    
    public List<ViewProductCategory> getListInventory() {
        InventoryCategoryListDao dao = new InventoryCategoryListDao();
        return dao.findAllByCategory(idCategory);
    }
 
DAO
 
public class CategoryDao {
    
    EntityManager em = JPAUtil.getEntityManagerFactory().createEntityManager();

    /*método para listar las categorias*/
    public List<DboCategory> finAll() {
        Query query = em.createNamedQuery("DboCategory.findAll");
        return query.getResultList();
    }

    /*buscar categoria por ID*/
    public DboCategory find(int id) {
        return em.find(DboCategory.class, id);
    }

    /*gaurdar una categoria*/
    public boolean create(DboCategory c) {
        boolean flag = false;

        try {
            em.getTransaction().begin();
            em.persist(c);
            em.getTransaction().commit();
            flag = true;
        } catch (Exception e) {
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
        return flag;
    }

    /* EDITAR CATEGORIA */
    public boolean edit(DboCategory c) {
        boolean flag = false;

        try {
            em.getTransaction().begin();
            em.merge(c);
            em.getTransaction().commit();
            flag = true;
        } catch (Exception e) {
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
        return flag;
    }

    /*eliminar una categoria*/
    public boolean remove(int id) {
        boolean flag = false;

        try {
            em.getTransaction().begin();
            em.remove(em.find(DboCategory.class, id));
            em.getTransaction().commit();
            flag = true;
        } catch (Exception e) {
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
        return flag;
    }
}

jpaUtil
public class JPAUtil {
    
    private static final String PERSISTENCE_UNIT_NAME = "misePU";
    private static EntityManagerFactory factory;
    
    public static EntityManagerFactory getEntityManagerFactory() {
        if (factory == null) {
            factory = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
        }
        return factory;
    }
}
 
 
en No hay comentarios:
Etiquetas: ,

crud java usando Abstract facade

package com.banco.utils;

import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;

public class JPAUtils {
    private static final String PERSISTENCE_UNIT_NAME = "PROJECT-BANCOPU";
    private static EntityManagerFactory factory;
    
    public static EntityManagerFactory getEntityManagerFactory( ) {
        
        if (factory == null) {
            factory = Persistence.createEntityManagerFactory(PERSISTENCE_UNIT_NAME);
        }
        
        return factory;
    }
}

ABSTRACT FACADE


import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.criteria.CriteriaQuery;

public abstract class AbstractFacade<T> {

    private Class<T> entityClass;

    public AbstractFacade(Class<T> entityClass) {
        this.entityClass = entityClass;
    }
    
    protected abstract EntityManager getEntityManager();
    
    public void create(T entity) {
        EntityManager em = getEntityManager();
        
        try {
            em.getTransaction().begin();
            em.persist(entity);
            em.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            em.getTransaction().rollback();
        } finally {
            em.close();
        }
    }
    
    public List<T> findAll() {
        CriteriaQuery<T> cq = getEntityManager().getCriteriaBuilder().createQuery(entityClass);
        return getEntityManager().createQuery(cq).getResultList();
    }
    
    public T find(Object id) {
        return getEntityManager().find(entityClass, id);
    }
    
    
}


DAO


import java.io.Serializable;

import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;

import com.banco.entity.Cliente;
import com.banco.utils.JPAUtils;

public class ClienteFacade extends AbstractFacade<Cliente> implements Serializable {

    private static final long serialVersionUID = 1L;
    private EntityManager em;

    public ClienteFacade() {
        super(Cliente.class);
        getEntityManager();
    }

    @Override
    protected EntityManager getEntityManager() {

        if (em == null) {
            em = JPAUtils.getEntityManagerFactory().createEntityManager();
        }

        return em;
    }

    public Cliente findByDui(String dui) {
        Cliente c = null;

        try {
            TypedQuery<Cliente> q = em.createQuery("SELECT c FROM Cliente c WHERE c.dui LIKE :dui", Cliente.class);
            q.setParameter("dui", "%" + dui);

            c = q.getSingleResult();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return c;
    }

}

CONTROLLER

import java.io.Serializable;
import java.util.Date;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;

import com.banco.dao.ClienteFacade;
import com.banco.entity.Cliente;

@ManagedBean
@RequestScoped
public class ClienteController implements Serializable {

    private ClienteFacade cf;
    private Cliente cli;

    public Cliente getCli() {
        return cli;
    }

    public void setCli(Cliente cli) {
        this.cli = cli;
    }

    @PostConstruct
    public void init() {
        cf = new ClienteFacade();
        cli = new Cliente();
    }

    public List<Cliente> list;

    public List<Cliente> getList() {
        return cf.findAll();
    }

    public void create() {
        FacesContext context = FacesContext.getCurrentInstance();

        try {
            if (cf.findByDui(cli.getDui()) == null) {
                cli.setFechaRegistro(new Date());
                cf.create(cli);
                context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_INFO, "Exito", "datos ingresados"));
            } else {
                context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "Error", "dui registrado"));
            }

        } catch (Exception e) {
            e.printStackTrace();
            context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, "Error", "datos no ingresados"));
        }

    }
}
en No hay comentarios:
Etiquetas: ,
Suscribirse a: Comentarios (Atom)