public Document getBinary(GetBinaryParams params) throws Exception {
    assertMinValue("binaryKey", params.binaryKey, 0);

    final UserEntity runAsUser = securityService.getImpersonatedPortalUser();

    final BinaryDataKey binaryDataKey = new BinaryDataKey(params.binaryKey);
    final BinaryDataEntity binaryData = binaryDataDao.findByKey(binaryDataKey);
    if (binaryData == null) {
      throw AttachmentNotFoundException.notFound(binaryDataKey);
    }

    final ContentBinaryDataEntity contentBinaryDataInMainVersion =
        ContentBinaryDataEntity.resolveContentBinaryDataInMainVersion(
            contentBinaryDataDao.findAllByBinaryKey(binaryData.getKey()));
    if (contentBinaryDataInMainVersion == null) {
      throw AttachmentNotFoundException.notFound(binaryData.getBinaryDataKey());
    }

    final ContentEntity content = contentBinaryDataInMainVersion.getContentVersion().getContent();
    if (content == null || content.isDeleted()) {
      throw AttachmentNotFoundException.notFound(binaryDataKey);
    }
    if (!new ContentAccessResolver(groupDao).hasReadContentAccess(runAsUser, content)) {
      throw AttachmentNotFoundException.noAccess(content.getKey());
    }
    checkContentIsOnline(content);

    return createBinaryDocument(createBinaryData(contentBinaryDataInMainVersion));
  }
Ejemplo n.º 2
0
  @Test
  public void request_content_image_that_binary_is_on_main_version() throws Exception {
    // setup: content
    byte[] bytes = loadImage("Arn.JPG");
    ContentKey contentKey =
        createImageContent(
            "MyImage.jpg", 2, bytes, "ImageCategory", new DateTime(2011, 6, 27, 10, 0, 0, 0), null);

    // setup: draft version of content
    ContentEntity content = fixture.findContentByKey(contentKey);

    BinaryDataEntity binaryDataOfMainVersion = content.getMainVersion().getBinaryData("source");

    // exercise & verify
    String imageRequestPath =
        "_image/" + contentKey + "/binary/" + binaryDataOfMainVersion.getKey() + ".jpg";
    setPathInfoAndRequestURI(httpServletRequest, imageRequestPath);
    httpServletRequest.setParameter("_background", "0xffffff");
    httpServletRequest.setParameter("_quality", "100");

    imageController.handleRequestInternal(httpServletRequest, httpServletResponse);

    assertEquals(HttpServletResponse.SC_OK, httpServletResponse.getStatus());
    assertTrue("Content Length", httpServletResponse.getContentLength() > 0);
    assertEquals("image/jpg", httpServletResponse.getContentType());
  }
  @Test
  public void testUpdateContentWithReplaceNew_WithNullValue() {
    ContentDataInput cdi = getContentData(true);
    UpdateContentParams upcd = getUpdateContentParams(cdi);
    upcd.updateStrategy = ContentDataInputUpdateStrategy.REPLACE_NEW;

    // update content with all fields set
    internalClient.updateContent(upcd);

    // get updated content - make sure all fiels are set
    String xml = getUpdatedContentXMLWithDao();
    assertTrue(
        "XML inneholder ikke <mytitle>updateTest</mytitle>",
        xml.contains("<mytitle>updateTest</mytitle>"));
    assertTrue(
        "XML inneholder ikke <updatefield>foobar</updatefield>",
        xml.contains("<updatefield>foobar</updatefield>"));

    // update content with missing field
    // update content with missing field
    cdi = new ContentDataInput("MyContentType");
    cdi.add(new TextInput("myTitle", "updateTest"));
    cdi.add(new TextInput("fieldToUpdate", null));
    upcd.contentData = cdi;
    internalClient.updateContent(upcd);

    // get updated content
    ContentEntity entity = contentDao.findByKey(updateContentKey);
    ContentVersionEntity version = entity.getMainVersion();
    CustomContentData customContentData = (CustomContentData) version.getContentData();
    TextDataEntry myTitle = (TextDataEntry) customContentData.getEntry("myTitle");
    assertEquals("updateTest", myTitle.getValue());
    TextDataEntry fieldToUpdate = (TextDataEntry) customContentData.getEntry("fieldToUpdate");
    assertFalse(fieldToUpdate.hasValue());
  }
Ejemplo n.º 4
0
  private void handleRecentItems(
      Document verticalDoc,
      Map<Integer, String> contentTypeKeyHandlerMapping,
      final ExtendedMap formItems,
      UserEntity user) {

    String maximize = formItems.getString("maximize", null);
    int index = formItems.getInt("index", 0);
    int count = formItems.getInt("count", maximize != null ? 20 : 10);

    ContentLogEntrySpecification logSpecification = new ContentLogEntrySpecification();
    logSpecification.setUser(user);
    logSpecification.setTypes(
        new LogType[] {LogType.ENTITY_OPENED, LogType.ENTITY_CREATED, LogType.ENTITY_UPDATED});
    logSpecification.setTableTypes(new Table[] {Table.CONTENT});
    logSpecification.setAllowDuplicateEntries(false);
    logSpecification.setAllowDeletedContent(false);

    Calendar now = GregorianCalendar.getInstance();
    final int monthsInPast = 3;
    now.add(Calendar.MONTH, -monthsInPast);
    logSpecification.setDateFilter(now.getTime());

    LogEntryResultSet logResult =
        logService.getLogEntries(logSpecification, "timestamp DESC", count, index);

    if (logResult.getLength() > 0) {

      // build contentTypeKey and handler mapping
      List<ContentKey> contentKeys = new ArrayList<ContentKey>();
      for (LogEntryEntity entity : logResult.getLogEntries()) {
        contentKeys.add(new ContentKey(entity.getKeyValue()));
      }

      ContentByContentQuery contentByContentQuery = new ContentByContentQuery();
      contentByContentQuery.setContentKeyFilter(contentKeys);
      contentByContentQuery.setUser(user);
      contentByContentQuery.setIndex(0);
      contentByContentQuery.setCount(logResult.getLength());
      ContentResultSet contentResultSet = contentService.queryContent(contentByContentQuery);
      for (ContentEntity entity : contentResultSet.getContents()) {
        contentTypeKeyHandlerMapping.put(
            entity.getContentType().getKey(),
            entity.getContentType().getContentHandlerName().getHandlerClassShortName());
      }
    }

    ContentLogXMLCreator logXMLCreator = new ContentLogXMLCreator();
    logXMLCreator.setIncludeContentData(true);
    logXMLCreator.setContentDao(contentDao);
    XMLDocument xmlDocument = logXMLCreator.createLogsDocument(logResult);

    Document lastModifiedDoc = xmlDocument.getAsDOMDocument();

    lastModifiedDoc.getDocumentElement().setAttribute("type", "lastmodified");
    XMLTool.mergeDocuments(verticalDoc, lastModifiedDoc, true);
  }
  @Test
  public void testCreateContentWithBinary() {
    fixture.createAndStoreNormalUserWithUserGroup("testuser", "Test user", "testuserstore");

    fixture.save(
        factory.createContentHandler(
            "Custom content", ContentHandlerName.CUSTOM.getHandlerClassShortName()));
    fixture.save(
        factory.createContentType(
            "MyContentType", ContentHandlerName.CUSTOM.getHandlerClassShortName(), standardConfig));
    fixture.save(factory.createUnit("MyUnit", "en"));
    fixture.save(
        factory.createCategory("MyCategory", "MyContentType", "MyUnit", "testuser", "testuser"));
    fixture.save(factory.createCategoryAccessForUser("MyCategory", "testuser", "read,create"));

    fixture.flushAndClearHibernateSesssion();

    UserEntity runningUser = fixture.findUserByName("testuser");
    PortalSecurityHolder.setImpersonatedUser(runningUser.getKey());

    ContentDataInput contentData = new ContentDataInput("MyContentType");
    contentData.add(new TextInput("myTitle", "testtitle"));
    contentData.add(new BinaryInput("myBinaryfile", dummyBinary, "dummyBinary"));

    CreateContentParams params = new CreateContentParams();
    params.categoryKey = fixture.findCategoryByName("MyCategory").getKey().toInt();
    params.contentData = contentData;
    params.publishFrom = new Date();
    params.publishTo = null;
    params.status = ContentStatus.STATUS_DRAFT;
    int contentKey = internalClient.createContent(params);

    fixture.flushAndClearHibernateSesssion();

    ContentEntity persistedContent = fixture.findContentByKey(new ContentKey(contentKey));
    assertNotNull(persistedContent);
    assertEquals("MyCategory", persistedContent.getCategory().getName());
    ContentVersionEntity persistedVersion = persistedContent.getMainVersion();
    assertNotNull(persistedVersion);
    assertEquals("testtitle", persistedVersion.getTitle());
    assertEquals(
        com.enonic.cms.core.content.ContentStatus.DRAFT.getKey(),
        persistedVersion.getStatus().getKey());

    // verify binary was saved
    Set<ContentBinaryDataEntity> contentBinaryDatas = persistedVersion.getContentBinaryData();
    assertEquals(1, contentBinaryDatas.size());
    ContentBinaryDataEntity contentBinaryData = contentBinaryDatas.iterator().next();
    BinaryDataEntity binaryData = contentBinaryData.getBinaryData();
    assertEquals("dummyBinary", binaryData.getName());

    CustomContentData customContentData = (CustomContentData) persistedVersion.getContentData();
    assertNotNull(customContentData);
  }
  private void validateUpdateContentParams(UpdateContentParams params) {
    if (params.contentKey == null) {
      throw new IllegalArgumentException("contentKey must be specified");
    }
    if (params.updateStrategy == null) {
      throw new IllegalArgumentException("updateStrategy must be specified");
    }
    if (params.publishFrom != null
        && params.publishTo != null
        && !params.publishTo.after(params.publishFrom)) {
      throw new IllegalArgumentException("publishTo must be after publishFrom");
    }
    if (params.createNewVersion
        && params.contentData == null
        && params.updateStrategy == ContentDataInputUpdateStrategy.REPLACE_ALL) {
      throw new IllegalArgumentException(
          "contentData must be specified if you want to create new version when updateStrategy is "
              + ContentDataInputUpdateStrategy.REPLACE_ALL);
    }
    if (params.contentVersionKey != null && params.createNewVersion) {
      throw new IllegalArgumentException(
          "There is no meaning in wanting to both update one specific version and create a new version");
    }

    ContentEntity persistedContent = contentDao.findByKey(new ContentKey(params.contentKey));
    if (persistedContent == null) {
      throw new IllegalArgumentException("No content for given contentKey: " + params.contentKey);
    }

    int currentStatus = persistedContent.getMainVersion().getStatus().getKey();
    if (!params.createNewVersion
        && currentStatus != ContentStatus.DRAFT.getKey()
        && params.contentData != null) {
      throw new IllegalArgumentException(
          "Only allowed to overwrite a draft content version - create new version instead");
    }

    if (params.status != null) {
      boolean currentStatusIsApprovedOrArchived =
          currentStatus == ContentStatus.APPROVED.getKey()
              || currentStatus == ContentStatus.ARCHIVED.getKey();

      if (currentStatusIsApprovedOrArchived) {
        boolean statusChangingingToDraft = params.status == ContentStatus.DRAFT.getKey();
        boolean statusChangingToSnapshot = params.status == ContentStatus.SNAPSHOT.getKey();

        if (!params.createNewVersion && (statusChangingingToDraft || statusChangingToSnapshot)) {
          throw new IllegalArgumentException(
              "Not allowed to change status of an approved or archived content version - create new content version instead");
        }
      }
    }
  }
Ejemplo n.º 7
0
  private void handleActivation(
      Document verticalDoc,
      Map<Integer, String> contentTypeKeyHandlerMapping,
      final ExtendedMap formItems,
      UserEntity user) {

    String maximize = formItems.getString("maximize", null);
    int index = formItems.getInt("index", 0);
    int count = formItems.getInt("count", maximize != null ? 20 : 3);

    ContentBySectionQuery contentBySectionQuery = new ContentBySectionQuery();
    contentBySectionQuery.setSectionFilterStatus(SectionFilterStatus.UNAPPROVED_ONLY);
    contentBySectionQuery.setSearchInAllSections();
    contentBySectionQuery.setCount(count);
    contentBySectionQuery.setUser(user);
    contentBySectionQuery.setOrderBy("timestamp DESC");
    contentBySectionQuery.setIndex(index);
    contentBySectionQuery.setFilterIncludeOfflineContent();
    contentBySectionQuery.setLevels(Integer.MAX_VALUE);

    List<CategoryAccessType> categoryAccessTypeFilter = new ArrayList<CategoryAccessType>();
    categoryAccessTypeFilter.add(CategoryAccessType.ADMINISTRATE);
    categoryAccessTypeFilter.add(CategoryAccessType.APPROVE);
    contentBySectionQuery.setCategoryAccessTypeFilter(
        categoryAccessTypeFilter, CategoryAccessTypeFilterPolicy.OR);

    ContentResultSet contentResultSet = null;
    try {
      contentResultSet = contentService.queryContent(contentBySectionQuery);
    } catch (Exception e) {
      throw new VerticalAdminException("Failed to get unapproved content", e);
    }

    // build contentTypeKey and handlerName mapping
    for (ContentEntity entity : contentResultSet.getContents()) {
      contentTypeKeyHandlerMapping.put(
          entity.getContentType().getKey(),
          entity.getContentType().getContentHandlerName().getHandlerClassShortName());
    }

    SectionXmlCreator sectionXmlCreator =
        new SectionXmlCreator(
            siteDao, new CategoryAccessResolver(groupDao), new ContentAccessResolver(groupDao));
    XMLDocument sectionDocument =
        sectionXmlCreator.createSectionsDocument(user, contentResultSet, count);

    Document waitingForActivationDoc = sectionDocument.getAsDOMDocument();
    // waitingForActivationDoc.getDocumentElement().setAttribute("type", "activation");

    XMLTool.mergeDocuments(verticalDoc, waitingForActivationDoc, true);
  }
  private ContentVersionKey resolveContentVersionKey(
      boolean createNewVersion, int contentKey, Integer contentVeresionKey) {
    ContentEntity persistedContent = contentDao.findByKey(new ContentKey(contentKey));

    ContentVersionKey contentVersionKey;
    if (createNewVersion) {
      contentVersionKey = persistedContent.getMainVersion().getKey();
    } else if (contentVeresionKey == null) {
      contentVersionKey = persistedContent.getMainVersion().getKey();
    } else {
      contentVersionKey = new ContentVersionKey(contentVeresionKey);
    }
    return contentVersionKey;
  }
  private void checkContentIsOnline(final ContentEntity content) {
    if (previewService.isInPreview()) {
      PreviewContext previewContext = previewService.getPreviewContext();
      if (previewContext.isPreviewingContent()
          && previewContext
              .getContentPreviewContext()
              .treatContentAsAvailableEvenIfOffline(content.getKey())) {
        // when in preview, the content doesn't need to be online
        return;
      }
    }

    if (!content.isOnline(timeService.getNowAsDateTime())) {
      throw AttachmentNotFoundException.notFound(content.getKey());
    }
  }
Ejemplo n.º 10
0
  private void removeContentHomeIfThisSectionIs(
      final ContentEntity content, final MenuItemEntity section) {
    final ContentHomeEntity contentHome = content.getContentHome(section.getSite().getKey());

    if (contentHome != null && contentHome.getMenuItem() == null) {
      content.removeContentHome(section.getSite().getKey());
      contentHomeDao.delete(contentHome);
    } else if (contentHome != null && section.getKey() == contentHome.getMenuItem().getKey()) {
      content.removeContentHome(section.getSite().getKey());
      contentHomeDao.delete(contentHome);
    }

    contentHomeDao
        .getHibernateTemplate()
        .getSessionFactory()
        .evictCollection(ContentEntity.class.getName() + ".contentHomes", content.getKey());
  }
Ejemplo n.º 11
0
  private void handleAssignedToMe(
      Document verticalDoc,
      Map<Integer, String> contentTypeKeyHandlerMapping,
      final ExtendedMap formItems,
      UserEntity user) {
    String maximize = formItems.getString("maximize", null);
    int index = formItems.getInt("index", 0);
    int count = formItems.getInt("count", maximize != null ? 20 : ASSIGNED_TO_COUNT);

    ContentSpecification contentSpecification = new ContentSpecification();
    // contentSpecification.setUser( user );
    contentSpecification.setAssignee(user);
    contentSpecification.setAssignedDraftsOnly(false);

    ContentResultSet contentResultSet =
        contentService.getContent(
            contentSpecification, "c.assignmentDueDate ASC, c.timestamp DESC", count, index);

    for (ContentEntity content : contentResultSet.getContents()) {
      contentTypeKeyHandlerMapping.put(
          content.getContentType().getKey(),
          content.getContentType().getContentHandlerName().getHandlerClassShortName());
    }

    ContentXMLCreator contentXMLCreator = new ContentXMLCreator();
    contentXMLCreator.setResultIndexing(index, count);
    contentXMLCreator.setIncludeOwnerAndModifierData(true);
    contentXMLCreator.setIncludeContentData(true);
    contentXMLCreator.setIncludeCategoryData(true);
    contentXMLCreator.setIncludeAccessRightsInfo(false);
    contentXMLCreator.setIncludeRelatedContentsInfo(false);
    contentXMLCreator.setIncludeRepositoryPathInfo(true);
    contentXMLCreator.setIncludeVersionsInfoForAdmin(true);
    contentXMLCreator.setIncludeAssignment(true);
    contentXMLCreator.setIncludeDraftInfo(true);
    contentXMLCreator.setIncludeSectionActivationInfo(true);
    XMLDocument xmlDocument =
        contentXMLCreator.createContentVersionsDocument(
            user, contentResultSet, new RelatedContentResultSetImpl());

    Document doc = xmlDocument.getAsDOMDocument();
    doc.getDocumentElement().setAttribute("type", "assignedto");

    XMLTool.mergeDocuments(verticalDoc, doc, true);
  }
Ejemplo n.º 12
0
  @Test
  public void request_content_image_that_is_deleted() throws Exception {
    byte[] bytes = loadImage("Arn.JPG");
    ContentKey contentKey =
        createImageContent(
            "MyImage.jpg", 2, bytes, "ImageCategory", new DateTime(2011, 6, 27, 10, 0, 0, 0), null);
    ContentEntity content = fixture.findContentByKey(contentKey);
    content.setDeleted(true);

    String imageRequestPath = "_image/" + contentKey + ".jpg";
    setPathInfoAndRequestURI(httpServletRequest, imageRequestPath);
    httpServletRequest.setParameter("_background", "0xffffff");
    httpServletRequest.setParameter("_quality", "100");

    imageController.handleRequestInternal(httpServletRequest, httpServletResponse);
    assertEquals(HttpServletResponse.SC_NOT_FOUND, httpServletResponse.getStatus());
    assertTrue("Content Length", httpServletResponse.getContentLength() == 0);
  }
Ejemplo n.º 13
0
 public ContentHomeEntity createContentHome(
     ContentEntity content, MenuItemEntity menuItem, PageTemplateEntity pageTemplate) {
   ContentHomeEntity contentHome = new ContentHomeEntity();
   contentHome.setKey(new ContentHomeKey(menuItem.getSite().getKey(), content.getKey()));
   contentHome.setContent(content);
   contentHome.setMenuItem(menuItem);
   contentHome.setSite(menuItem.getSite());
   contentHome.setPageTemplate(pageTemplate);
   return contentHome;
 }
Ejemplo n.º 14
0
  @Test
  public void response_ok_for_request_to_content_image_that_binary_is_not_on_main_version()
      throws Exception {
    // setup: content
    byte[] bytes = loadImage("Arn.JPG");
    ContentKey contentKey =
        createImageContent(
            "MyImage.jpg", 2, bytes, "ImageCategory", new DateTime(2011, 6, 27, 10, 0, 0, 0), null);

    // setup: draft version of content
    ContentEntity content = fixture.findContentByKey(contentKey);
    ContentVersionEntity draftVersion = createDraftVersion("Arn.JPG");
    draftVersion.setContentDataXml(content.getMainVersion().getContentDataAsXmlString());
    content.setDraftVersion(draftVersion);
    content.addVersion(draftVersion);
    fixture.save(draftVersion);

    BinaryDataEntity binaryDataForDraftVersion = factory.createBinaryData("Arn.JPG", bytes.length);
    binaryDataForDraftVersion.setBlobKey(
        content.getMainVersion().getBinaryData("source").getBlobKey());
    fixture.save(binaryDataForDraftVersion);

    ContentBinaryDataEntity contentBinaryDataForDraftVersion =
        factory.createContentBinaryData("source", binaryDataForDraftVersion, draftVersion);
    draftVersion.addContentBinaryData(contentBinaryDataForDraftVersion);
    fixture.save(contentBinaryDataForDraftVersion);

    fixture.flushAndClearHibernateSesssion();

    // exercise & verify
    String imageRequestPath = "_image/" + contentKey + "/label/source.jpg";
    setPathInfoAndRequestURI(httpServletRequest, imageRequestPath);
    httpServletRequest.setParameter("_version", draftVersion.getKey().toString());
    httpServletRequest.setParameter("_background", "0xffffff");
    httpServletRequest.setParameter("_quality", "100");

    imageController.handleRequestInternal(httpServletRequest, httpServletResponse);

    assertEquals(HttpServletResponse.SC_OK, httpServletResponse.getStatus());
    assertTrue("Content Length", httpServletResponse.getContentLength() > 0);
    assertEquals("image/jpg", httpServletResponse.getContentType());
  }
Ejemplo n.º 15
0
  public void deleteContent(DeleteContentParams params) {
    UserEntity runningUser = securityService.getImpersonatedPortalUser();

    ContentEntity content = contentDao.findByKey(new ContentKey(params.contentKey));

    if (content != null && !content.isDeleted()) {
      ContentLocationSpecification contentLocationSpecification =
          new ContentLocationSpecification();
      contentLocationSpecification.setIncludeInactiveLocationsInSection(false);
      ContentLocations contentLocations = content.getLocations(contentLocationSpecification);

      contentService.deleteContent(
          runningUser, content, params.siteKey != null ? new SiteKey(params.siteKey) : null);

      for (ContentLocation contentLocation : contentLocations.getAllLocations()) {
        PageCache pageCache = pageCacheService.getPageCacheService(contentLocation.getSiteKey());
        pageCache.removeEntriesByMenuItem(contentLocation.getMenuItemKey());
      }
    }
  }
  private UpdateContentCommand updateContentCommand(
      ContentKey contentKeyToUpdate, ContentData contentData, String updaterUid) {
    ContentEntity contentToUpdate = fixture.findContentByKey(contentKeyToUpdate);

    UpdateContentCommand command =
        UpdateContentCommand.storeNewVersionEvenIfUnchanged(
            contentToUpdate.getMainVersion().getKey());
    command.setUpdateAsMainVersion(true);
    command.setSyncAccessRights(false);
    command.setSyncRelatedContent(true);
    command.setContentKey(contentToUpdate.getKey());
    command.setUpdateStrategy(UpdateContentCommand.UpdateStrategy.MODIFY);
    command.setModifier(fixture.findUserByName(updaterUid).getKey());
    command.setPriority(0);
    command.setLanguage(fixture.findLanguageByCode("en"));
    command.setStatus(ContentStatus.APPROVED);
    command.setContentData(contentData);
    command.setAvailableFrom(DATE_TIME_2010_01_01.toDate());
    return command;
  }
Ejemplo n.º 17
0
  private void doArchiveContent(
      UserEntity importer, ContentKey contentKey, ImportResult importResult) {
    final ContentEntity content = contentDao.findByKey(contentKey);

    if (content == null) {
      return;
    }

    boolean contentArchived = contentStorer.archiveMainVersion(importer, content);
    if (contentArchived) {
      importResult.addArchived(content);

      UnassignContentCommand unassignContentCommand = new UnassignContentCommand();
      unassignContentCommand.setContentKey(content.getKey());
      unassignContentCommand.setUnassigner(importer.getKey());
      contentStorer.unassignContent(unassignContentCommand);
    } else {
      importResult.addAlreadyArchived(content);
    }
  }
  @Test
  public void testUpdateContentDoNotChangeAssignment() {
    // exercise: updateContent

    AssignContentCommand assignContentCommand = new AssignContentCommand();
    assignContentCommand.setAssignerKey(fixture.findUserByName("testuser").getKey());
    assignContentCommand.setAssigneeKey(fixture.findUserByName("testuser").getKey());
    assignContentCommand.setAssignmentDescription("test assignment");
    assignContentCommand.setAssignmentDueDate(new DateTime(2010, 6, 6, 10, 0, 0, 0).toDate());
    assignContentCommand.setContentKey(contentWithBinaryKey);
    contentService.assignContent(assignContentCommand);

    ContentDataInput newContentData = new ContentDataInput("MyContentType");
    newContentData.add(new TextInput("myTitle", "changedtitle"));
    newContentData.add(new BinaryInput("myBinaryfile", dummyBinary, "dummyBinary"));

    UserEntity runningUser = fixture.findUserByName("testuser");
    PortalSecurityHolder.setImpersonatedUser(runningUser.getKey());

    UpdateContentParams params = new UpdateContentParams();
    params.contentKey = contentWithBinaryKey.toInt();
    params.contentData = newContentData;
    params.publishFrom = new Date();
    params.publishTo = null;
    params.createNewVersion = false;
    params.status = ContentStatus.STATUS_DRAFT;
    int contentVersionKey = internalClient.updateContent(params);

    fixture.flushAndClearHibernateSession();

    ContentVersionEntity actualVersion =
        contentVersionDao.findByKey(new ContentVersionKey(contentVersionKey));
    ContentEntity persistedContent = contentDao.findByKey(actualVersion.getContent().getKey());

    assertEquals(runningUser, persistedContent.getAssignee());
    assertEquals(runningUser, persistedContent.getAssigner());
    assertEquals("test assignment", persistedContent.getAssignmentDescription());
    assertEquals(
        new DateTime(2010, 6, 6, 10, 0, 0, 0).toDate(), persistedContent.getAssignmentDueDate());
  }
Ejemplo n.º 19
0
  public Document getContentBinary(GetContentBinaryParams params) throws ClientException {
    assertMinValue("contentKey", params.contentKey, 0);

    final UserEntity runAsUser = securityService.getImpersonatedPortalUser();

    final ContentKey contentKey = new ContentKey(params.contentKey);
    final ContentEntity content = contentDao.findByKey(contentKey);
    if (content == null || content.isDeleted()) {
      throw AttachmentNotFoundException.notFound(contentKey);
    }
    if (!new ContentAccessResolver(groupDao).hasReadContentAccess(runAsUser, content)) {
      throw AttachmentNotFoundException.noAccess(content.getKey());
    }

    if (!params.includeOfflineContent) {
      checkContentIsOnline(content);
    }

    ContentBinaryDataEntity contentBinaryData;
    if (params.label == null) {
      contentBinaryData = content.getMainVersion().getContentBinaryData("source");
      if (contentBinaryData == null) {
        contentBinaryData = content.getMainVersion().getOneAndOnlyContentBinaryData();
      }
    } else {
      contentBinaryData = content.getMainVersion().getContentBinaryData(params.label);
    }

    if (contentBinaryData == null) {
      throw AttachmentNotFoundException.notFound(contentKey);
    }

    return createBinaryDocument(createBinaryData(contentBinaryData));
  }
  private void createUpdateContentWithBinary() {
    UserEntity runningUser = fixture.findUserByName("testuser");

    // prepare: save a new content
    ContentEntity content = new ContentEntity();
    content.setPriority(0);
    content.setAvailableFrom(null);
    content.setAvailableTo(null);
    content.setCategory(fixture.findCategoryByName("MyCategory"));
    content.setLanguage(fixture.findLanguageByCode("en"));
    content.setName("testcontentwithbinary");

    ContentVersionEntity version = new ContentVersionEntity();
    version.setContent(content);
    version.setModifiedBy(runningUser);
    version.setStatus(com.enonic.cms.core.content.ContentStatus.DRAFT);
    version.setContent(content);
    CustomContentData contentData =
        new CustomContentData(
            fixture.findContentTypeByName("MyContentType").getContentTypeConfig());

    TextDataEntryConfig titleConfig =
        (TextDataEntryConfig)
            contentData.getContentTypeConfig().getForm().getInputConfig("myTitle");
    TextDataEntryConfig updateFieldConfig =
        (TextDataEntryConfig)
            contentData.getContentTypeConfig().getForm().getInputConfig("fieldToUpdate");
    BinaryDataEntryConfig binaryConfig =
        (BinaryDataEntryConfig)
            contentData.getContentTypeConfig().getForm().getInputConfig("myBinaryfile");

    contentData.add(new TextDataEntry(titleConfig, "testitle"));
    contentData.add(new TextDataEntry(updateFieldConfig, "foobar"));
    contentData.add(new BinaryDataEntry(binaryConfig, "%0"));

    version.setContentData(contentData);
    version.setTitle(contentData.getTitle());

    CreateContentCommand createContentCommand = new CreateContentCommand();
    createContentCommand.setCreator(runningUser);

    createContentCommand.populateCommandWithContentValues(content);
    createContentCommand.populateCommandWithContentVersionValues(version);

    List<BinaryDataAndBinary> binaryDatas = new ArrayList<BinaryDataAndBinary>();
    binaryDatas.add(factory.createBinaryDataAndBinary("dummyBinary", dummyBinary));

    createContentCommand.setBinaryDatas(binaryDatas);
    createContentCommand.setUseCommandsBinaryDataToAdd(true);

    contentWithBinaryKey = contentService.createContent(createContentCommand);

    fixture.flushAndClearHibernateSession();
  }
Ejemplo n.º 21
0
  private void doSetContentHome(
      final ContentEntity content,
      final MenuItemEntity section,
      final PageTemplateEntity pageTemplate) {
    final ContentHomeEntity existingHome = content.getContentHome(section.getSite().getKey());
    if (existingHome != null) {
      existingHome.setMenuItem(section);
      existingHome.setPageTemplate(pageTemplate);
    } else {
      final ContentHomeEntity newContentHome = new ContentHomeEntity();
      newContentHome.setKey(new ContentHomeKey(section.getSite().getKey(), content.getKey()));
      newContentHome.setSite(section.getSite());
      newContentHome.setContent(content);
      newContentHome.setMenuItem(section);
      newContentHome.setPageTemplate(pageTemplate);
      contentHomeDao.storeNew(newContentHome);

      content.addContentHome(newContentHome);
    }

    indexTransactionService.registerUpdate(content.getKey(), true);
  }
Ejemplo n.º 22
0
  private void doExecuteRemoveContentsFromSectionCommand(
      final RemoveContentsFromSectionCommand command) {
    Preconditions.checkNotNull(command.getSection(), "section cannot be null");
    Preconditions.checkNotNull(command.getRemover(), "remover cannot be null");
    Preconditions.checkNotNull(command.getContentsToRemove(), "content to remove cannot be null");

    final UserEntity remover = userDao.findByKey(command.getRemover());
    final MenuItemEntity section = doResolveSection(command.getSection());

    final MenuItemAccessResolver menuItemAccessResolver = new MenuItemAccessResolver(groupDao);
    for (ContentKey contentKey : command.getContentsToRemove()) {
      final SectionContentEntity sectionContentToRemove = section.getSectionContent(contentKey);
      Preconditions.checkNotNull(
          sectionContentToRemove,
          "content in section (" + section.getKey() + ") not found: " + contentKey);

      final boolean contentIsApprovedInSection = sectionContentToRemove.isApproved();
      if (contentIsApprovedInSection) {
        menuItemAccessResolver.checkAccessToUnapproveContentInSection(
            remover, section, "Cannot remove approved content from section.");
      } else {
        menuItemAccessResolver.checkAccessToRemoveUnapprovedContentFromSection(
            remover, section, "Cannot remove unapproved content from section.");
      }

      final ContentEntity content = contentDao.findByKey(contentKey);
      content.removeSectionContent(command.getSection());

      sectionContentDao.getHibernateTemplate().flush();

      sectionContentDao
          .getHibernateTemplate()
          .getSessionFactory()
          .evictCollection(MenuItemEntity.class.getName() + ".sectionContents", section.getKey());

      removeContentHomeIfThisSectionIs(content, section);
      indexTransactionService.registerUpdate(content.getKey(), true);
    }
  }
Ejemplo n.º 23
0
 public ContentEntity createContent(
     String contentName,
     String categoryName,
     String languageCode,
     String ownerQualifiedName,
     String priority,
     Date created) {
   ContentEntity content = new ContentEntity();
   content.setLanguage(fixture.findLanguageByCode(languageCode));
   content.setCategory(fixture.findCategoryByName(categoryName));
   content.setOwner(fixture.findUserByName(ownerQualifiedName));
   content.setPriority(Integer.valueOf(priority));
   content.setCreatedAt(created); // Not-null field in database.
   content.setDeleted(false); // Not-null field in database.
   content.setName(contentName);
   return content;
 }
Ejemplo n.º 24
0
  private void doExecuteSetContentHomeCommand(final SetContentHomeCommand command) {
    Preconditions.checkNotNull(command.getSetter(), "setter cannot be null");
    Preconditions.checkNotNull(command.getContent(), "content to set home for cannot be null");
    Preconditions.checkNotNull(command.getSection(), "section to set home to cannot be null");

    final UserEntity setter = doResolveUser(command.getSetter(), "setter");
    final ContentEntity content = contentDao.findByKey(command.getContent());
    final MenuItemEntity section = doResolveSection(command.getSection());

    final CategoryAccessResolver categoryAccessResolver = new CategoryAccessResolver(groupDao);
    if (!categoryAccessResolver.hasApproveContentAccess(setter, content.getCategory())) {
      throw new CategoryAccessException(
          "Cannot set content home",
          setter.getQualifiedName(),
          CategoryAccessType.APPROVE,
          content.getCategory().getKey());
    }

    PageTemplateEntity pageTemplate = null;
    if (command.getPageTemplate() != null) {
      pageTemplate = pageTemplateDao.findByKey(command.getPageTemplate().toInt());
    }
    doSetContentHome(content, section, pageTemplate);
  }
  private void createUpdateContent() {
    UserEntity runningUser = fixture.findUserByName("testuser");

    // prepare: save a new content
    ContentEntity content = new ContentEntity();
    content.setPriority(0);
    content.setAvailableFrom(new Date());
    content.setAvailableTo(null);
    content.setCategory(fixture.findCategoryByName("MyCategory"));
    content.setLanguage(fixture.findLanguageByCode("en"));
    content.setName("testcontent");

    ContentVersionEntity version = new ContentVersionEntity();
    version.setContent(content);
    version.setModifiedBy(runningUser);
    version.setStatus(com.enonic.cms.core.content.ContentStatus.APPROVED);
    version.setContent(content);
    CustomContentData contentData =
        new CustomContentData(
            fixture.findContentTypeByName("MyContentType").getContentTypeConfig());

    TextDataEntryConfig titleConfig =
        (TextDataEntryConfig)
            contentData.getContentTypeConfig().getForm().getInputConfig("myTitle");
    TextDataEntryConfig updateFieldConfig =
        (TextDataEntryConfig)
            contentData.getContentTypeConfig().getForm().getInputConfig("fieldToUpdate");
    contentData.add(new TextDataEntry(titleConfig, "testitle"));
    contentData.add(new TextDataEntry(updateFieldConfig, "foobar"));

    version.setContentData(contentData);
    version.setTitle(contentData.getTitle());

    CreateContentCommand createContentCommand = new CreateContentCommand();
    createContentCommand.setCreator(runningUser);
    createContentCommand.setAccessRightsStrategy(AccessRightsStrategy.USE_GIVEN);

    createContentCommand.populateCommandWithContentValues(content);
    createContentCommand.populateCommandWithContentVersionValues(version);

    updateContentKey = contentService.createContent(createContentCommand);

    fixture.flushAndClearHibernateSession();
  }
Ejemplo n.º 26
0
 private ContentTypeEntity resolveContentType(int contentKey) {
   ContentEntity persistedContent = contentDao.findByKey(new ContentKey(contentKey));
   return persistedContent.getCategory().getContentType();
 }
Ejemplo n.º 27
0
  private void doExecuteAddContentToSectionCommand(final AddContentToSectionCommand command) {
    Preconditions.checkNotNull(command, "a command is required");
    Preconditions.checkNotNull(
        command.getContributor(), "the command's contributor argument is required");
    Preconditions.checkNotNull(command.getContent(), "the command's content argument is required");
    Preconditions.checkNotNull(command.getSection(), "the command's section argument is required");
    if (!command.isApproveInSection()) {
      Preconditions.checkArgument(
          !command.isAddOnTop(), "no point in adding content to top when not approving");
    }

    final ContentEntity content = contentDao.findByKey(command.getContent());
    Preconditions.checkNotNull(content, "content does not exist: " + command.getContent());
    Preconditions.checkArgument(
        !content.isDeleted(), "content is deleted: " + command.getContent());

    final MenuItemEntity section = doResolveSection(command.getSection());
    if (!section.isOrderedSection()) {
      Preconditions.checkArgument(
          command.getOrderContentsInSectionCommand() == null,
          "section is not ordered, did not expect to get order specified in command");
    }

    final UserEntity contributor = doResolveUser(command.getContributor(), "contributor");
    final MenuItemAccessResolver menuItemAccessResolver = new MenuItemAccessResolver(groupDao);
    menuItemAccessResolver.checkAccessToAddContentToSection(
        contributor, section, "Cannot add content in section.");
    if (command.isApproveInSection()) {
      menuItemAccessResolver.checkAccessToApproveContentInSection(
          contributor, section, "Cannot approve content in section.");
    }

    if (section.isSection() && section.hasSectionContentTypeFilter()) {
      if (!section.supportsSectionContentType(content.getCategory().getContentType())) {
        throw new ContentTypeNotSupportedException(content.getCategory().getContentType(), section);
      }
    } else if (section.getType() == MenuItemType.PAGE
        && section.getPage().getTemplate().getContentTypes().size() > 0) {
      if (!section
          .getPage()
          .getTemplate()
          .supportsContentType(content.getCategory().getContentType())) {
        throw new ContentTypeNotSupportedException(content.getCategory().getContentType(), section);
      }
    }

    final SectionContentEntity sectionContent = new SectionContentEntity();
    sectionContent.setOrder(0);
    sectionContent.setContent(content);
    sectionContent.setMenuItem(section);
    sectionContent.setApproved(command.isApproveInSection());
    sectionContent.setTimestamp(timeService.getNowAsDateTime().toDate());
    if (command.isAddOnTop() && section.isOrderedSection()) {
      sectionContent.setOrder(resolveOrderValueForInsertOnTopOfApprovedContentInSection(section));
    }

    content.addSectionContent(sectionContent);
    sectionContentDao.getHibernateTemplate().flush();

    sectionContentDao
        .getHibernateTemplate()
        .getSessionFactory()
        .evictCollection(MenuItemEntity.class.getName() + ".sectionContents", section.getKey());
    if (!content.hasHome(section.getSite().getKey())) {
      doSetContentHome(content, section, null);
    }

    if (section.isOrderedSection()) {
      if (command.getOrderContentsInSectionCommand() != null) {
        // ensure section will have it's newly added content
        sectionContentDao.getHibernateTemplate().refresh(section);

        List<ContentKey> wantedOrder = command.getOrderContentsInSectionCommand().getWantedOrder();
        ContentsInSectionOrderer orderer =
            new ContentsInSectionOrderer(wantedOrder, section, ORDER_SPACE);
        orderer.order();
      }
    }

    indexTransactionService.registerUpdate(command.getContent(), true);
  }
 public static void enforceNoLazyInitialization(ContentEntity content) {
   content.setCategory(
       content.getCategory() != null ? new CategoryEntity(content.getCategory()) : null);
   content.setAssignee(
       content.getAssignee() != null ? new UserEntity(content.getAssignee()) : null);
   content.setAssigner(
       content.getAssigner() != null ? new UserEntity(content.getAssigner()) : null);
   content.setOwner(content.getOwner() != null ? new UserEntity(content.getOwner()) : null);
   content.setLanguage(
       content.getLanguage() != null ? new LanguageEntity(content.getLanguage()) : null);
   content.setDraftVersion(
       content.getDraftVersion() != null
           ? new ContentVersionEntity(content.getDraftVersion())
           : null);
   content.setMainVersion(
       content.getMainVersion() != null
           ? new ContentVersionEntity(content.getMainVersion())
           : null);
 }
  @Test
  public void testCreateContentWithBlockGroup() {
    fixture.createAndStoreUserAndUserGroup(
        "testuser", "testuser fullname", UserType.NORMAL, "testuserstore");

    fixture.save(
        factory.createContentHandler(
            "Custom content", ContentHandlerName.CUSTOM.getHandlerClassShortName()));

    // setup content type
    ContentTypeConfigBuilder ctyconf = new ContentTypeConfigBuilder("Skole", "tittel");
    ctyconf.startBlock("Skole");
    ctyconf.addInput("tittel", "text", "contentdata/tittel", "Tittel", true);
    ctyconf.endBlock();
    ctyconf.startBlock("Elever", "contentdata/elever");
    ctyconf.addInput("elev-navn", "text", "navn", "Navn");
    ctyconf.addInput("elev-karakter", "text", "karakter", "Karakter");
    ctyconf.endBlock();
    ctyconf.startBlock("Laerere", "contentdata/laerere");
    ctyconf.addInput("laerer-navn", "text", "navn", "Navn");
    ctyconf.addInput("laerer-karakter", "text", "karakter", "Karakter");
    ctyconf.endBlock();
    Document configAsXmlBytes = XMLDocumentFactory.create(ctyconf.toString()).getAsJDOMDocument();
    fixture.save(
        factory.createContentType(
            "Skole", ContentHandlerName.CUSTOM.getHandlerClassShortName(), configAsXmlBytes));

    fixture.save(factory.createUnit("MyUnit", "en"));
    fixture.save(factory.createCategory("Skole", "Skole", "MyUnit", "testuser", "testuser"));
    fixture.save(factory.createCategoryAccessForUser("Skole", "testuser", "read,create,approve"));

    UserEntity runningUser = fixture.findUserByName("testuser");
    PortalSecurityHolder.setImpersonatedUser(runningUser.getKey());

    CreateContentParams content = new CreateContentParams();
    content.categoryKey = fixture.findCategoryByName("Skole").getKey().toInt();
    content.publishFrom = new Date();
    content.status = ContentStatus.STATUS_APPROVED;

    ContentDataInput contentData = new ContentDataInput("Skole");
    contentData.add(new TextInput("tittel", "St. Olav Videregaende skole"));

    GroupInput groupInputElev1 = contentData.addGroup("Elever");
    groupInputElev1.add(new TextInput("elev-navn", "Vegar Jansen"));
    groupInputElev1.add(new TextInput("elev-karakter", "S"));

    GroupInput groupInputElev2 = contentData.addGroup("Elever");
    groupInputElev2.add(new TextInput("elev-navn", "Thomas Sigdestad"));
    groupInputElev2.add(new TextInput("elev-karakter", "M"));

    GroupInput groupInputLaerer1 = contentData.addGroup("Laerere");
    groupInputLaerer1.add(new TextInput("laerer-navn", "Mutt Hansen"));
    groupInputLaerer1.add(new TextInput("laerer-karakter", "LG"));

    GroupInput groupInputLaerer2 = contentData.addGroup("Laerere");
    groupInputLaerer2.add(new TextInput("laerer-navn", "Striks Jansen"));
    groupInputLaerer2.add(new TextInput("laerer-karakter", "M"));

    content.contentData = contentData;
    ContentKey contentKey = new ContentKey(internalClient.createContent(content));

    ContentEntity createdContent = fixture.findContentByKey(contentKey);
    ContentVersionEntity createdVersion = createdContent.getMainVersion();
    CustomContentData createdContentData = (CustomContentData) createdVersion.getContentData();
    BlockGroupDataEntries elever = createdContentData.getBlockGroupDataEntries("Elever");

    GroupDataEntry elev1 = elever.getGroupDataEntry(1);
    assertEquals("Vegar Jansen", ((TextDataEntry) elev1.getEntry("elev-navn")).getValue());
    assertEquals("S", ((TextDataEntry) elev1.getEntry("elev-karakter")).getValue());

    GroupDataEntry elev2 = elever.getGroupDataEntry(2);
    assertEquals("Thomas Sigdestad", ((TextDataEntry) elev2.getEntry("elev-navn")).getValue());
    assertEquals("M", ((TextDataEntry) elev2.getEntry("elev-karakter")).getValue());

    BlockGroupDataEntries laerere = createdContentData.getBlockGroupDataEntries("Laerere");

    GroupDataEntry laerer1 = laerere.getGroupDataEntry(1);
    assertEquals("Mutt Hansen", ((TextDataEntry) laerer1.getEntry("laerer-navn")).getValue());
    assertEquals("LG", ((TextDataEntry) laerer1.getEntry("laerer-karakter")).getValue());

    GroupDataEntry laerer2 = laerere.getGroupDataEntry(2);
    assertEquals("Striks Jansen", ((TextDataEntry) laerer2.getEntry("laerer-navn")).getValue());
    assertEquals("M", ((TextDataEntry) laerer2.getEntry("laerer-karakter")).getValue());
  }
  @Test
  public void testUpdateCurrentVersion() {
    ContentKey relatedContentKey1 = storeSimpleContent("rel1");
    ContentKey relatedContentKey2 = storeSimpleContent("rel2");
    ContentKey relatedContentKey3 = storeSimpleContent("rel3");
    ContentKey relatedContentKey4 = storeSimpleContent("rel4");
    ContentKey relatedContentKey5 = storeSimpleContent("rel5");

    ContentEntity content = factory.createContent("MyCategory", "en", "testuser", "0", new Date());
    ContentVersionEntity version = factory.createContentVersion("0", "testuser");

    ContentTypeConfig contentTypeConfig =
        ContentTypeConfigParser.parse(ContentHandlerName.CUSTOM, configEl);
    CustomContentData contentData = new CustomContentData(contentTypeConfig);
    TextDataEntryConfig titleConfig =
        new TextDataEntryConfig("myTitle", true, "Tittel", "contentdata/mytitle");
    contentData.add(new TextDataEntry(titleConfig, "test title"));

    RelatedContentDataEntryConfig multipleRelatedContentsConfig =
        (RelatedContentDataEntryConfig)
            contentTypeConfig.getInputConfig("myMultipleRelatedContent");

    contentData.add(
        new RelatedContentsDataEntry(multipleRelatedContentsConfig)
            .add(new RelatedContentDataEntry(multipleRelatedContentsConfig, relatedContentKey1))
            .add(new RelatedContentDataEntry(multipleRelatedContentsConfig, relatedContentKey2)));

    RelatedContentDataEntryConfig soleRelatedConfig =
        (RelatedContentDataEntryConfig) contentTypeConfig.getInputConfig("mySoleRelatedContent");

    contentData.add(new RelatedContentDataEntry(soleRelatedConfig, relatedContentKey3));

    version.setContentData(contentData);

    UserEntity runningUser = fixture.findUserByName("testuser");

    CreateContentCommand createContentCommand = new CreateContentCommand();
    createContentCommand.setCreator(runningUser);

    createContentCommand.populateCommandWithContentValues(content);
    createContentCommand.populateCommandWithContentVersionValues(version);

    createContentCommand.setBinaryDatas(new ArrayList<BinaryDataAndBinary>());
    createContentCommand.setUseCommandsBinaryDataToAdd(true);

    ContentKey contentKey = contentService.createContent(createContentCommand);

    hibernateTemplate.flush();
    hibernateTemplate.clear();

    ContentEntity persistedContent = contentDao.findByKey(contentKey);
    assertNotNull(persistedContent);

    ContentVersionEntity persistedVersion = persistedContent.getMainVersion();
    assertNotNull(persistedVersion);

    assertEquals(3, persistedVersion.getRelatedChildren(true).size());

    ContentEntity changedContent =
        factory.createContent("MyCategory", "en", "testuser", "0", new Date());
    changedContent.setKey(contentKey);
    ContentVersionEntity changedVersion = factory.createContentVersion("0", "testuser");
    changedVersion.setKey(persistedVersion.getKey());

    CustomContentData changedCD = new CustomContentData(contentTypeConfig);

    TextDataEntryConfig changedTitleConfig =
        new TextDataEntryConfig("myTitle", true, "Tittel", "contentdata/mytitle");
    changedCD.add(new TextDataEntry(changedTitleConfig, "changed title"));

    changedCD.add(
        new RelatedContentsDataEntry(multipleRelatedContentsConfig)
            .add(new RelatedContentDataEntry(multipleRelatedContentsConfig, relatedContentKey3))
            .add(new RelatedContentDataEntry(multipleRelatedContentsConfig, relatedContentKey5)));

    changedCD.add(new RelatedContentDataEntry(soleRelatedConfig, relatedContentKey4));

    changedVersion.setContentData(changedCD);

    UpdateContentCommand updateContentCommand =
        UpdateContentCommand.updateExistingVersion2(persistedVersion.getKey());
    updateContentCommand.setModifier(runningUser);
    updateContentCommand.setUpdateAsMainVersion(false);

    updateContentCommand.populateContentValuesFromContent(persistedContent);
    updateContentCommand.populateContentVersionValuesFromContentVersion(changedVersion);

    contentService.updateContent(updateContentCommand);

    hibernateTemplate.flush();
    hibernateTemplate.clear();

    ContentEntity contentAfterUpdate = contentDao.findByKey(contentKey);
    ContentVersionEntity versionAfterUpdate =
        contentVersionDao.findByKey(persistedVersion.getKey());

    Document contentDataXmlAfterUpdate = versionAfterUpdate.getContentDataAsJDomDocument();

    AssertTool.assertXPathEquals(
        "/contentdata/mysolerelatedcontent/@key",
        contentDataXmlAfterUpdate,
        relatedContentKey4.toString());
    AssertTool.assertXPathEquals(
        "/contentdata/myrelatedcontents/content[1]/@key",
        contentDataXmlAfterUpdate,
        relatedContentKey3.toString());
    AssertTool.assertXPathEquals(
        "/contentdata/myrelatedcontents/content[2]/@key",
        contentDataXmlAfterUpdate,
        relatedContentKey5.toString());

    assertEquals(3, versionAfterUpdate.getRelatedChildren(true).size());
  }