Esempio n. 1
0
  private void doExecuteApproveContentInSectionCommand(
      final ApproveContentInSectionCommand command) {
    Preconditions.checkNotNull(command.getSection(), "section cannot be null");
    Preconditions.checkNotNull(command.getApprover(), "approver cannot be null");
    Preconditions.checkNotNull(command.getContentToApprove(), "content to approve cannot be null");

    final MenuItemEntity section = doResolveSection(command.getSection());
    final UserEntity approver = doResolveUser(command.getApprover(), "approver");

    new MenuItemAccessResolver(groupDao)
        .checkAccessToApproveContentInSection(
            approver, section, "Cannot approve content in section.");

    final SectionContentEntity sectionContent =
        section.getSectionContent(command.getContentToApprove());
    boolean changed = false;

    if (!sectionContent.isApproved()) {
      sectionContent.setApproved(true);
      changed = true;
    }

    final int newOrder = resolveOrderValueForInsertOnTopOfApprovedContentInSection(section);
    if (sectionContent.getOrder() != newOrder) {
      sectionContent.setOrder(newOrder);
      changed = true;
    }

    if (changed) {
      sectionContent.setTimestamp(timeService.getNowAsDateTime().toDate());
      indexTransactionService.registerUpdate(command.getContentToApprove(), true);
    }
  }
Esempio n. 2
0
  private int resolveOrderValueForInsertOnTopOfApprovedContentInSection(
      final MenuItemEntity section) {
    if (section.getSectionContents().size() == 0) {
      return 0;
    }

    int lowestOrderValue = Integer.MAX_VALUE;
    for (SectionContentEntity sectionContent : section.getSectionContents()) {
      if (sectionContent.isApproved() && sectionContent.getOrder() < lowestOrderValue) {
        lowestOrderValue = sectionContent.getOrder();
      }
    }

    return lowestOrderValue - ORDER_SPACE;
  }
Esempio n. 3
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());
  }
Esempio n. 4
0
  private void doExecuteApproveContentsInSectionCommand(
      final ApproveContentsInSectionCommand command) {
    Preconditions.checkNotNull(command.getSection(), "section cannot be null");
    Preconditions.checkNotNull(command.getApprover(), "approver cannot be null");
    Preconditions.checkNotNull(
        command.getContentsToApprove().size(), "no given content to approve in section");

    final MenuItemEntity section = doResolveSection(command.getSection());
    final UserEntity approver = doResolveUser(command.getApprover(), "approver");

    new MenuItemAccessResolver(groupDao)
        .checkAccessToApproveContentInSection(
            approver, section, "Cannot approve content in section.");

    final Set<SectionContentEntity> changedSectionContents = new HashSet<SectionContentEntity>();
    for (ContentKey contentKey : command.getContentsToApprove()) {
      final SectionContentEntity sectionContent = section.getSectionContent(contentKey);
      if (!sectionContent.isApproved()) {
        sectionContent.setApproved(true);
        changedSectionContents.add(sectionContent);
      }
    }

    // handle re-order command
    if (command.getOrderContentsInSectionCommand() != null) {
      if (section.isOrderedSection()) {
        changedSectionContents.addAll(
            new ContentsInSectionOrderer(
                    command.getOrderContentsInSectionCommand().getWantedOrder(),
                    section,
                    ORDER_SPACE)
                .order());
      }
    }

    // update timestamp of only those who have changed
    for (SectionContentEntity changedSectionContent : changedSectionContents) {
      changedSectionContent.setTimestamp(timeService.getNowAsDateTime().toDate());
    }

    for (ContentKey contentKey : command.getContentsToApprove()) {
      indexTransactionService.registerUpdate(contentKey, true);
    }
  }
Esempio n. 5
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);
    }
  }
Esempio n. 6
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);
  }
Esempio n. 7
0
  private void doExecuteUnapproveContentsInSectionCommand(
      final UnapproveContentsInSectionCommand command) {
    Preconditions.checkNotNull(command.getSection(), "section cannot be null");
    Preconditions.checkNotNull(command.getUnapprover(), "unapprover cannot be null");
    Preconditions.checkNotNull(
        command.getContentToUnapprove().size(), "no given content to unapprove in section");

    final UserEntity updater = doResolveUser(command.getUnapprover(), "unapprover");
    final MenuItemEntity section = doResolveSection(command.getSection());

    new MenuItemAccessResolver(groupDao)
        .checkAccessToUnapproveContentInSection(
            updater, section, "Cannot unapprove section content.");

    for (ContentKey contentKey : command.getContentToUnapprove()) {
      final SectionContentEntity sectionContent = section.getSectionContent(contentKey);
      if (sectionContent == null) {
        continue;
      }
      doUnapproveContentInSection(sectionContent);
      indexTransactionService.registerUpdate(contentKey, true);
    }
  }
Esempio n. 8
0
 private MenuItemEntity doResolveSection(final MenuItemKey sectionKey) {
   final MenuItemEntity section = menuItemDao.findByKey(sectionKey);
   Preconditions.checkNotNull(section, "section does not exist: " + sectionKey);
   Preconditions.checkArgument(section.isSection(), "menu item is not a section:" + sectionKey);
   return section;
 }
Esempio n. 9
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);
  }