Problema para popular grid [fechada]

Question

Estou tentando criar uma grid que carregue as informações das colunas obsligacao datahoraalteracao e ativo. Configurei o lado do service que consiste em assíncrono e síncrono, chamei o método no Presenter e exibi o resultado em uma grid no View.

Service:

 public List<ObservacaoLigacaoVO> obterHistoricoObservacoes(Integer idLigacao, int offset, int limit) throws Exception {
        Connection conn = conecta();
        Statement stmt = null;
        ResultSet rs = null;
        String sql = "";
        List<ObservacaoLigacaoVO> listaObservacoes = new ArrayList<>();

        try {
            stmt = conn.createStatement();

            if (offset >= 0 && limit > 0 && limit <= 100) {
                sql = "SELECT * FROM ("
                        + "SELECT obsligacao.obsligacao, obsligacao.ativo, obsligacao.datahoraalteracao, ROW_NUMBER() OVER (ORDER BY obsligacao.datahoraalteracao DESC) AS rownum "
                        + "FROM obsligacao "
                        + "WHERE obsligacao.idligacao = " + idLigacao
                        + ") AS temp_table "
                        + "WHERE rownum > " + offset
                        + " AND rownum <= " + (offset + limit);
            } else {
                sql = "SELECT obsligacao.obsligacao, obsligacao.ativo, obsligacao.datahoraalteracao "
                        + "FROM obsligacao "
                        + "WHERE obsligacao.idligacao = " + idLigacao;
            }

            rs = stmt.executeQuery(sql);

            while (rs.next()) {
                ObservacaoLigacaoVO observacaoLigacaoVO = new ObservacaoLigacaoVO();
                observacaoLigacaoVO.setObservacao(rs.getString("obsligacao"));
                observacaoLigacaoVO.setAtivo(rs.getBoolean("ativo"));
                observacaoLigacaoVO.setDataHoraAlteracao(rs.getString("datahoraalteracao"));
                listaObservacoes.add(observacaoLigacaoVO);
            }

            return listaObservacoes;

        } catch (Exception e) {
            rollbackTransaction(e);
            throw e;
        } finally {
            if (stmt != null) {
                stmt.close();
            }
            if (rs != null) {
                rs.close();
            }
            if (conn != null) {
                destruir(conn);
            }
        }
    }

Obs: Os valores estao coerentes aos apresentados no ObservacaoLigacaoVO/DTO

PresenterImpl:

public void loadObservacoesLigacao(final int offset, final int limit, final AsyncCallback<PagingLoadResult<ObservacaoLigacaoDTO>> callback) {
        ObservacaoLigacaoGWTService.Util.getInstance().obterHistoricoObservacoes(baseView.getLigacao(), offset, limit, new AsyncCallback<List<ObservacaoLigacaoDTO>>() {

            public void onFailure(Throwable caught) {
                cf.alert(caught);
            }

            public void onSuccess(List<ObservacaoLigacaoDTO> result) {
                if (result != null) {
                    baseView.setlistStoreObservacao(result);
                } else {
                    System.out.println("Nenhum registro encontrado.");
                    callback.onSuccess(new PagingLoadResultBean<>(Collections.emptyList(), 0, offset));
                }
            }
        });
    }

Conversão de VO para DTO:

  public List<ObservacaoLigacaoDTO> obterHistoricoObservacoes(Integer idLigacao, int offset, int limit) throws Exception {
        try {
            List<ObservacaoLigacaoVO> ret = observacaoLigacaoService.obterHistoricoObservacoes(idLigacao, offset, limit);


            if (ret == null) {
                ret = new ArrayList<ObservacaoLigacaoVO>();
            }

            return com.waterfy.customerfy.server.util.Util.convert(ObservacaoLigacaoDTO.class.getName(), ret);
        } catch (Exception e) {
            throw new UIException(e);
        }
    }

View:

private Grid<ObservacaoLigacaoDTO> getGridObservacao() {

        if (gridObservacao == null) {

            List<ColumnConfig<ObservacaoLigacaoDTO, ?>> columns = new ArrayList<ColumnConfig<ObservacaoLigacaoDTO, ?>>();

            // Configuração das colunas
            ColumnConfig<ObservacaoLigacaoDTO, String> colObservacao = new ColumnConfig<ObservacaoLigacaoDTO, String>(
                    new ValueProvider<ObservacaoLigacaoDTO, String>() {
                        @Override
                        public String getValue(ObservacaoLigacaoDTO object) {
                            return object.getObservacao();
                        }

                        @Override
                        public void setValue(ObservacaoLigacaoDTO object, String value) {
                            object.setObservacao(value);
                        }

                        @Override
                        public String getPath() {
                            return "observacao";
                        }
                    },
                    200,
                    I18n.I.observacao()
            );

            ColumnConfig<ObservacaoLigacaoDTO, Boolean> colAtivo = new ColumnConfig<ObservacaoLigacaoDTO, Boolean>(
                    new ValueProvider<ObservacaoLigacaoDTO, Boolean>() {
                        @Override
                        public Boolean getValue(ObservacaoLigacaoDTO observacaoLigacao) {
                            return observacaoLigacao.isAtivo();
                        }

                        @Override
                        public void setValue(ObservacaoLigacaoDTO object, Boolean value) {
                            object.setAtivo(value);
                        }

                        @Override
                        public String getPath() {
                            return "ativo";
                        }
                    },
                    40,
                    I18n.I.ativo()
            );

            CheckBoxCell c = new CheckBoxCell() {
                @Override
                public void render(Context context, Boolean value, SafeHtmlBuilder sb) {
                    // Renderiza o checkbox com o valor (true/false)
                    super.render(context, value, sb);
                }
            };


            colAtivo.setCell(c);
            colAtivo.setSortable(true);


            columns.add(colAtivo);
            columns.add(colObservacao);
            columns.add(new ColumnConfig<ObservacaoLigacaoDTO, String>(new ValueProvider<ObservacaoLigacaoDTO, String>() {

                public String getValue(ObservacaoLigacaoDTO object) {
                    if (object.getDataHoraAlteracao() != null && !object.getDataHoraAlteracao().isEmpty()) {
                        return DataUtil.formatDateFromBD(object.getDataHoraAlteracao());
                    } else {
                        return "";
                    }
                }

                public void setValue(ObservacaoLigacaoDTO object, String value) {
                }


                public String getPath() {
                            return "dataHoraAlteracao";
                        }
                    }, 150, I18n.I.dataHora()));



            gridObservacao = new Grid <ObservacaoLigacaoDTO> (getListStoreObservacao(), new ColumnModel <ObservacaoLigacaoDTO>(columns));

            gridObservacao.getView().setStripeRows(true);
            gridObservacao.getView().setColumnLines(true);
            gridObservacao.getView().setForceFit(true);
            gridObservacao.setColumnReordering(true);
            gridObservacao.setBorders(false);

        }
        return gridObservacao;
    }


    private ListStore<ObservacaoLigacaoDTO> getListStoreObservacao() {
        if (listStoreObservacao == null) {
            listStoreObservacao = new ListStore<ObservacaoLigacaoDTO>(new ModelKeyProvider<ObservacaoLigacaoDTO>(){

                public String getKey(ObservacaoLigacaoDTO item) {
                    return item.getId() + "";
                }
            });
            listStoreObservacao.setAutoCommit(true);
        }
        return listStoreObservacao;
    }

    public void setlistStoreObservacao(List<ObservacaoLigacaoDTO> l) {
        getGridObservacao().getSelectionModel().deselectAll();
        getListStoreObservacao().clear();
        getListStoreObservacao().clear();
        getListStoreObservacao().addAll(l);
        getGridObservacao().getView().refresh(true);
    }

    private List<ObservacaoLigacaoDTO> getObservacoesDTO() {
        List<ObservacaoLigacaoDTO> ret = new ArrayList<ObservacaoLigacaoDTO>();
        for (ObservacaoLigacaoDTO f : getListStoreObservacao().getAll()) {
            if (f.isUtilizar()) {
                ret.add(f);
            }
        }
        return ret;
    }

Há alguma inconsistência no método apresentado?