Example usage for org.springframework.transaction.support TransactionTemplate TransactionTemplate

List of usage examples for org.springframework.transaction.support TransactionTemplate TransactionTemplate

  1. HOME
  2. Java
  3. org.springframework
  4. org.springframework.transaction.support.*
  5. TransactionTemplate
  6. TransactionTemplate

Introduction

In this page you can find the example usage for org.springframework.transaction.support TransactionTemplate TransactionTemplate.

Prototype

public TransactionTemplate(PlatformTransactionManager transactionManager)

Source Link

Document

Construct a new TransactionTemplate using the given transaction manager.

Usage

From source file:com._4dconcept.springframework.data.marklogic.datasource.DatabaseConnectorJtaTransactionTest.java

private void doTestJtaTransactionWithPropagationRequiresNewAndBeginException(boolean suspendException,
        final boolean openOuterConnection, final boolean useTransactionAwareContentSource) throws Exception {

    given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
            Status.STATUS_ACTIVE);
    if (suspendException) {
        given(transactionManager.suspend()).willThrow(new SystemException());
    } else {//  w w  w  .  j a v a2s  .  c om
        given(transactionManager.suspend()).willReturn(transaction);
        willThrow(new SystemException()).given(userTransaction).begin();
    }

    given(session.getTransactionMode()).willReturn(Session.TransactionMode.QUERY);

    final ContentSource dsToUse = useTransactionAwareContentSource
            ? new TransactionAwareContentSourceProxy(contentSource)
            : contentSource;
    if (dsToUse instanceof TransactionAwareContentSourceProxy) {
        ((TransactionAwareContentSourceProxy) dsToUse).setReobtainTransactionalSessions(true);
    }

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction, transactionManager);
    final TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    try {
        tt.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
                assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
                assertTrue("JTA synchronizations active",
                        TransactionSynchronizationManager.isSynchronizationActive());
                assertTrue("Is new transaction", status.isNewTransaction());

                Session c = ContentSourceUtils.getSession(dsToUse);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
                c.getTransactionMode();
                ContentSourceUtils.releaseSession(c, dsToUse);

                c = ContentSourceUtils.getSession(dsToUse);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
                if (!openOuterConnection) {
                    ContentSourceUtils.releaseSession(c, dsToUse);
                }

                try {
                    tt.execute(new TransactionCallbackWithoutResult() {
                        @Override
                        protected void doInTransactionWithoutResult(TransactionStatus status)
                                throws RuntimeException {
                            assertTrue("Hasn't thread session",
                                    !TransactionSynchronizationManager.hasResource(dsToUse));
                            assertTrue("JTA synchronizations active",
                                    TransactionSynchronizationManager.isSynchronizationActive());
                            assertTrue("Is new transaction", status.isNewTransaction());

                            Session c = ContentSourceUtils.getSession(dsToUse);
                            assertTrue("Has thread session",
                                    TransactionSynchronizationManager.hasResource(dsToUse));
                            ContentSourceUtils.releaseSession(c, dsToUse);

                            c = ContentSourceUtils.getSession(dsToUse);
                            assertTrue("Has thread session",
                                    TransactionSynchronizationManager.hasResource(dsToUse));
                            ContentSourceUtils.releaseSession(c, dsToUse);
                        }
                    });
                } finally {
                    if (openOuterConnection) {
                        c.getTransactionMode();
                        ContentSourceUtils.releaseSession(c, dsToUse);

                    }
                }
            }
        });

        fail("Should have thrown TransactionException");
    } catch (TransactionException ex) {
        // expected
    }

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(dsToUse));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    verify(userTransaction).begin();
    if (suspendException) {
        verify(userTransaction).rollback();
    }

    if (suspendException) {
        verify(session, atLeastOnce()).close();
    } else {
        verify(session, never()).close();
    }
}

From source file:dao.FlowsDAO.java

public static ObjectNode getPagedJobsByFlow(String applicationName, Long flowId, int page, int size) {
    ObjectNode result;//w w w  .  j a  va 2  s  . c  om
    List<Job> pagedJobs = new ArrayList<Job>();

    if (StringUtils.isBlank(applicationName) || (flowId <= 0)) {
        result = Json.newObject();
        result.put("count", 0);
        result.put("page", page);
        result.put("itemsPerPage", size);
        result.put("totalPages", 0);
        result.set("jobs", Json.toJson(""));
        return result;
    }

    String application = applicationName.replace(".", " ");

    Integer appID = getApplicationIDByName(application);
    if (appID != 0) {
        javax.sql.DataSource ds = getJdbcTemplate().getDataSource();
        DataSourceTransactionManager tm = new DataSourceTransactionManager(ds);
        TransactionTemplate txTemplate = new TransactionTemplate(tm);
        final long azkabanFlowId = flowId;
        result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
            public ObjectNode doInTransaction(TransactionStatus status) {
                List<Map<String, Object>> rows = null;
                rows = getJdbcTemplate().queryForList(GET_PAGED_JOBS_BY_APP_ID_AND_FLOW_ID, appID,
                        azkabanFlowId, (page - 1) * size, size);
                long count = 0;
                String flowName = "";
                try {
                    count = getJdbcTemplate().queryForObject("SELECT FOUND_ROWS()", Long.class);
                } catch (EmptyResultDataAccessException e) {
                    Logger.error("Exception = " + e.getMessage());
                }
                for (Map row : rows) {
                    Job job = new Job();
                    job.id = (Long) row.get("job_id");
                    job.name = (String) row.get("job_name");
                    job.path = (String) row.get("job_path");
                    job.path = (String) row.get("job_path");
                    job.refFlowGroup = (String) row.get("flow_group");
                    if (StringUtils.isNotBlank(job.path)) {
                        int index = job.path.indexOf("/");
                        if (index != -1) {
                            job.path = job.path.substring(0, index);
                        }
                    }
                    job.type = (String) row.get("job_type");
                    Object created = row.get("created_time");
                    job.refFlowId = (Long) row.get("ref_flow_id");
                    if (created != null) {
                        job.created = DateFormat.format(created.toString());
                    }
                    Object modified = row.get("modified_time");
                    if (modified != null) {
                        job.modified = DateFormat.format(modified.toString());
                    }

                    if (StringUtils.isBlank(flowName)) {
                        flowName = (String) row.get("flow_name");
                    }
                    pagedJobs.add(job);
                }
                ObjectNode resultNode = Json.newObject();
                resultNode.put("count", count);
                resultNode.put("flow", flowName);
                resultNode.put("page", page);
                resultNode.put("itemsPerPage", size);
                resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
                resultNode.set("jobs", Json.toJson(pagedJobs));
                return resultNode;
            }
        });
        return result;
    }

    result = Json.newObject();
    result.put("count", 0);
    result.put("page", page);
    result.put("itemsPerPage", size);
    result.put("totalPages", 0);
    result.set("jobs", Json.toJson(""));
    return result;
}

From source file:dao.DashboardDAO.java

public static ObjectNode getPagedOwnershipDatasetsByManagerId(String managerId, String platform, int option,
        int page, int size) {

    final DataSourceTransactionManager tm = new DataSourceTransactionManager(getJdbcTemplate().getDataSource());
    final TransactionTemplate txTemplate = new TransactionTemplate(tm);

    return txTemplate.execute(new TransactionCallback<ObjectNode>() {

        public ObjectNode doInTransaction(TransactionStatus status) {
            final String datasetQuery;
            switch (option) {
            case 1:
                datasetQuery = GET_OWNERSHIP_CONFIRMED_DATASETS_FILTER_PLATFORM;
                break;
            case 2:
                datasetQuery = GET_OWNERSHIP_UNCONFIRMED_DATASETS_FILTER_PLATFORM;
                break;
            case 3:
                datasetQuery = GET_OWNERSHIP_DATASETS_FILTER_PLATFORM;
                break;
            default:
                datasetQuery = GET_OWNERSHIP_DATASETS_FILTER_PLATFORM;
            }//w  w  w  . j av  a 2 s . co  m

            List<Map<String, Object>> rows = new ArrayList<>(size);
            long count = getPagedDashboardDatasets(managerId, datasetQuery, platform, null, page, size, rows);

            List<DashboardDataset> datasets = new ArrayList<>();
            for (Map row : rows) {
                DashboardDataset dashboardDataset = new DashboardDataset();
                dashboardDataset.datasetId = (Long) row.get("dataset_id");
                dashboardDataset.datasetName = (String) row.get("name");
                dashboardDataset.ownerId = (String) row.get("owner_id");
                String confirmedOwnerId = (String) row.get("confirmed_owner_id");
                if (StringUtils.isBlank(confirmedOwnerId) && option == 1) {
                    confirmedOwnerId = "<other team>";
                }
                dashboardDataset.confirmedOwnerId = confirmedOwnerId;
                datasets.add(dashboardDataset);
            }

            ObjectNode resultNode = Json.newObject();
            resultNode.put("status", "ok");
            resultNode.put("count", count);
            resultNode.put("page", page);
            resultNode.put("itemsPerPage", size);
            resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
            resultNode.set("datasets", Json.toJson(datasets));
            return resultNode;
        }
    });
}

From source file:com.bitsofproof.supernode.core.ImplementBCSAPI.java

private Color getColor(final String hash) {
    log.trace("get color " + hash);
    final Color color = new Color();
    new TransactionTemplate(transactionManager).execute(new TransactionCallbackWithoutResult() {
        @Override/*w ww .  j  a  v  a 2s. co  m*/
        protected void doInTransactionWithoutResult(TransactionStatus status) {
            status.setRollbackOnly();
            StoredColor c;
            try {
                c = ((ColorStore) store).findColor(hash);
                if (c != null) {
                    color.setExpiryHeight(c.getExpiryHeight());
                    color.setSignature(c.getSignature());
                    color.setTerms(c.getTerms());
                    color.setUnit(c.getUnit());
                    color.setPubkey(c.getPubkey());
                    color.setTransaction(c.getTxHash());
                }
            } catch (ValidationException e) {
                log.error("can not get color " + hash, e);
            }

        }
    });
    if (color.getTerms() != null) {
        log.trace("get color returned " + hash);
        return color;
    }
    log.trace("get color failed ");
    return null;
}

From source file:org.wallride.service.ArticleService.java

@Transactional(propagation = Propagation.NOT_SUPPORTED)
@CacheEvict(value = WallRideCacheConfiguration.ARTICLE_CACHE, allEntries = true)
public List<Article> bulkDeleteArticle(ArticleBulkDeleteRequest bulkDeleteRequest, BindingResult result) {
    List<Article> articles = new ArrayList<>();
    for (long id : bulkDeleteRequest.getIds()) {
        final ArticleDeleteRequest deleteRequest = new ArticleDeleteRequest.Builder().id(id)
                .language(bulkDeleteRequest.getLanguage()).build();

        final BeanPropertyBindingResult r = new BeanPropertyBindingResult(deleteRequest, "request");
        r.setMessageCodesResolver(messageCodesResolver);

        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW);
        Article article = null;//from   w w  w.jav  a 2 s  . c o  m
        try {
            article = transactionTemplate.execute(new TransactionCallback<Article>() {
                public Article doInTransaction(TransactionStatus status) {
                    try {
                        return deleteArticle(deleteRequest, r);
                    } catch (BindException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            articles.add(article);
        } catch (Exception e) {
            logger.debug("Errors: {}", r);
            result.addAllErrors(r);
        }
    }
    return articles;
}

From source file:org.wallride.service.PageService.java

@CacheEvict(value = WallRideCacheConfiguration.PAGE_CACHE, allEntries = true)
@Transactional(propagation = Propagation.NOT_SUPPORTED)
public List<Page> bulkDeletePage(PageBulkDeleteRequest bulkDeleteRequest, BindingResult result) {
    List<Page> pages = new ArrayList<>();
    for (long id : bulkDeleteRequest.getIds()) {
        final PageDeleteRequest deleteRequest = new PageDeleteRequest.Builder().id(id)
                .language(bulkDeleteRequest.getLanguage()).build();

        final BeanPropertyBindingResult r = new BeanPropertyBindingResult(deleteRequest, "request");
        r.setMessageCodesResolver(messageCodesResolver);

        TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.setPropagationBehavior(TransactionTemplate.PROPAGATION_REQUIRES_NEW);
        Page page = null;//from w  ww  .  j a  v a  2 s . c om
        try {
            page = transactionTemplate.execute(new TransactionCallback<Page>() {
                public Page doInTransaction(TransactionStatus status) {
                    try {
                        return deletePage(deleteRequest, r);
                    } catch (BindException e) {
                        throw new RuntimeException(e);
                    }
                }
            });
            pages.add(page);
        } catch (Exception e) {
            logger.debug("Errors: {}", r);
            result.addAllErrors(r);
        }
    }
    return pages;
}

From source file:dao.DashboardDAO.java

public static ObjectNode getPagedConfidentialDatasetsByManagerId(String managerId, String platform, int page,
        int size) {

    DataSourceTransactionManager tm = new DataSourceTransactionManager(getJdbcTemplate().getDataSource());
    TransactionTemplate txTemplate = new TransactionTemplate(tm);

    return txTemplate.execute(new TransactionCallback<ObjectNode>() {

        public ObjectNode doInTransaction(TransactionStatus status) {
            List<Map<String, Object>> rows = new ArrayList<>(size);
            long count = getPagedDashboardDatasets(managerId, GET_CONFIDENTIAL_DATASETS_FILTER_PLATFORM,
                    platform, null, page, size, rows);

            List<DashboardDataset> datasets = new ArrayList<>();
            for (Map row : rows) {
                DashboardDataset dashboardDataset = new DashboardDataset();
                dashboardDataset.datasetId = (Long) row.get("dataset_id");
                dashboardDataset.datasetName = (String) row.get("name");
                dashboardDataset.ownerId = (String) row.get("owner_id");
                if (dashboardDataset.datasetId != null && dashboardDataset.datasetId > 0) {
                    dashboardDataset.fields = getJdbcTemplate().queryForList(
                            GET_CONFIDENTIAL_FIELDS_BY_DATASET_ID, String.class, dashboardDataset.datasetId);
                }//  w  ww.  j av a2  s.co m
                datasets.add(dashboardDataset);
            }

            ObjectNode resultNode = Json.newObject();
            resultNode.put("status", "ok");
            resultNode.put("count", count);
            resultNode.put("page", page);
            resultNode.put("itemsPerPage", size);
            resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
            resultNode.set("datasets", Json.toJson(datasets));
            return resultNode;
        }
    });
}

From source file:dao.SearchDAO.java

public static ObjectNode getPagedDatasetByKeyword(String category, String keyword, String source, int page,
        int size) {
    List<Dataset> pagedDatasets = new ArrayList<Dataset>();
    final JdbcTemplate jdbcTemplate = getJdbcTemplate();
    javax.sql.DataSource ds = jdbcTemplate.getDataSource();
    DataSourceTransactionManager tm = new DataSourceTransactionManager(ds);

    TransactionTemplate txTemplate = new TransactionTemplate(tm);

    ObjectNode result;//from w  w w.j av a2s .c  o m
    result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
        public ObjectNode doInTransaction(TransactionStatus status) {
            List<Map<String, Object>> rows = null;
            if (StringUtils.isBlank(source) || source.toLowerCase().equalsIgnoreCase("all")) {
                String query = SEARCH_DATASET_WITH_PAGINATION.replace("$keyword", keyword);
                rows = jdbcTemplate.queryForList(query, (page - 1) * size, size);
            } else {
                String query = SEARCH_DATASET_BY_SOURCE_WITH_PAGINATION.replace("$keyword", keyword);
                rows = jdbcTemplate.queryForList(query, source, (page - 1) * size, size);
            }

            for (Map row : rows) {

                Dataset ds = new Dataset();
                ds.id = (Long) row.get(DatasetRowMapper.DATASET_ID_COLUMN);
                ds.name = (String) row.get(DatasetRowMapper.DATASET_NAME_COLUMN);
                ds.source = (String) row.get(DatasetRowMapper.DATASET_SOURCE_COLUMN);
                ds.urn = (String) row.get(DatasetRowMapper.DATASET_URN_COLUMN);
                ds.schema = (String) row.get(DatasetRowMapper.DATASET_SCHEMA_COLUMN);
                pagedDatasets.add(ds);
            }
            long count = 0;
            try {
                count = jdbcTemplate.queryForObject("SELECT FOUND_ROWS()", Long.class);
            } catch (EmptyResultDataAccessException e) {
                Logger.error("Exception = " + e.getMessage());
            }

            ObjectNode resultNode = Json.newObject();
            resultNode.put("count", count);
            resultNode.put("page", page);
            resultNode.put("category", category);
            resultNode.put("source", source);
            resultNode.put("itemsPerPage", size);
            resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
            resultNode.set("data", Json.toJson(pagedDatasets));

            return resultNode;
        }
    });

    return result;
}

From source file:dao.DatasetsDAO.java

public static ObjectNode getPagedDatasets(String urn, Integer page, Integer size, String user) {
    ObjectNode result = Json.newObject();

    Integer userId = UserDAO.getUserIDByUserName(user);

    javax.sql.DataSource ds = getJdbcTemplate().getDataSource();
    DataSourceTransactionManager tm = new DataSourceTransactionManager(ds);
    TransactionTemplate txTemplate = new TransactionTemplate(tm);
    final Integer id = userId;

    result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
        public ObjectNode doInTransaction(TransactionStatus status) {

            ObjectNode resultNode = Json.newObject();
            List<Dataset> pagedDatasets = new ArrayList<Dataset>();
            List<Map<String, Object>> rows = null;
            if (id != null && id > 0) {
                if (StringUtils.isBlank(urn)) {
                    rows = getJdbcTemplate().queryForList(SELECT_PAGED_DATASET_BY_CURRENT_USER,
                            (page - 1) * size, size, id, id);
                } else {
                    rows = getJdbcTemplate().queryForList(SELECT_PAGED_DATASET_BY_URN_CURRENT_USER, urn + "%",
                            (page - 1) * size, size, id, id);
                }//from ww  w  .  ja  v  a 2s.  c  o  m
            } else {
                if (StringUtils.isBlank(urn)) {
                    rows = getJdbcTemplate().queryForList(SELECT_PAGED_DATASET, (page - 1) * size, size);
                } else {
                    rows = getJdbcTemplate().queryForList(SELECT_PAGED_DATASET_BY_URN, urn + "%",
                            (page - 1) * size, size);
                }

            }

            long count = 0;
            try {

                if (StringUtils.isBlank(urn)) {
                    count = getJdbcTemplate().queryForObject(GET_PAGED_DATASET_COUNT, Long.class);
                } else {
                    count = getJdbcTemplate().queryForObject(GET_PAGED_DATASET_COUNT_BY_URN, Long.class,
                            urn + "%");
                }
            } catch (EmptyResultDataAccessException e) {
                Logger.error("Exception = " + e.getMessage());
            }

            for (Map row : rows) {

                Dataset ds = new Dataset();
                Timestamp modified = (Timestamp) row.get(DatasetWithUserRowMapper.DATASET_MODIFIED_TIME_COLUMN);
                ds.id = (Long) row.get(DatasetWithUserRowMapper.DATASET_ID_COLUMN);
                ds.name = (String) row.get(DatasetWithUserRowMapper.DATASET_NAME_COLUMN);
                ds.source = (String) row.get(DatasetWithUserRowMapper.DATASET_SOURCE_COLUMN);
                ds.urn = (String) row.get(DatasetWithUserRowMapper.DATASET_URN_COLUMN);
                ds.schema = (String) row.get(DatasetWithUserRowMapper.DATASET_SCHEMA_COLUMN);
                String strOwner = (String) row.get(DatasetWithUserRowMapper.DATASET_OWNER_ID_COLUMN);
                String strOwnerName = (String) row.get(DatasetWithUserRowMapper.DATASET_OWNER_NAME_COLUMN);
                Long sourceModifiedTime = (Long) row
                        .get(DatasetWithUserRowMapper.DATASET_SOURCE_MODIFIED_TIME_COLUMN);
                String properties = (String) row.get(DatasetWithUserRowMapper.DATASET_PROPERTIES_COLUMN);
                try {
                    if (StringUtils.isNotBlank(properties)) {
                        ds.properties = Json.parse(properties);
                    }
                } catch (Exception e) {
                    Logger.error(e.getMessage());
                }

                if (modified != null && sourceModifiedTime != null && sourceModifiedTime > 0) {
                    ds.modified = modified;
                    ds.formatedModified = modified.toString();
                }

                String[] owners = null;
                if (StringUtils.isNotBlank(strOwner)) {
                    owners = strOwner.split(",");
                }
                String[] ownerNames = null;
                if (StringUtils.isNotBlank(strOwnerName)) {
                    ownerNames = strOwnerName.split(",");
                }
                ds.owners = new ArrayList<User>();
                if (owners != null && ownerNames != null) {
                    if (owners.length == ownerNames.length) {
                        for (int i = 0; i < owners.length; i++) {
                            User datasetOwner = new User();
                            datasetOwner.userName = owners[i];
                            if (datasetOwner.userName.equalsIgnoreCase(user)) {
                                ds.isOwned = true;
                            }
                            if (StringUtils.isBlank(ownerNames[i]) || ownerNames[i].equalsIgnoreCase("*")) {
                                datasetOwner.name = owners[i];
                            } else {
                                datasetOwner.name = ownerNames[i];
                            }
                            ds.owners.add(datasetOwner);
                        }
                    } else {
                        Logger.error("getPagedDatasets get wrong owner and names. Dataset ID: "
                                + Long.toString(ds.id) + " Owner: " + owners + " Owner names: " + ownerNames);
                    }
                }

                Integer favoriteId = (Integer) row.get(DatasetWithUserRowMapper.FAVORITE_DATASET_ID_COLUMN);
                Long watchId = (Long) row.get(DatasetWithUserRowMapper.DATASET_WATCH_ID_COLUMN);

                Long schemaHistoryRecordCount = 0L;
                try {
                    schemaHistoryRecordCount = getJdbcTemplate().queryForObject(CHECK_SCHEMA_HISTORY,
                            Long.class, ds.id);
                } catch (EmptyResultDataAccessException e) {
                    Logger.error("Exception = " + e.getMessage());
                }

                if (StringUtils.isNotBlank(ds.urn)) {
                    if (ds.urn.substring(0, 4).equalsIgnoreCase(DatasetRowMapper.HDFS_PREFIX)) {
                        ds.hdfsBrowserLink = Play.application().configuration().getString(HDFS_BROWSER_URL_KEY)
                                + ds.urn.substring(DatasetRowMapper.HDFS_URN_PREFIX_LEN);
                    }
                }
                if (favoriteId != null && favoriteId > 0) {
                    ds.isFavorite = true;
                } else {
                    ds.isFavorite = false;
                }
                if (watchId != null && watchId > 0) {
                    ds.watchId = watchId;
                    ds.isWatched = true;
                } else {
                    ds.isWatched = false;
                    ds.watchId = 0L;
                }
                if (schemaHistoryRecordCount != null && schemaHistoryRecordCount > 0) {
                    ds.hasSchemaHistory = true;
                } else {
                    ds.hasSchemaHistory = false;
                }
                pagedDatasets.add(ds);
            }

            resultNode.put("count", count);
            resultNode.put("page", page);
            resultNode.put("itemsPerPage", size);
            resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
            resultNode.set("datasets", Json.toJson(pagedDatasets));
            return resultNode;
        }
    });
    return result;
}

From source file:com._4dconcept.springframework.data.marklogic.datasource.DatabaseConnectorJtaTransactionTest.java

@Test
public void testJtaTransactionWithConnectionHolderStillBound() throws Exception {
    @SuppressWarnings("serial")
    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction) {

        @Override/*from w w  w  .  j a va2s .co  m*/
        protected void doRegisterAfterCompletionWithJtaTransaction(JtaTransactionObject txObject,
                final List<TransactionSynchronization> synchronizations)
                throws RollbackException, SystemException {
            Thread async = new Thread() {
                @Override
                public void run() {
                    invokeAfterCompletion(synchronizations, TransactionSynchronization.STATUS_COMMITTED);
                }
            };
            async.start();
            try {
                async.join();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        }
    };
    TransactionTemplate tt = new TransactionTemplate(ptm);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    given(userTransaction.getStatus()).willReturn(Status.STATUS_ACTIVE);
    for (int i = 0; i < 3; i++) {
        final boolean releaseCon = (i != 1);

        tt.execute(new TransactionCallbackWithoutResult() {
            @Override
            protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
                assertTrue("JTA synchronizations active",
                        TransactionSynchronizationManager.isSynchronizationActive());
                assertTrue("Is existing transaction", !status.isNewTransaction());

                Session c = ContentSourceUtils.getSession(contentSource);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(contentSource));
                ContentSourceUtils.releaseSession(c, contentSource);

                c = ContentSourceUtils.getSession(contentSource);
                assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(contentSource));
                if (releaseCon) {
                    ContentSourceUtils.releaseSession(c, contentSource);
                }
            }
        });

        if (!releaseCon) {
            assertTrue("Still has session holder",
                    TransactionSynchronizationManager.hasResource(contentSource));
        } else {
            assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
        }
        assertTrue("JTA synchronizations not active",
                !TransactionSynchronizationManager.isSynchronizationActive());
    }
    verify(session, times(3)).close();
}