Fórum Novo registro não é mostrado no datatable #377611

<rich:dataTable id="local" value="#{profissionalcargohonorificoController.todos}" var="item" rows="15" onRowMouseOver="this.style.backgroundColor='#F1F1F1'" onRowMouseOut="this.style.backgroundColor='#FFFFFF'" rendered="#{not empty profissionalcargohonorificoController.todos}">
            <h:column>
                <f:facet name="header">
                    <h:outputText value="Profissional" />
                </f:facet>
                <h:outputText value="#{item.id.profissional.nome}" />
            </h:column>

            <h:column>
                <f:facet name="header">
                    <h:outputText value="Cargo Honorífico" />
                </f:facet>
                <h:outputText value="#{item.id.cargohonorifico.descricao}" />
            </h:column>

            <h:column>
                <f:facet name="header">
                    <h:outputText value="Data de Término" />
                </f:facet>
                <h:outputText value="#{item.datatermino}" />
            </h:column>

            <h:column>
                <a4j:commandLink action="#{profissionalcargohonorificoController.editar}" reRender="local">
                    <h:graphicImage value="/imagens/site/edit.gif"
                        style="border: none; left: 35%; position: relative;" alt="Alterar" />
                    
                </a4j:commandLink>
                <f:facet name="header">
                    <h:outputText value="Atualizar" />
                </f:facet>
            </h:column>
            <h:column>
                <a4j:commandLink action="#{profissionalcargohonorificoController.excluir}" reRender="local"
                    onclick="if (!confirm('Deseja excluir este registro?')) return false;">
                    <h:graphicImage value="/imagens/site/delete.gif"
                        style="border: none;left: 27%; position: relative;" alt="Excluir" />
                    
                </a4j:commandLink>
                <f:facet name="header">
                    <h:outputText value="Excluir" />
                </f:facet>
            </h:column>
            <f:facet name="footer">
                <rich:datascroller/>
            </f:facet>
        </rich:dataTable><br />

@Controller("profissionalcargohonorificoController")
@Scope("session")
public class ProfissionalcargohonorificoController {

    private Profissionalcargohonorifico profissionalcargohonorifico;
    private DataModel model;
    private int ordem = 4;

    public Profissionalcargohonorifico getProfissionalcargohonorifico() {
        return profissionalcargohonorifico;
    }

    public void setProfissionalcargohonorifico(
            Profissionalcargohonorifico profissionalcargohonorifico) {
        this.profissionalcargohonorifico = profissionalcargohonorifico;
    }

    public DataModel getModel() {
        return model;
    }

    public void setModel(DataModel model) {
        this.model = model;
    }

    public int getOrdem() {
        return ordem;
    }

    public void setOrdem(int ordem) {
        this.ordem = ordem;
    }

    public DaoGenerico<Profissionalcargohonorifico, String> getProfissionalcargohonorificoDao() {
        return profissionalcargohonorificoDao;
    }

    public void setLocaltrabalhoDao(
            DaoGenerico<Profissionalcargohonorifico, String> profissionalcargohonorificoDao) {
        this.profissionalcargohonorificoDao = profissionalcargohonorificoDao;
    }

    @Resource
    private DaoGenerico<Profissional, String> profissionalDao;

    @Resource
    private DaoGenerico<Profissionalcargohonorifico, String> profissionalcargohonorificoDao;

    @Resource
    private DaoGenerico<Cargohonorifico, Long> cargohonorificoDao;

    @Resource
    private DaoGenerico<Camara, Long> camaraDao;

    @Resource
    private DaoGenerico<Entidadeclasse, String> entidadeclasseDao;

    public DaoGenerico<Cargohonorifico, Long> getCargohonorificoDao() {
        return cargohonorificoDao;
    }

    public void setCargohonorificoDao(
            DaoGenerico<Cargohonorifico, Long> cargohonorificoDao) {
        this.cargohonorificoDao = cargohonorificoDao;
    }

    public DaoGenerico<Camara, Long> getCamaraDao() {
        return camaraDao;
    }

    public void setCamaraDao(DaoGenerico<Camara, Long> camaraDao) {
        this.camaraDao = camaraDao;
    }

    public DaoGenerico<Entidadeclasse, String> getEntidadeclasseDao() {
        return entidadeclasseDao;
    }

    public void setEntidadeclasseDao(
            DaoGenerico<Entidadeclasse, String> entidadeclasseDao) {
        this.entidadeclasseDao = entidadeclasseDao;
    }

    private Map<String, Object> cargohonorificoItem = null;
    private Map<String, Object> camaraItem = null;
    private Map<String, Object> entidadeClasseItem = null;

    public Map<String, Object> getCargohonorifico() {

        cargohonorificoItem = new LinkedHashMap<String, Object>();

        for (Iterator<?> iter = cargohonorificoDao.todos(2).iterator(); iter
                .hasNext();) {
            Cargohonorifico c = (Cargohonorifico) iter.next();
            cargohonorificoItem.put(c.getDescricao(), c.getIdcargohonorifico());// label,value
        }

        return cargohonorificoItem;

    }

    public Map<String, Object> getCamara() {

        camaraItem = new LinkedHashMap<String, Object>();

        for (Iterator<?> iter = camaraDao.todos(2).iterator(); iter.hasNext();) {
            Camara c = (Camara) iter.next();
            camaraItem.put(c.getDescricao(), c.getIdcamara());// label,value
        }

        return camaraItem;

    }

    public Map<String, Object> getEntidadeclasse() {

        entidadeClasseItem = new LinkedHashMap<String, Object>();

        for (Iterator<?> iter = entidadeclasseDao.todos(2).iterator(); iter
                .hasNext();) {
            Entidadeclasse e = (Entidadeclasse) iter.next();
            entidadeClasseItem.put(e.getSigla(), e.getIdentidadeclasse());// label,value
        }

        return entidadeClasseItem;

    }

    public DaoGenerico<Profissional, String> getProfissionalDao() {
        return profissionalDao;
    }

    public void setProfissionalDao(
            DaoGenerico<Profissional, String> profissionalDao) {
        this.profissionalDao = profissionalDao;
    }

    public void setProfissionalcargohonorificoDao(
            DaoGenerico<Profissionalcargohonorifico, String> profissionalcargohonorificoDao) {
        this.profissionalcargohonorificoDao = profissionalcargohonorificoDao;
    }

    public ProfissionalcargohonorificoController() {
    }

    public String novo() {
    
        this.profissionalcargohonorifico = new Profissionalcargohonorifico();
        this.profissionalcargohonorifico
                .setId(new ProfissionalcargohonorificoId());

        this.profissionalcargohonorifico.getId().setCargohonorifico(
                new Cargohonorifico());
        getCargohonorifico();

        this.profissionalcargohonorifico.getId().setProfissional(
                new Profissional());
        this.profissionalcargohonorifico.setRnpsuplente(new Profissional());
        this.profissionalcargohonorifico.setCamara(new Camara());
        getCamara();

        this.profissionalcargohonorifico
                .setEntidadeclasse(new Entidadeclasse());
        getEntidadeclasse();

        return "formProfissionalCargoHonorifico";
    }

    public DataModel getTodos() {
        return model = new ListDataModel(profissionalcargohonorificoDao
                .todos(ordem));
    }

    public Profissionalcargohonorifico getProfissionalcargohonorificoParaEditarExcluir() {
        Profissionalcargohonorifico profissionalcargohonorifico = (Profissionalcargohonorifico) model
                .getRowData();
        return profissionalcargohonorifico;
    }

    public String editar() {
        novoregistro = false;
        renderizar();
        FacesContext context = FacesContext.getCurrentInstance();
        Profissionalcargohonorifico pch = (Profissionalcargohonorifico) context
                .getExternalContext().getRequestMap().get("item");
        setProfissionalcargohonorifico(pch);

        return "formProfissionalCargoHonorifico";
    }

    public String salvar() {
        if ((profissionalcargohonorifico.getRnpsuplente().getCodigo() == null)
                || (profissionalcargohonorifico.getRnpsuplente().getCodigo()
                        .equals(""))) {
            profissionalcargohonorifico.setRnpsuplente(profissionalDao.pesquisarPorId(""));
        } else {
            profissionalcargohonorifico.getRnpsuplente().setCodigo(
                    profissionalcargohonorifico.getRnpsuplente().getCodigo());
        }

        try {
            if (novoregistro == true) {
                profissionalcargohonorificoDao
                        .salvar(profissionalcargohonorifico);
            } else {
                profissionalcargohonorificoDao
                        .atualizar(profissionalcargohonorifico);
            }
        } catch (JpaSystemException e) {
            registroSalvo = false;
            FacesContext.getCurrentInstance().addMessage(
                    "form1",
                    new FacesMessage(FacesMessage.SEVERITY_ERROR,
                            "Registro já Existe", "Registro já Existe"));
            return null;
        }
        return "sucesso";
    }

    public String excluir() {
        FacesContext context = FacesContext.getCurrentInstance();
        Profissionalcargohonorifico pch = (Profissionalcargohonorifico) context
                .getExternalContext().getRequestMap().get("item");
        profissionalcargohonorificoDao.excluir(pch);
        return null;
    }

    public void validaProfissional(FacesContext context,
            UIComponent componente, Object objeto) throws ValidatorException {
        String codigo = (String) objeto;

        if (profissionalcargohonorifico.getId().getProfissional().getCodigo() != "") {
            if (profissionalDao.pesquisarPorId(codigo) == null) {
                ((UIInput) componente).setValid(false);
                FacesMessage message = new FacesMessage(
                        "Profissional não Encontrado.");
                context.addMessage(componente.getClientId(context), message);
            }
        }
    }

    public String getExisteProfissional() {

        if (profissionalcargohonorifico.getId().getProfissional().getCodigo() != null) {
            Profissional prof = profissionalDao
                    .pesquisarPorId(profissionalcargohonorifico.getId()
                            .getProfissional().getCodigo());
            if (prof != null) {
                return prof.getNome();
            } else {
                return null;
            }
        }
        return null;
    }

    public String getExisteSuplente() {

        if (profissionalcargohonorifico.getRnpsuplente().getCodigo() != null) {
            Profissional prof = profissionalDao.pesquisarPorId(profissionalcargohonorifico.getRnpsuplente().getCodigo());
            if (prof != null) {
                return prof.getNome();
            } else {
                return null;
            }
        }
        return null;

    }


}

@Transactional(readOnly=true,propagation=Propagation.REQUIRED)
public class DaoGenericoImp<T,ID extends Serializable> implements DaoGenerico<T, ID> {

    private EntityManager entityManager;
    
    private final Class<T> oClass;
    
    @SuppressWarnings("unchecked")
    public DaoGenericoImp(){
        this.oClass = (Class<T>)((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0];
    }
    
    @Override
    @Transactional(readOnly=false,propagation=Propagation.REQUIRED)
    public T atualizar(T object) {
        //getEntityManager().merge(object);
        getEntityManager().merge(object);
        return object;
    }

    @Override
    @Transactional(readOnly=false,propagation=Propagation.REQUIRED)
    public void excluir(T object) {
        object = getEntityManager().merge(object);
        getEntityManager().remove(object);
    }

    @Override
    public Class<T> getObjectClass() {
        return this.oClass;
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<T> listPesq(String query) {
        Query q = getEntityManager().createQuery(query);
        return q.getResultList();
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<T> listPesqParam(String query, Map<String, Object> params) {
        Query q = getEntityManager().createQuery(query);
        for(String chave:params.keySet()){
            q.setParameter(chave, params.get(chave));
        }
        return q.getResultList();
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<T> listPesqParam(String query, Map<String, Object> params,
            int maximo, int atual) {
        Query q = getEntityManager().createQuery(query).setMaxResults(maximo).setFirstResult(atual);
        for(String chave:params.keySet()){
            q.setParameter(chave, params.get(chave));
        }
        return q.getResultList();
    }

    @SuppressWarnings("unchecked")
    @Override
    public T pesqParam(String query, Map<String, Object> params) {
        Query q = getEntityManager().createQuery(query);
        
        for(String chave : params.keySet()){
            q.setParameter(chave, params.get(chave));
        }
        
        try{
            return (T)q.getSingleResult();
        }catch(NoResultException nre){
            return null;
        }
    }

    @Override
    public T pesquisarPorId(ID id) {
        return (T)getEntityManager().find(oClass, id);
    }

    @Override
    @Transactional(readOnly=false,propagation=Propagation.REQUIRED)
    public T salvar(T object){
        getEntityManager().clear();
        getEntityManager().persist(object);
        return object;
    }

    @SuppressWarnings("unchecked")
    @Override
    public List<T> todos(int ordem) {
        String queryS = "SELECT obj FROM "+oClass.getSimpleName()+" obj ORDER BY "+ordem;
        Query query = getEntityManager().createQuery(queryS);
        return query.getResultList();
    }
    
    @PersistenceContext
    public void setEntityManager(EntityManager em) {
        this.entityManager = em;
    }

    public EntityManager getEntityManager() {
        if (entityManager == null)
             throw new IllegalStateException("Erro");
        return entityManager;
    }

}