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

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

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

Introduction

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

Prototype

@Override
    @Nullable
    public <T> T execute(TransactionCallback<T> action) throws TransactionException

Source Link

Usage

From source file:alfio.manager.AdminReservationManager.java

public Result<Boolean> updateReservation(String eventName, String reservationId,
        AdminReservationModification adminReservationModification, String username) {
    DefaultTransactionDefinition definition = new DefaultTransactionDefinition();
    TransactionTemplate template = new TransactionTemplate(transactionManager, definition);
    return template.execute(status -> {
        try {// ww  w.  j  ava  2  s . c  o m
            Result<Boolean> result = eventRepository.findOptionalByShortName(eventName)
                    .flatMap(e -> optionally(() -> {
                        eventManager.checkOwnership(e, username, e.getOrganizationId());
                        return e;
                    }))
                    .map(event -> ticketReservationRepository.findOptionalReservationById(reservationId)
                            .map(r -> performUpdate(reservationId, event, r, adminReservationModification))
                            .orElseGet(() -> Result.error(ErrorCode.ReservationError.UPDATE_FAILED)))
                    .orElseGet(() -> Result.error(ErrorCode.ReservationError.NOT_FOUND));
            if (!result.isSuccess()) {
                log.debug(
                        "Application error detected eventName: {} reservationId: {}, username: {}, reservation: {}",
                        eventName, reservationId, username,
                        AdminReservationModification.summary(adminReservationModification));
                status.setRollbackOnly();
            }
            return result;
        } catch (Exception e) {
            log.error(
                    "Error during update of reservation eventName: {} reservationId: {}, username: {}, reservation: {}",
                    eventName, reservationId, username,
                    AdminReservationModification.summary(adminReservationModification));
            status.setRollbackOnly();
            return Result.error(singletonList(ErrorCode.custom("", e.getMessage())));
        }
    });
}

From source file:com.goodhuddle.huddle.service.impl.MemberServiceImpl.java

@Override
public ImportMembersResults importMembers(MultipartFile multipartFile, Long[] tagIds) {
    final ImportMembersResults results = new ImportMembersResults();
    results.setSuccess(true);/*from   ww  w  .  j a v a 2 s  .  c om*/

    try {
        final Huddle huddle = huddleService.getHuddle();

        if (!multipartFile.isEmpty()) {

            File file = fileStore.getTempFile(fileStore.createTempFile(multipartFile.getBytes()));

            final CSVReader reader = new CSVReader(new FileReader(file));
            if (reader.readNext() != null) {
                // skipped header row

                final List<Tag> tags = new ArrayList<>();
                if (tagIds != null) {
                    for (Long tagId : tagIds) {
                        tags.add(tagRepository.findByHuddleAndId(huddle, tagId));
                    }
                }

                boolean done = false;
                while (!done) {
                    TransactionTemplate txTemplate = new TransactionTemplate(txManager);
                    txTemplate.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRES_NEW);
                    done = txTemplate.execute(new TransactionCallback<Boolean>() {

                        @Override
                        public Boolean doInTransaction(TransactionStatus status) {
                            try {
                                int i = 0;
                                String[] nextLine;
                                while ((nextLine = reader.readNext()) != null) {
                                    String email = nextLine[0];
                                    String firstName = nextLine[1];
                                    String lastName = nextLine[2];
                                    String postCode = nextLine[3];
                                    String phone = nextLine[4];

                                    Member member = memberRepository.findByHuddleAndEmailIgnoreCase(huddle,
                                            email);
                                    if (member != null) {
                                        member.setFirstName(firstName);
                                        member.setLastName(lastName);
                                        member.setPostCode(postCode);
                                        member.setPhone(phone);
                                        List<Tag> memberTags = member.getTags();
                                        if (memberTags == null) {
                                            memberTags = new ArrayList<>();
                                        }
                                        outer: for (Tag tag : tags) {
                                            for (Tag memberTag : memberTags) {
                                                if (memberTag.getId() == member.getId()) {
                                                    break outer;
                                                }
                                            }
                                            memberTags.add(tag);
                                        }
                                        member.setTags(memberTags);
                                        memberRepository.save(member);
                                        results.setNumUpdated(results.getNumUpdated() + 1);
                                    } else {
                                        member = new Member();
                                        member.setHuddle(huddle);
                                        member.setEmail(email);
                                        member.setFirstName(firstName);
                                        member.setLastName(lastName);
                                        member.setPostCode(postCode);
                                        member.setPhone(phone);
                                        member.setTags(tags);
                                        memberRepository.save(member);
                                        results.setNumImported(results.getNumImported() + 1);
                                    }

                                    if (i++ > 30) {
                                        return false;
                                    }
                                }
                                return true;
                            } catch (IOException e) {
                                log.error("Error importing file: " + e, e);
                                results.setSuccess(false);
                                results.setErrorMessage("Error importing file: " + e);
                                return true;
                            }
                        }
                    });
                }

            }

        } else {
            log.info("Empty file was uploaded");
            results.setSuccess(false);
            results.setErrorMessage("Empty file was uploaded");
        }
    } catch (IOException e) {
        results.setSuccess(false);
        results.setErrorMessage("Error uploading file: " + e);
    }

    return results;
}

From source file:org.openvpms.archetype.rules.patient.reminder.ReminderRulesTestCase.java

/**
 * Tests the {@link ReminderRules#markMatchingRemindersCompleted(List)} method.
 *//*from   w ww  .  j a  v a  2  s  .  co  m*/
@Test
public void testMarkMatchingRemindersCompletedForList() {
    Entity reminderType = ReminderTestHelper.createReminderType();

    Party patient1 = TestHelper.createPatient();
    Party patient2 = TestHelper.createPatient();

    // create reminders for patient1 and patient2
    Act reminder0 = ReminderTestHelper.createReminder(patient1, reminderType);
    Act reminder1 = ReminderTestHelper.createReminder(patient2, reminderType);
    save(reminder0, reminder1);
    checkReminder(reminder0, ReminderStatus.IN_PROGRESS);
    checkReminder(reminder1, ReminderStatus.IN_PROGRESS);

    Act reminder2 = ReminderTestHelper.createReminder(patient1, reminderType);
    Act reminder3 = ReminderTestHelper.createReminder(patient2, reminderType);
    Act reminder3dup = ReminderTestHelper.createReminder(patient2, reminderType); // duplicates reminder3
    final List<Act> reminders = Arrays.asList(reminder2, reminder3, reminder3dup);
    PlatformTransactionManager mgr = (PlatformTransactionManager) applicationContext.getBean("txnManager");
    TransactionTemplate template = new TransactionTemplate(mgr);
    template.execute(new TransactionCallback<Object>() {
        public Object doInTransaction(TransactionStatus status) {
            save(reminders);
            rules.markMatchingRemindersCompleted(reminders);
            return null;
        }
    });

    checkReminder(reminder0, ReminderStatus.COMPLETED);
    checkReminder(reminder1, ReminderStatus.COMPLETED);
    checkReminder(reminder2, ReminderStatus.IN_PROGRESS);
    checkReminder(reminder3, ReminderStatus.IN_PROGRESS);
    checkReminder(reminder3dup, ReminderStatus.COMPLETED); // as it duplicates reminder3
}

From source file:com.wavemaker.runtime.data.salesforce.SalesforceDataServiceManager.java

private Object runInTx(Task task, Map<String, Class<?>> types, boolean named, Object... input) {
    TransactionTemplate txTemplate = new TransactionTemplate(this.txMgr);
    boolean rollbackOnly = task instanceof DefaultRollback && !isTxRunning();
    RunInTx tx = new RunInTx(rollbackOnly, types, named, input);
    if (txLogger.isInfoEnabled()) {
        if (isTxRunning()) {
            txLogger.info("tx is running executing \"" + task.getName() + "\" in current tx");
        } else {//from  w  ww  .  j  a va 2  s .  co m
            txLogger.info("no tx running, wrapping execution of \"" + task.getName() + "\" in tx");
            if (rollbackOnly) {
                txLogger.info("rollback enabled for \"" + task.getName() + "\"");
            }
        }
    }

    Object rtn = txTemplate.execute(tx);
    if (txLogger.isInfoEnabled()) {
        if (isTxRunning()) {
            txLogger.info("tx is running after execution of \"" + task.getName() + "\"");
        } else {
            txLogger.info("tx is not running after execution of \"" + task.getName() + "\"");
        }
    }

    return rtn;
}

From source file:org.codehaus.grepo.query.commons.repository.GenericQueryRepositorySupport.java

/**
 * Executes the given {@code callback} with either an read-only, normal or none transaction template.
 *
 * @param callback The callback to execute.
 * @param preferReadOnlyTransactionTemplate Flag to indicate if the read-only template should be prefered.
 * @return Returns the result.// ww w.  ja  v a2 s  .c  om
 */
protected Object executeCallback(TransactionCallback<Object> callback,
        boolean preferReadOnlyTransactionTemplate) {
    boolean isReadOnlyTemplateUsed = false;
    TransactionTemplate templateToUse = null;
    if (preferReadOnlyTransactionTemplate && getReadOnlyTransactionTemplate() != null) {
        isReadOnlyTemplateUsed = true;
        templateToUse = getReadOnlyTransactionTemplate();
    } else {
        templateToUse = getTransactionTemplate();
    }

    Object retVal = null;
    if (templateToUse == null) {
        logger.debug("Executing query without using transaction template");
        // execute without transaction...
        retVal = callback.doInTransaction(null);
    } else {
        logger.debug("Executing query using{}transaction template",
                (isReadOnlyTemplateUsed ? " read-only " : " "));
        retVal = templateToUse.execute(callback);
    }
    return retVal;
}

From source file:org.codehaus.grepo.procedure.repository.GenericProcedureRepositorySupport.java

/**
 * Executes the given {@code callback} with either an read-only, normal or none transaction template.
 *
 * @param callback The callback to execute.
 * @param preferReadOnlyTransactionTemplate Flag to indicate if the read-only template should be prefered.
 * @return Returns the result.//from  w w w  .j  a v a2s . com
 */
@SuppressWarnings("unchecked")
protected Map<String, Object> executeCallback(TransactionCallback<Object> callback,
        boolean preferReadOnlyTransactionTemplate) {
    boolean isReadOnlyTemplateUsed = false;
    TransactionTemplate templateToUse = null;
    if (preferReadOnlyTransactionTemplate && getReadOnlyTransactionTemplate() != null) {
        isReadOnlyTemplateUsed = true;
        templateToUse = getReadOnlyTransactionTemplate();
    } else {
        templateToUse = getTransactionTemplate();
    }

    Map<String, Object> retVal = null;
    if (templateToUse == null) {
        logger.debug("Executing procedure without using transaction template");
        // execute without transaction...
        retVal = (Map<String, Object>) callback.doInTransaction(null);
    } else {
        logger.debug("Executing procedure using {} transaction template",
                (isReadOnlyTemplateUsed ? "read-only" : ""));
        retVal = (Map<String, Object>) templateToUse.execute(callback);
    }
    return retVal;
}

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 ww  w  . ja  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: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  ww . j a  v  a2s .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:com._4dconcept.springframework.data.marklogic.datasource.DatabaseConnectorJtaTransactionTest.java

private void doTestJtaTransaction(final boolean rollback) throws Exception {
    if (rollback) {
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE);
    } else {/*from w  ww . j  a  va2 s  .  c  o m*/
        given(userTransaction.getStatus()).willReturn(Status.STATUS_NO_TRANSACTION, Status.STATUS_ACTIVE,
                Status.STATUS_ACTIVE);
    }

    JtaTransactionManager ptm = new JtaTransactionManager(userTransaction);
    TransactionTemplate tt = new TransactionTemplate(ptm);
    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());

    tt.execute(new TransactionCallbackWithoutResult() {
        @Override
        protected void doInTransactionWithoutResult(TransactionStatus status) throws RuntimeException {
            assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
            assertTrue("JTA synchronizations active",
                    TransactionSynchronizationManager.isSynchronizationActive());
            assertTrue("Is new 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));
            ContentSourceUtils.releaseSession(c, contentSource);

            if (rollback) {
                status.setRollbackOnly();
            }
        }
    });

    assertTrue("Hasn't thread session", !TransactionSynchronizationManager.hasResource(contentSource));
    assertTrue("JTA synchronizations not active", !TransactionSynchronizationManager.isSynchronizationActive());
    verify(userTransaction).begin();
    if (rollback) {
        verify(userTransaction).rollback();
    }
    verify(session).close();
}

From source file:dao.ScriptFinderDAO.java

public static ObjectNode getPagedScripts(JsonNode filterOpt, int page, int size) {
    ObjectNode result = Json.newObject();

    javax.sql.DataSource ds = getJdbcTemplate().getDataSource();
    DataSourceTransactionManager tm = new DataSourceTransactionManager(ds);
    TransactionTemplate txTemplate = new TransactionTemplate(tm);
    String scriptName = null;//from  w ww  . java 2  s.co  m
    String scriptPath = null;
    String scriptType = null;
    String chainName = null;
    String jobName = null;
    String committerName = null;
    String committerEmail = null;
    if (filterOpt != null && (filterOpt.isContainerNode())) {
        if (filterOpt.has("scriptName")) {
            scriptName = filterOpt.get("scriptName").asText();
        }
        if (filterOpt.has("scriptPath")) {
            scriptPath = filterOpt.get("scriptPath").asText();
        }
        if (filterOpt.has("scriptType")) {
            scriptType = filterOpt.get("scriptType").asText();
        }
        if (filterOpt.has("chainName")) {
            chainName = filterOpt.get("chainName").asText();
        }
        if (filterOpt.has("jobName")) {
            jobName = filterOpt.get("jobName").asText();
        }
        if (filterOpt.has("committerName")) {
            committerName = filterOpt.get("committerName").asText();
        }
        if (filterOpt.has("committerEmail")) {
            committerEmail = filterOpt.get("committerEmail").asText();
        }
    }

    final String finalScriptName = scriptName;
    final String finalScriptPath = scriptPath;
    final String finalScriptType = scriptType;
    final String finalChainName = chainName;
    final String finalJobName = jobName;
    final String finalCommitterName = committerName;
    result = txTemplate.execute(new TransactionCallback<ObjectNode>() {
        public ObjectNode doInTransaction(TransactionStatus status) {

            List<Map<String, Object>> rows = null;
            String whereClause = "";
            boolean needAnd = false;
            Map<String, Object> params = new HashMap<String, Object>();
            if (StringUtils.isNotBlank(finalScriptName)) {
                if (StringUtils.isBlank(whereClause)) {
                    whereClause = " WHERE ";
                }
                if (needAnd) {
                    whereClause += " AND ";
                }
                whereClause += " script_name like :scriptname ";
                needAnd = true;
                params.put("scriptname", "%" + finalScriptName + "%");
            }
            if (StringUtils.isNotBlank(finalScriptPath)) {
                if (StringUtils.isBlank(whereClause)) {
                    whereClause = " WHERE ";
                }
                if (needAnd) {
                    whereClause += " AND ";
                }
                whereClause += " script_path like :scriptpath ";
                needAnd = true;
                params.put("scriptpath", "%" + finalScriptPath + "%");
            }
            if (StringUtils.isNotBlank(finalScriptType)) {
                if (StringUtils.isBlank(whereClause)) {
                    whereClause = " WHERE ";
                }
                if (needAnd) {
                    whereClause += " AND ";
                }
                whereClause += " script_type like :scripttype ";
                needAnd = true;
                params.put("scripttype", "%" + finalScriptType + "%");
            }
            if (StringUtils.isNotBlank(finalChainName)) {
                if (StringUtils.isBlank(whereClause)) {
                    whereClause = " WHERE ";
                }
                if (needAnd) {
                    whereClause += " AND ";
                }
                whereClause += " chain_name like :chainname ";
                needAnd = true;
                params.put("chainname", "%" + finalChainName + "%");
            }
            if (StringUtils.isNotBlank(finalJobName)) {
                if (StringUtils.isBlank(whereClause)) {
                    whereClause = " WHERE ";
                }
                if (needAnd) {
                    whereClause += " AND ";
                }
                whereClause += " job_name like :jobname ";
                needAnd = true;
                params.put("jobname", "%" + finalJobName + "%");
            }
            if (StringUtils.isNotBlank(finalCommitterName)) {
                if (StringUtils.isBlank(whereClause)) {
                    whereClause = " WHERE ";
                }
                if (needAnd) {
                    whereClause += " AND ";
                }
                whereClause += " ( committer_ldap like :committername or committer_name like :committername )";
                needAnd = true;
                params.put("committername", "%" + finalCommitterName + "%");
            }
            String query = GET_PAGED_SCRIPTS.replace("$WHERE_CLAUSE", whereClause);
            params.put("index", (page - 1) * size);
            params.put("size", size);
            NamedParameterJdbcTemplate namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(
                    getJdbcTemplate().getDataSource());
            rows = namedParameterJdbcTemplate.queryForList(query, params);
            long count = 0;
            try {
                count = getJdbcTemplate().queryForObject("SELECT FOUND_ROWS()", Long.class);
            } catch (EmptyResultDataAccessException e) {
                Logger.error("Exception = " + e.getMessage());
            }

            List<ScriptInfo> pagedScripts = new ArrayList<ScriptInfo>();
            for (Map row : rows) {
                int applicationID = (Integer) row.get(ScriptInfoRowMapper.APPLICATION_ID_COLUMN);
                int jobID = (Integer) row.get(ScriptInfoRowMapper.JOB_ID_COLUMN);
                String scriptUrl = (String) row.get(ScriptInfoRowMapper.SCRIPT_URL_COLUMN);
                String scriptPath = (String) row.get(ScriptInfoRowMapper.SCRIPT_PATH_COLUMN);
                String scriptType = (String) row.get(ScriptInfoRowMapper.SCRIPT_TYPE_COLUMN);
                String chainName = (String) row.get(ScriptInfoRowMapper.CHAIN_NAME_COLUMN);
                String jobName = (String) row.get(ScriptInfoRowMapper.JOB_NAME_COLUMN);
                String scriptName = (String) row.get(ScriptInfoRowMapper.SCRIPT_NAME_COLUMN);
                String committerName = (String) row.get(ScriptInfoRowMapper.COMMITTER_NAMES_COLUMN);
                String committerEmail = (String) row.get(ScriptInfoRowMapper.COMMITTER_EMAILS_COLUMN);
                ScriptInfo scriptInfo = new ScriptInfo();
                scriptInfo.applicationID = applicationID;
                scriptInfo.jobID = jobID;
                scriptInfo.scriptUrl = scriptUrl;
                scriptInfo.scriptPath = scriptPath;
                scriptInfo.scriptType = scriptType;
                scriptInfo.scriptName = scriptName;
                scriptInfo.chainName = chainName;
                scriptInfo.jobName = jobName;
                scriptInfo.committerName = committerName;
                scriptInfo.committerEmail = committerEmail;
                pagedScripts.add(scriptInfo);
            }

            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("scripts", Json.toJson(pagedScripts));

            return resultNode;
        }
    });

    return result;
}