java类org.springframework.transaction.annotation.Propagation的实例源码

@Test
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void testCreateUnmappedGeneIndex() throws IOException, InterruptedException, FeatureIndexException,
        NoSuchAlgorithmException {
    Chromosome chr1 = EntityHelper.createNewChromosome("chr1");
    chr1.setSize(TEST_CHROMOSOME_SIZE);
    Reference testHumanReference = EntityHelper.createNewReference(chr1,
            referenceGenomeManager.createReferenceId());

    referenceGenomeManager.register(testHumanReference);
    Long humanReferenceId = testHumanReference.getId();

    Resource resource = context.getResource("classpath:templates/mrna.sorted.chunk.gtf");

    FeatureIndexedFileRegistrationRequest request = new FeatureIndexedFileRegistrationRequest();
    request.setReferenceId(humanReferenceId);
    request.setPath(resource.getFile().getAbsolutePath());

    GeneFile geneFile = gffManager.registerGeneFile(request);
    Assert.assertNotNull(geneFile);
    Assert.assertNotNull(geneFile.getId());

    Project project = new Project();
    project.setName(TEST_PROJECT_NAME + 1);

    project.setItems(Arrays.asList(
            new ProjectItem(new BiologicalDataItem(geneFile.getBioDataItemId())),
            new ProjectItem(new BiologicalDataItem(testHumanReference.getBioDataItemId()))));
    projectManager.saveProject(project);

    List<FeatureIndexEntry> entryList = (List<FeatureIndexEntry>)
            featureIndexManager.searchFeaturesInProject("", project.getId()).getEntries();
    Assert.assertTrue(entryList.isEmpty());

    entryList = (List<FeatureIndexEntry>) featureIndexManager.searchFeaturesInProject("AM992871",
                                                                                      project.getId()).getEntries();
    Assert.assertTrue(entryList.isEmpty()); // we don't search for exons
}

@Override
@SecureOnCallSystem
@Transactional(propagation = Propagation.MANDATORY)
public void deleteAll()
{
    getHibernateTemplate().deleteAll(listAllUsers());
}

@Transactional(propagation = Propagation.MANDATORY)
@Override
public void delete(Item item)
{
    List<ThumbnailRequest> thumbsForItem = findAllByCriteria(Restrictions.eq("itemUuid", item.getUuid()),
        Restrictions.eq("itemVersion", item.getVersion()), Restrictions.eq("institution", CurrentInstitution.get()));
    for( ThumbnailRequest thumb : thumbsForItem )
    {
        delete(thumb);
    }
}

@Transactional(propagation = Propagation.MANDATORY)
@SecureOnReturn(priv = "CREATE_ITEM")
@Override
public ItemDefinition getForItemCreate(String uuid)
{
    ItemDefinition collection = getByUuid(uuid);
    if( collection == null )
    {
        throw new NotFoundException("Collection '" + uuid + "' doesn't exist");
    }
    return collection;
}

@Override
@Transactional(propagation = Propagation.REQUIRED, readOnly = false)
public void deleteArticleCommentById(String commentId) {
    MMSnsArticleCommentEntity articleCommentEntity = new MMSnsArticleCommentEntity();
    articleCommentEntity.setCommentId(Integer.parseInt(commentId));
    articleCommentEntity.setCommentStatus(PublicEnum.DELETE.value());
    updateArticleComment(articleCommentEntity);
}

@Override
@Transactional(propagation = Propagation.MANDATORY)
public void saveOrUpdate(AccessEntry entity)
{
    entity.generateAggregateOrdering();
    super.saveOrUpdate(entity);
}

@RequestMapping(value = "/model", method = RequestMethod.POST, produces = "application/json", name="模型创建")
@ResponseStatus(value = HttpStatus.CREATED)
@Transactional(propagation = Propagation.REQUIRED)
public ModelResponse createModel(@RequestBody ModelRequest modelRequest){

    Model model = repositoryService.newModel();
    model.setCategory(modelRequest.getCategory());
    model.setKey(modelRequest.getKey());
    model.setMetaInfo(modelRequest.getMetaInfo());
    model.setName(modelRequest.getName());
    model.setVersion(modelRequest.getVersion());
    model.setTenantId(modelRequest.getTenantId());

    repositoryService.saveModel(model);

    ObjectMapper objectMapper = new ObjectMapper();
    ObjectNode editorNode = objectMapper.createObjectNode();
    editorNode.put(EditorJsonConstants.EDITOR_STENCIL_ID, "canvas");

    editorNode.put(EditorJsonConstants.EDITOR_SHAPE_ID, "canvas");
    //设置流程定义初始化的key和name
    ObjectNode propertieNode = objectMapper.createObjectNode();
    if(StringUtils.isNotEmpty(model.getKey())){
        propertieNode.put(StencilConstants.PROPERTY_PROCESS_ID, model.getKey());
    }else{
        propertieNode.put(StencilConstants.PROPERTY_PROCESS_ID, "model_"+model.getId());
    }
    propertieNode.put(StencilConstants.PROPERTY_NAME, model.getName());
    editorNode.set(EditorJsonConstants.EDITOR_SHAPE_PROPERTIES, propertieNode);
    ObjectNode stencilSetNode = objectMapper.createObjectNode();
    stencilSetNode.put("namespace", "http://b3mn.org/stencilset/bpmn2.0#");
    editorNode.set("stencilset", stencilSetNode);
    try {
        repositoryService.addModelEditorSource(model.getId(), editorNode.toString().getBytes("utf-8"));
    } catch (UnsupportedEncodingException e) {
        throw new FlowableConflictException("create model exception :"+e.getMessage());
    }

    return restResponseFactory.createModelResponse(model);
}

@Test
@Transactional(propagation = Propagation.REQUIRES_NEW)
public void testRegisterUrl() throws Exception {
    String bedUrl = UrlTestingUtils.TEST_FILE_SERVER_URL + "/genes_sorted.bed";
    String indexUrl = UrlTestingUtils.TEST_FILE_SERVER_URL + "/genes_sorted.bed.tbi";

    Server server = UrlTestingUtils.getFileServer(context);
    try {
        server.start();

        IndexedFileRegistrationRequest request = new IndexedFileRegistrationRequest();
        request.setPath(bedUrl);
        request.setType(BiologicalDataItemResourceType.URL);
        request.setIndexType(BiologicalDataItemResourceType.URL);
        request.setIndexPath(indexUrl);
        request.setReferenceId(referenceId);

        BedFile bedFile = bedManager.registerBed(request);
        Assert.assertNotNull(bedFile);

        bedFile = bedFileManager.loadBedFile(bedFile.getId());
        Assert.assertNotNull(bedFile.getId());
        Assert.assertNotNull(bedFile.getBioDataItemId());
        Assert.assertNotNull(bedFile.getIndex());
        Assert.assertFalse(bedFile.getPath().isEmpty());
        Assert.assertFalse(bedFile.getIndex().getPath().isEmpty());

        testLoadBedRecords(bedFile);
    } finally {
        server.stop();
    }
}

@Test(expected = IllegalArgumentException.class)
@Transactional(propagation = Propagation.REQUIRES_NEW, rollbackFor = Exception.class)
public void deleteReferenceTest() throws IOException {
    Chromosome testChromosome = EntityHelper.createNewChromosome();
    testChromosome.setSize(TEST_CHROMOSOME_SIZE);
    Reference testReference = EntityHelper.createNewReference(testChromosome,
            referenceGenomeManager.createReferenceId());
    File tmp = File.createTempFile(TMP_FILE_NAME, TMP_FILE_NAME);
    testReference.setPath(tmp.getAbsolutePath());
    referenceGenomeManager.register(testReference);
    dataItemManager.deleteFileByBioItemId(testReference.getBioDataItemId());
}

/**
 * Loads a {@code Person} instance from the database specified by it's name and password
 * @param name of a user
 * @param password of a user
 * @return  a loaded {@code Person} instance or
 *          {@code null} if user with a given name and password doesn't exist
 */
@Transactional(propagation = Propagation.MANDATORY)
public Person loadPersonByNameAndPassword(String name, String password) {
    MapSqlParameterSource params = new MapSqlParameterSource();
    params.addValue(PersonParameters.NAME.name(), name);
    params.addValue(PersonParameters.PASSWORD.name(), password);

    List<Person> persons = getNamedParameterJdbcTemplate().query(loadPersonByNameAndPasswordQuery, params,
            PersonParameters.getRowMapper());
    return persons.isEmpty() ? null : persons.get(0);
}