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:dao.DashboardDAO.java

public static ObjectNode getPagedDescriptionDatasetsByManagerId(String managerId, String platform, int option,
        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) {
            Boolean isDatasetLevel = true;
            String description;// w  w  w  .j a  v a  2s .com

            final String datasetQuery;
            switch (option) {
            case 1:
                datasetQuery = GET_DATASETS_WITH_DESCRIPTION_FILTER_PLATFORM;
                description = "has dataset level description";
                break;
            case 2:
                datasetQuery = GET_DATASETS_WITHOUT_DESCRIPTION_FILTER_PLATFORM;
                description = "no dataset level description";
                break;
            case 3:
                datasetQuery = GET_DATASETS_WITH_FULL_FIELD_DESCRIPTION_FILTER_PLATFORM;
                description = "all fields have description";
                isDatasetLevel = false;
                break;
            case 4:
                datasetQuery = GET_DATASETS_WITH_ANY_FIELD_DESCRIPTION_FILTER_PLATFORM;
                description = "has field description";
                isDatasetLevel = false;
                break;
            case 5:
                datasetQuery = GET_DATASETS_WITH_NO_FIELD_DESCRIPTION_FILTER_PLATFORM;
                description = "no field description";
                isDatasetLevel = false;
                break;
            case 6:
                datasetQuery = GET_ALL_DATASETS_BY_ID_FILTER_PLATFORM;
                description = "";
                break;
            default:
                datasetQuery = GET_ALL_DATASETS_BY_ID_FILTER_PLATFORM;
                description = "";
            }

            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");
                if (dashboardDataset.datasetId != null && dashboardDataset.datasetId > 0) {
                    if (isDatasetLevel) {
                        dashboardDataset.fields = getJdbcTemplate().queryForList(GET_DATASET_LEVEL_COMMENTS,
                                String.class, dashboardDataset.datasetId);
                    } else {
                        dashboardDataset.fields = getJdbcTemplate().queryForList(GET_FIELDS_WITH_DESCRIPTION,
                                String.class, dashboardDataset.datasetId);
                    }
                }
                datasets.add(dashboardDataset);
            }

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

From source file:org.opentides.web.controller.BaseCrudController.java

/**
 * This is a post construct that set ups the service and validator for the
 * child service class.//from www. jav a 2s. c  o  m
 * 
 * @throws Exception
 */
@SuppressWarnings({ "unchecked" })
@Override
public void afterPropertiesSet() throws Exception {
    try {
        this.entityBeanType = (Class<T>) ((ParameterizedType) getClass().getGenericSuperclass())
                .getActualTypeArguments()[0];
    } catch (ClassCastException cc) {
        // if dao is extended from the generic dao class
        this.entityBeanType = (Class<T>) ((ParameterizedType) getClass().getSuperclass().getGenericSuperclass())
                .getActualTypeArguments()[0];
    }
    Assert.notNull(this.entityBeanType,
            "Unable to retrieve entityBeanType for " + this.getClass().getSimpleName());
    // try setting up service and validator by convention
    String attributeName = NamingUtil.toAttributeName(this.entityBeanType.getSimpleName());
    String serviceBean = attributeName + "Service";
    String validatorBean = attributeName + "Validator";
    if (_log.isDebugEnabled()) {
        _log.debug("Retrieving service for " + serviceBean);
    }

    if (this.service == null && beanFactory.containsBean(serviceBean)) {
        this.service = (BaseCrudService<T>) beanFactory.getBean(serviceBean);
    }

    if (this.formValidator == null && beanFactory.containsBean(validatorBean))
        this.formValidator = (Validator) beanFactory.getBean(validatorBean);
    if (StringUtil.isEmpty(this.singlePage)) {
        this.singlePage = "app/" + NamingUtil.toElementName(this.entityBeanType.getSimpleName()) + "-crud";
    }
    Assert.notNull(service, this.getClass().getSimpleName() + " is not associated with a service class ["
            + serviceBean + "]. Please check your configuration.");

    // initialize transaction template.
    PlatformTransactionManager txManager = (PlatformTransactionManager) beanFactory
            .getBean("transactionManager");
    this.transactionTemplate = new TransactionTemplate(txManager);
}

From source file:dao.SearchDAO.java

public static ObjectNode getPagedMetricByKeyword(final String category, String keyword, int page, int size) {
    List<Metric> pagedMetrics = new ArrayList<Metric>();
    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 .  jav  a  2s. c  o m*/
    result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
        public ObjectNode doInTransaction(TransactionStatus status) {
            String query = SEARCH_METRIC_WITH_PAGINATION.replace("$keyword", keyword);
            List<Map<String, Object>> rows = null;
            rows = jdbcTemplate.queryForList(query, (page - 1) * size, size);
            for (Map row : rows) {

                Metric metric = new Metric();
                metric.id = (Integer) row.get(MetricRowMapper.METRIC_ID_COLUMN);
                metric.name = (String) row.get(MetricRowMapper.METRIC_NAME_COLUMN);
                metric.refID = (String) row.get(MetricRowMapper.METRIC_REF_ID_COLUMN);
                metric.refIDType = (String) row.get(MetricRowMapper.METRIC_REF_ID_TYPE_COLUMN);
                metric.description = (String) row.get(MetricRowMapper.METRIC_DESCRIPTION_COLUMN);
                metric.dashboardName = (String) row.get(MetricRowMapper.METRIC_DASHBOARD_NAME_COLUMN);
                metric.category = (String) row.get(MetricRowMapper.METRIC_CATEGORY_COLUMN);
                metric.group = (String) row.get(MetricRowMapper.METRIC_GROUP_COLUMN);
                metric.source = "metric";
                metric.urn = "";
                if (StringUtils.isNotBlank(metric.dashboardName)) {
                    metric.urn += metric.dashboardName + "/";
                }
                if (StringUtils.isNotBlank(metric.group)) {
                    metric.urn += metric.group + "/";
                }
                if (StringUtils.isNotBlank(metric.name)) {
                    metric.urn += metric.name;
                }

                ObjectNode schema = Json.newObject();
                schema.put(MetricRowMapper.METRIC_REF_ID_COLUMN, metric.refID);
                schema.put(MetricRowMapper.METRIC_REF_ID_TYPE_COLUMN, metric.refIDType);
                schema.put(MetricRowMapper.METRIC_DESCRIPTION_COLUMN, metric.description);
                schema.put(MetricRowMapper.METRIC_DASHBOARD_NAME_COLUMN, metric.dashboardName);
                schema.put(MetricRowMapper.METRIC_CATEGORY_COLUMN, metric.category);
                schema.put(MetricRowMapper.METRIC_GROUP_COLUMN, metric.group);
                metric.schema = schema.toString();
                pagedMetrics.add(metric);
            }
            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("itemsPerPage", size);
            resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
            resultNode.set("data", Json.toJson(pagedMetrics));

            return resultNode;
        }
    });

    return result;
}

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

@Test
public void testJtaTransactionWithIsolationLevelContentSourceAdapter() throws Exception {
    given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
            Status.STATUS_ACTIVE, Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);

    final IsolationLevelContentSourceAdapter dsToUse = new IsolationLevelContentSourceAdapter();
    dsToUse.setTargetContentSource(contentSource);
    dsToUse.afterPropertiesSet();//from ww  w  .ja v  a 2 s . c o  m

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction);
    ptm.setAllowCustomIsolationLevels(true);

    TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            Session c = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            assertSame(session, c);
            ContentSourceUtils.releaseSession(c, dsToUse);
        }
    });

    tt.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
    tt.setReadOnly(true);
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            Session c = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            assertSame(session, c);
            ContentSourceUtils.releaseSession(c, dsToUse);
        }
    });

    verify(userTransaction, times(2)).begin();
    verify(userTransaction, times(2)).commit();
    verify(session).setTransactionMode(Session.TransactionMode.QUERY);
    verify(session, times(2)).close();
}

From source file:database.DataLoader.java

private void addAuthorRights() throws Exception {
    final String modelName = USERS;
    final ResultSet userRes = getFromOldBase("select * from z_zauthor");
    while (userRes.next()) {

        final TransactionTemplate transactionTemplate = new TransactionTemplate(transactionManager);
        transactionTemplate.execute(new TransactionCallbackWithoutResult() {

            @Override/*from   ww w.java2s.  c  o  m*/
            protected void doInTransactionWithoutResult(TransactionStatus ts) {
                try {
                    Long userId = userRes.getLong("id");
                    Long branchId = userRes.getLong("branch_id");
                    Long newUserId = getNewId(userId, modelName);
                    User user = getUser(newUserId);
                    if (branchId != 0) {
                        Long newBranchId = getNewId(branchId, BRANCH);
                        Branch branch = branchDao.find(newBranchId);
                        List<Long> branchIds = new ArrayList();
                        if (user instanceof Author) {
                            branchIds.add(newBranchId);
                            authorService.changeRoleForAuthor(newUserId, branchIds);
                        }
                    } else {
                        List<Branch> branchList = branchDao.getAll();
                        List<Long> branchIds = new ArrayList();
                        for (Branch branch : branchList) {
                            branchIds.add(branch.getBranchId());
                        }
                        if (user instanceof Author) {
                            authorService.changeRoleForAuthor(newUserId, branchIds);
                        }
                    }
                } catch (Exception e) {
                    ts.setRollbackOnly();
                    addErrorMessage(StringAdapter.getStackExeption(e));
                }
            }
        });
    }
}

From source file:dao.DashboardDAO.java

public static ObjectNode getPagedComplianceDatasetsByManagerId(String managerId, String platform, String option,
        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) {
            long count;
            List<Map<String, Object>> rows = new ArrayList<>(size);
            if (StringUtils.isNotBlank(option) && !(option.equalsIgnoreCase(ALL_DATASETS))) {
                count = getPagedDashboardDatasets(managerId, GET_DATASETS_WITH_COMPLIANCE_FILTER_PLATFORM,
                        platform, option, page, size, rows);
            } else {
                count = getPagedDashboardDatasets(managerId, GET_ALL_DATASETS_BY_ID_FILTER_PLATFORM, platform,
                        null, page, size, rows);
            }/*  ww  w .j a v  a 2 s. c  om*/

            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_COMPLIANCE_FIELDS_BY_DATASET_ID, String.class, dashboardDataset.datasetId);
                }
                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.AdvSearchDAO.java

public static ObjectNode search(JsonNode searchOpt, int page, int size) {
    ObjectNode resultNode = Json.newObject();
    int count = 0;
    List<String> scopeInList = new ArrayList<String>();
    List<String> scopeNotInList = new ArrayList<String>();
    List<String> tableInList = new ArrayList<String>();
    List<String> tableNotInList = new ArrayList<String>();
    List<String> fieldAnyList = new ArrayList<String>();
    List<String> fieldAllList = new ArrayList<String>();
    List<String> fieldNotInList = new ArrayList<String>();
    String fieldAllIDs = "";
    String comments = "";

    if (searchOpt != null && (searchOpt.isContainerNode())) {
        if (searchOpt.has("scope")) {
            JsonNode scopeNode = searchOpt.get("scope");
            if (scopeNode != null && scopeNode.isContainerNode()) {
                if (scopeNode.has("in")) {
                    JsonNode scopeInNode = scopeNode.get("in");
                    if (scopeInNode != null) {
                        String scopeInStr = scopeInNode.asText();
                        if (StringUtils.isNotBlank(scopeInStr)) {
                            String[] scopeInArray = scopeInStr.split(",");
                            if (scopeInArray != null) {
                                for (String value : scopeInArray) {
                                    if (StringUtils.isNotBlank(value)) {
                                        scopeInList.add(value.trim());
                                    }//from   w ww .j  av  a 2 s  .  c o m
                                }
                            }
                        }
                    }
                }
                if (scopeNode.has("not")) {
                    JsonNode scopeNotInNode = scopeNode.get("not");
                    if (scopeNotInNode != null) {
                        String scopeNotInStr = scopeNotInNode.asText();
                        if (StringUtils.isNotBlank(scopeNotInStr)) {
                            String[] scopeNotInArray = scopeNotInStr.split(",");
                            if (scopeNotInArray != null) {
                                for (String value : scopeNotInArray) {
                                    if (StringUtils.isNotBlank(value)) {
                                        scopeNotInList.add(value.trim());
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        if (searchOpt.has("table")) {
            JsonNode tableNode = searchOpt.get("table");
            if (tableNode != null && tableNode.isContainerNode()) {
                if (tableNode.has("in")) {
                    JsonNode tableInNode = tableNode.get("in");
                    if (tableInNode != null) {
                        String tableInStr = tableInNode.asText();
                        if (StringUtils.isNotBlank(tableInStr)) {
                            String[] tableInArray = tableInStr.split(",");
                            if (tableInArray != null) {
                                for (String value : tableInArray) {
                                    if (StringUtils.isNotBlank(value)) {
                                        tableInList.add(value.trim());
                                    }
                                }
                            }
                        }
                    }
                }
                if (tableNode.has("not")) {
                    JsonNode tableNotInNode = tableNode.get("not");
                    if (tableNotInNode != null) {
                        String tableNotInStr = tableNotInNode.asText();
                        if (StringUtils.isNotBlank(tableNotInStr)) {
                            String[] tableNotInArray = tableNotInStr.split(",");
                            if (tableNotInArray != null) {
                                for (String value : tableNotInArray) {
                                    if (StringUtils.isNotBlank(value)) {
                                        tableNotInList.add(value.trim());
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        if (searchOpt.has("fields")) {
            JsonNode fieldNode = searchOpt.get("fields");
            if (fieldNode != null && fieldNode.isContainerNode()) {
                if (fieldNode.has("any")) {
                    JsonNode fieldAnyNode = fieldNode.get("any");
                    if (fieldAnyNode != null) {
                        String fieldAnyStr = fieldAnyNode.asText();
                        if (StringUtils.isNotBlank(fieldAnyStr)) {
                            String[] fieldAnyArray = fieldAnyStr.split(",");
                            if (fieldAnyArray != null) {
                                for (String value : fieldAnyArray) {
                                    if (StringUtils.isNotBlank(value)) {
                                        fieldAnyList.add(value.trim());
                                    }
                                }
                            }
                        }
                    }
                }
                if (fieldNode.has("all")) {
                    JsonNode fieldAllNode = fieldNode.get("all");
                    if (fieldAllNode != null) {
                        String fieldAllStr = fieldAllNode.asText();
                        if (StringUtils.isNotBlank(fieldAllStr)) {
                            String[] fieldAllArray = fieldAllStr.split(",");
                            if (fieldAllArray != null) {
                                for (String value : fieldAllArray) {
                                    if (StringUtils.isNotBlank(value)) {
                                        fieldAllList.add(value.trim());
                                    }
                                }
                            }
                        }
                    }
                }
                if (fieldNode.has("not")) {
                    JsonNode fieldNotInNode = fieldNode.get("not");
                    if (fieldNotInNode != null) {
                        String fieldNotInStr = fieldNotInNode.asText();
                        if (StringUtils.isNotBlank(fieldNotInStr)) {
                            String[] fieldNotInArray = fieldNotInStr.split(",");
                            if (fieldNotInArray != null) {
                                for (String value : fieldNotInArray) {
                                    if (StringUtils.isNotBlank(value)) {
                                        fieldNotInList.add(value.trim());
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }

        String datasetSources = "";
        if (searchOpt.has("sources")) {
            JsonNode sourcesNode = searchOpt.get("sources");
            if (sourcesNode != null) {
                datasetSources = sourcesNode.asText();
            }
        }

        boolean needAndKeyword = false;
        int fieldQueryIndex = 0;
        if (fieldAllList.size() > 0) {
            String fieldAllQuery = "SELECT DISTINCT f1.dataset_id FROM dict_field_detail f1 ";
            String fieldWhereClause = " WHERE ";
            for (String field : fieldAllList) {
                fieldQueryIndex++;
                if (fieldQueryIndex == 1) {
                    fieldWhereClause += "f1.field_name LIKE '%" + field + "%' ";
                } else {
                    fieldAllQuery += "JOIN dict_field_detail f" + fieldQueryIndex + " ON f"
                            + (fieldQueryIndex - 1) + ".dataset_id = f" + fieldQueryIndex + ".dataset_id ";
                    fieldWhereClause += " and f" + fieldQueryIndex + ".field_name LIKE '%" + field + "%' ";

                }
            }
            fieldAllQuery += fieldWhereClause;
            List<Map<String, Object>> rows = getJdbcTemplate().queryForList(fieldAllQuery);
            for (Map row : rows) {

                fieldAllIDs += (Long) row.get("dataset_id") + ",";
            }
            if (fieldAllIDs.length() > 0) {
                fieldAllIDs = fieldAllIDs.substring(0, fieldAllIDs.length() - 1);
            }
            if (StringUtils.isBlank(fieldAllIDs)) {
                fieldAllIDs = Integer.toString(0);

            }
        }

        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;

        if (searchOpt.has("comments")) {
            JsonNode commentsNode = searchOpt.get("comments");
            if (commentsNode != null) {
                comments = commentsNode.asText();
                if (StringUtils.isNotBlank(comments)) {
                    if (scopeInList.size() == 0 && scopeNotInList.size() == 0 && tableInList.size() == 0
                            && tableNotInList.size() == 0 && fieldAllList.size() == 0
                            && fieldAnyList.size() == 0 && fieldNotInList.size() == 0) {
                        final String commentsQueryStr = SEARCH_DATASETS_BY_COMMENTS_WITH_PAGINATION
                                .replace("$keyword", comments);

                        result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
                            public ObjectNode doInTransaction(TransactionStatus status) {
                                List<Map<String, Object>> rows = null;
                                rows = jdbcTemplate.queryForList(commentsQueryStr, (page - 1) * size, size);

                                for (Map row : rows) {

                                    Dataset ds = new Dataset();
                                    ds.id = (Long) row.get("id");
                                    ds.name = (String) row.get("name");
                                    ds.source = (String) row.get("source");
                                    ds.urn = (String) row.get("urn");
                                    ds.schema = (String) row.get("schema");
                                    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("itemsPerPage", size);
                                resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
                                resultNode.set("data", Json.toJson(pagedDatasets));

                                return resultNode;
                            }
                        });
                        return result;
                    }
                }
            }
        }

        String query = "";
        if (StringUtils.isNotBlank(comments)) {
            query = "SELECT DISTINCT d.id FROM dict_dataset d";
        } else {
            query = "SELECT SQL_CALC_FOUND_ROWS " + "DISTINCT d.id, d.name, d.schema, d.source, d.urn, "
                    + "FROM_UNIXTIME(d.source_modified_time) as modified FROM dict_dataset d";
        }
        if (fieldAllList.size() > 0 || fieldAnyList.size() > 0 || fieldNotInList.size() > 0) {
            String fieldQuery = "SELECT DISTINCT dataset_id FROM dict_field_detail f WHERE (";
            query += " WHERE d.id IN ( ";
            query += fieldQuery;
            String whereClause = "";
            boolean fieldNeedAndKeyword = false;
            if (fieldAnyList.size() > 0) {
                whereClause = " (";
                int indexForAnyList = 0;
                for (String field : fieldAnyList) {
                    if (indexForAnyList == 0) {
                        whereClause += "f.field_name LIKE '%" + field + "%'";
                    } else {
                        whereClause += " or f.field_name LIKE '%" + field + "%'";
                    }
                    indexForAnyList++;
                }
                whereClause += " ) ";
                fieldNeedAndKeyword = true;
                query += whereClause;
            }
            if (fieldAllList.size() > 0 && StringUtils.isNotBlank(fieldAllIDs)) {
                if (fieldNeedAndKeyword) {
                    whereClause = " and (";
                } else {
                    whereClause = " (";
                }
                whereClause += "f.dataset_id IN (" + fieldAllIDs + ")";
                whereClause += " ) ";
                query += whereClause;
                fieldNeedAndKeyword = true;
            }
            if (fieldNotInList.size() > 0) {
                if (fieldNeedAndKeyword) {
                    whereClause = " and ( f.dataset_id not in (select dataset_id from dict_field_detail where";
                } else {
                    whereClause = " ( f.dataset_id not in (select dataset_id from dict_field_detail where";
                }
                int indexForNotInList = 0;
                for (String field : fieldNotInList) {
                    if (indexForNotInList == 0) {
                        whereClause += " field_name LIKE '%" + field + "%'";
                    } else {
                        whereClause += " or field_name LIKE '%" + field + "%'";
                    }
                    indexForNotInList++;
                }
                whereClause += " )) ";
                query += whereClause;
                fieldNeedAndKeyword = true;
            }
            needAndKeyword = true;
            query += ") )";
        }

        if (scopeInList.size() > 0 || scopeNotInList.size() > 0) {
            if (needAndKeyword) {
                query += " and";
            } else {
                query += " where";
            }
            boolean scopeNeedAndKeyword = false;
            if (scopeInList.size() > 0) {
                query += " d.parent_name in (";
                scopeNeedAndKeyword = true;
                int indexForScopeInList = 0;
                for (String scope : scopeInList) {
                    if (indexForScopeInList == 0) {
                        query += "'" + scope + "'";
                    } else {
                        query += ", '" + scope + "'";
                    }
                    indexForScopeInList++;
                }
                query += ") ";
            }
            if (scopeNotInList.size() > 0) {
                if (scopeNeedAndKeyword) {
                    query += " and d.parent_name not in (";
                } else {
                    query += " d.parent_name not in (";
                }
                int indexForScopeNotInList = 0;
                for (String scope : scopeNotInList) {
                    if (indexForScopeNotInList == 0) {
                        query += "'" + scope + "'";
                    } else {
                        query += ", '" + scope + "'";
                    }
                    indexForScopeNotInList++;
                }
                query += ") ";
            }
            needAndKeyword = true;
        }
        String condition1 = "";
        String condition2 = "";
        String condition3 = "";
        String condition4 = "";

        if (tableInList.size() > 0 || tableNotInList.size() > 0) {
            if (needAndKeyword) {
                query += " and";
            } else {
                query += " where";
            }
            boolean tableNeedAndKeyword = false;
            if (tableInList.size() > 0) {
                query += " (";
                int indexForTableInList = 0;
                for (String table : tableInList) {
                    if (indexForTableInList == 0) {
                        query += "d.name LIKE '%" + table + "%'";
                    } else {
                        condition1 += " or ";
                        condition2 += " or ";
                        condition3 += " or ";
                        condition4 += " or ";
                        query += " or d.name LIKE '%" + table + "%'";
                    }
                    condition1 += "name = '" + table + "'";
                    condition2 += "name LIKE '" + table + "%'";
                    condition3 += "name LIKE '%" + table + "'";
                    condition4 += "name LIKE '%" + table + "%'";
                    indexForTableInList++;
                }
                query += " ) ";
                tableNeedAndKeyword = true;
            }
            if (tableNotInList.size() > 0) {
                if (tableNeedAndKeyword) {
                    query += " and (";
                } else {
                    query += " (";
                }
                int indexForTableNotInList = 0;
                for (String table : tableNotInList) {
                    if (indexForTableNotInList == 0) {
                        query += "d.name NOT LIKE '%" + table + "%'";
                    } else {
                        query += " and d.name NOT LIKE '%" + table + "%'";
                    }
                    indexForTableNotInList++;
                }
                query += " ) ";
            }
            needAndKeyword = true;
        }

        if (StringUtils.isNotBlank(datasetSources)) {
            if (needAndKeyword) {
                query += " and";
            } else {
                query += " WHERE";
            }
            query += " d.source in (";
            String[] dataestSourceArray = datasetSources.split(",");
            for (int i = 0; i < dataestSourceArray.length; i++) {
                query += "'" + dataestSourceArray[i] + "'";
                if (i != (dataestSourceArray.length - 1)) {
                    query += ",";
                }
            }
            query += ")";
        }
        if ((tableInList.size() > 0 || tableNotInList.size() > 0) && StringUtils.isNotBlank(condition1)
                && StringUtils.isNotBlank(condition2) && StringUtils.isNotBlank(condition3)
                && StringUtils.isNotBlank(condition4)) {
            query += ADVSEARCH_RANK_CLAUSE.replace("$condition1", condition1).replace("$condition2", condition2)
                    .replace("$condition3", condition3).replace("$condition4", condition4);
        } else {
            query += " ORDER BY CASE WHEN urn LIKE 'teradata://DWH_%' THEN 2 "
                    + "WHEN urn LIKE 'hdfs://data/tracking/%' THEN 1 "
                    + "WHEN urn LIKE 'teradata://DWH/%' THEN 3 "
                    + "WHEN urn LIKE 'hdfs://data/databases/%' THEN 4 "
                    + "WHEN urn LIKE 'hdfs://data/dervied/%' THEN 5 ELSE 99 end, urn";
        }
        if (StringUtils.isBlank(comments)) {
            query += " LIMIT " + (page - 1) * size + ", " + size;
            final String queryString = query;

            result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
                public ObjectNode doInTransaction(TransactionStatus status) {
                    List<Map<String, Object>> rows = null;
                    rows = jdbcTemplate.queryForList(queryString);

                    for (Map row : rows) {

                        Dataset ds = new Dataset();
                        ds.id = (Long) row.get("id");
                        ds.name = (String) row.get("name");
                        ds.source = (String) row.get("source");
                        ds.urn = (String) row.get("urn");
                        ds.schema = (String) row.get("schema");
                        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("itemsPerPage", size);
                    resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
                    resultNode.set("data", Json.toJson(pagedDatasets));

                    return resultNode;
                }
            });
            return result;
        } else {
            String datasetIDStr = "";
            final String queryString = query;

            datasetIDStr = txTemplate.execute(new TransactionCallback<String>() {
                public String doInTransaction(TransactionStatus status) {
                    List<Map<String, Object>> rows = null;
                    rows = jdbcTemplate.queryForList(queryString);
                    String idsString = "";

                    for (Map row : rows) {

                        Long id = (Long) row.get("id");
                        idsString += Long.toString(id) + ",";
                    }
                    if (StringUtils.isNotBlank(idsString)) {
                        idsString = idsString.substring(0, idsString.length() - 1);
                    }
                    return idsString;
                }
            });
            if (StringUtils.isBlank(datasetIDStr)) {
                resultNode.put("count", 0);
                resultNode.put("page", page);
                resultNode.put("itemsPerPage", size);
                resultNode.put("totalPages", 0);
                resultNode.set("data", Json.toJson(""));
                return resultNode;
            }
            final String commentsQueryWithConditionStr = DATASET_BY_COMMENT_PAGINATION_IN_CLAUSE
                    .replace("$keyword", comments).replace("$id_list", datasetIDStr);
            result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
                public ObjectNode doInTransaction(TransactionStatus status) {
                    List<Map<String, Object>> rows = null;
                    rows = jdbcTemplate.queryForList(commentsQueryWithConditionStr, (page - 1) * size, size);

                    for (Map row : rows) {

                        Dataset ds = new Dataset();
                        ds.id = (Long) row.get("id");
                        ds.name = (String) row.get("name");
                        ds.source = (String) row.get("source");
                        ds.urn = (String) row.get("urn");
                        ds.schema = (String) row.get("schema");
                        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("itemsPerPage", size);
                    resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
                    resultNode.set("data", Json.toJson(pagedDatasets));

                    return resultNode;
                }
            });
            return result;
        }
    }
    resultNode.put("count", 0);
    resultNode.put("page", page);
    resultNode.put("itemsPerPage", size);
    resultNode.put("totalPages", 0);
    resultNode.set("data", Json.toJson(""));
    return resultNode;
}

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

private void doTestJtaTransactionWithIsolationLevelContentSourceRouter() throws Exception {
    given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
            Status.STATUS_ACTIVE, Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE, Status.STATUS_ACTIVE);

    final ContentSource contentSource1 = mock(ContentSource.class);
    final Session session1 = mock(Session.class);
    given(contentSource1.newSession()).willReturn(session1);

    final ContentSource contentSource2 = mock(ContentSource.class);
    final Session session2 = mock(Session.class);
    given(contentSource2.newSession()).willReturn(session2);

    final IsolationLevelContentSourceRouter dsToUse = new IsolationLevelContentSourceRouter();
    Map<Object, Object> targetContentSources = new HashMap<Object, Object>();

    targetContentSources.put("ISOLATION_REPEATABLE_READ", contentSource2);
    dsToUse.setDefaultTargetContentSource(contentSource1);

    dsToUse.setTargetContentSources(targetContentSources);
    dsToUse.afterPropertiesSet();//from  w  w  w.  j av a2  s.co m

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction);
    ptm.setAllowCustomIsolationLevels(true);

    TransactionTemplate tt = new TransactionTemplate(ptm);
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            Session c = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            assertSame(session1, c);
            ContentSourceUtils.releaseSession(c, dsToUse);
        }
    });

    tt.setIsolationLevel(TransactionDefinition.ISOLATION_REPEATABLE_READ);
    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            Session c = ContentSourceUtils.getSession(dsToUse);
            assertTrue("Has thread session", TransactionSynchronizationManager.hasResource(dsToUse));
            assertSame(session2, c);
            ContentSourceUtils.releaseSession(c, dsToUse);
        }
    });

    verify(userTransaction, times(2)).begin();
    verify(userTransaction, times(2)).commit();
    verify(session1).close();
    verify(session2).close();
}

From source file:com.formkiq.web.AbstractIntegrationTest.java

/**
 * Save Client./*from w  w  w .  j  a  va  2 s  . c om*/
 * @param clientid {@link String}
 * @param clientsecret {@link String}
 * @return {@link String}
 */
protected String saveClient(final String clientid, final String clientsecret) {

    TransactionTemplate transactionTemplate = new TransactionTemplate(this.getPlatformTransactionManager());
    return (String) transactionTemplate.execute(new TransactionCallback<Object>() {
        @Override
        public Object doInTransaction(final TransactionStatus arg0) {

            List<OAuthGrantTypes> grantTypes = Arrays.asList(OAuthGrantTypes.AUTHORIZATION_CODE,
                    OAuthGrantTypes.PASSWORD, OAuthGrantTypes.REFRESH_TOKEN);

            AbstractIntegrationTest.this.oauthservice.save(clientid, clientid, clientsecret, grantTypes, false);
            return null;
        }
    });
}

From source file:dao.SearchDAO.java

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

    TransactionTemplate txTemplate = new TransactionTemplate(tm);

    ObjectNode result;/*from  www .  j  a  va2  s.c  o  m*/
    result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
        public ObjectNode doInTransaction(TransactionStatus status) {
            String query = SEARCH_FLOW_WITH_PAGINATION.replace("$keyword", keyword);
            List<Map<String, Object>> rows = null;

            rows = jdbcTemplate.queryForList(query, (page - 1) * size, size);
            for (Map row : rows) {

                FlowJob flow = new FlowJob();
                flow.flowId = (Long) row.get(FlowRowMapper.FLOW_ID_COLUMN);
                flow.flowName = (String) row.get(FlowRowMapper.FLOW_NAME_COLUMN);
                flow.flowPath = (String) row.get(FlowRowMapper.FLOW_PATH_COLUMN);
                flow.flowGroup = (String) row.get(FlowRowMapper.FLOW_GROUP_COLUMN);
                flow.appCode = (String) row.get(FlowRowMapper.APP_CODE_COLUMN);
                flow.appId = (Integer) row.get(FlowRowMapper.APP_ID_COLUMN);
                flow.displayName = flow.flowName;
                flow.link = "#/flows/name/" + flow.appCode + "/" + Long.toString(flow.flowId) + "/page/1?urn="
                        + flow.flowGroup;
                flow.path = flow.appCode + "/" + flow.flowPath;
                pagedFlows.add(flow);
            }
            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("isFlowJob", true);
            resultNode.put("page", page);
            resultNode.put("category", category);
            resultNode.put("itemsPerPage", size);
            resultNode.put("totalPages", (int) Math.ceil(count / ((double) size)));
            resultNode.set("data", Json.toJson(pagedFlows));

            return resultNode;
        }
    });

    return result;
}