/**
   * This will prepare <code>jcrPath</code> to have a storage node for the unique id. Call this
   * method on initialization time when no concurrent access will hapen.
   */
  public void initializePath(String jcrPath) throws IDException {
    jcrPath = removeJCRPrefix(jcrPath);

    Session session;
    try {
      session = login();

      Item item = session.getItem(jcrPath);
      if (!item.isNode()) {
        throw new IDException("Path '" + jcrPath + "' is a property (should be a node)");
      } else {
        // check if it has a subnode containing a unique id
        Node parent = (Node) item;
        if (!parent.hasNode(ID_NODE)) {
          // create the id node if it does not exist yet
          parent.addNode(ID_NODE, ID_NODE_TYPE);
          session.save();
        }
      }
      session.logout();
    } catch (LoginException e) {
      throw new IDException("Login to repository failed.", e);
    } catch (PathNotFoundException e) {
      throw new IDException("Repository path does not exist: " + jcrPath, e);
    } catch (RepositoryException e) {
      throw new IDException("Cannot lookup repository path: " + jcrPath, e);
    }
  }
示例#2
0
  /**
   * Clears {@link #next} and tries to fetch the next Node instance. When this method returns {@link
   * #next} refers to the next available node instance in this iterator. If {@link #next} is null
   * when this method returns, then there are no more valid element in this iterator.
   */
  private void fetchNext() {
    // reset
    next = null;
    nextScore = 0;

    while (next == null && rows.hasNext()) {
      try {
        QueryResultRow row = (QueryResultRow) rows.next();
        nextId = row.getNodeId(null);
        Item tmp = itemMgr.getItem(hierarchyMgr.getNodeEntry(nextId));

        if (tmp.isNode()) {
          next = (Node) tmp;
          nextScore = row.getScore(null);
        } else {
          log.warn("Item with Id is not a Node: " + nextId);
          // try next
          invalid++;
          pos++;
        }
      } catch (Exception e) {
        log.warn("Exception retrieving Node with Id: " + nextId);
        // try next
        invalid++;
        pos++;
      }
    }
    pos++;
  }
 /**
  * @param item
  * @return
  */
 private boolean isFilteredNamespace(Item item) {
   try {
     return isFilteredNamespace(item.getName(), item.getSession());
   } catch (RepositoryException e) {
     log.warn(e.getMessage());
   }
   return false;
 }
  @Override
  public void removeMessageAfterSent() throws Exception {
    final boolean stats =
        NotificationContextFactory.getInstance().getStatistics().isStatisticsEnabled();
    boolean created = NotificationSessionManager.createSystemProvider();
    SessionProvider sProvider = NotificationSessionManager.getSessionProvider();

    try {
      Node notificationHome = getNotificationHomeNode(sProvider, workspace);
      Session session = notificationHome.getSession();
      // remove all
      Set<String> listPaths = removeByCallBack.get(REMOVE_ALL);
      removeByCallBack.remove(REMOVE_ALL);
      if (listPaths != null && listPaths.size() > 0) {
        for (String nodePath : listPaths) {
          try {
            session.getItem(nodePath).remove();
            // record entity delete here
            if (stats) {
              NotificationContextFactory.getInstance()
                  .getStatisticsCollector()
                  .deleteEntity(NTF_MESSAGE);
            }

            LOG.debug("Remove NotificationMessage " + nodePath);
          } catch (Exception e) {
            LOG.warn(
                "Failed to remove node of NotificationMessage " + nodePath + "\n" + e.getMessage());
            LOG.debug("Remove NotificationMessage " + nodePath, e);
          }
        }
        session.save();
      }

      listPaths = removeByCallBack.get(REMOVE_DAILY);
      if (listPaths != null && listPaths.size() > 0) {
        for (String nodePath : listPaths) {
          try {
            Item item = session.getItem(nodePath);
            if (item.isNode()) {
              Node node = (Node) item;
              node.setProperty(NTF_SEND_TO_DAILY, new String[] {""});
            }
            LOG.debug("Remove SendToDaily property " + nodePath);
          } catch (Exception e) {
            LOG.warn(
                "Failed to remove SendToDaily property of " + nodePath + "\n" + e.getMessage());
            LOG.debug("Remove SendToDaily property " + nodePath, e);
          }
        }
        session.save();
      }
    } catch (Exception e) {
      LOG.warn("Failed to remove message after sent email notification", e);
    } finally {
      NotificationSessionManager.closeSessionProvider(created);
    }
  }
 /**
  * Generates a document view export using a {@link
  * org.apache.jackrabbit.commons.xml.DocumentViewExporter} instance.
  *
  * @param path of the node to be exported
  * @param handler handler for the SAX events of the export
  * @param skipBinary whether binary values should be skipped
  * @param noRecurse whether to export just the identified node
  * @throws PathNotFoundException if a node at the given path does not exist
  * @throws SAXException if the SAX event handler failed
  * @throws RepositoryException if another error occurs
  */
 public void exportDocumentView(
     String path, ContentHandler handler, boolean skipBinary, boolean noRecurse)
     throws PathNotFoundException, SAXException, RepositoryException {
   DocumentViewExporter exporter = new DocumentViewExporter(this, handler, skipBinary, noRecurse);
   Item item = getItem(path);
   if (item.isNode()) {
     exporter.export((JCRNodeWrapper) item);
   } else {
     throw new PathNotFoundException("XML export is not defined for properties: " + path);
   }
 }
  /**
   * Generates a system view export using a {@link
   * org.apache.jackrabbit.commons.xml.SystemViewExporter} instance.
   *
   * @param path of the node to be exported
   * @param handler handler for the SAX events of the export
   * @param skipBinary whether binary values should be skipped
   * @param noRecurse whether to export just the identified node
   * @throws PathNotFoundException if a node at the given path does not exist
   * @throws SAXException if the SAX event handler failed
   * @throws RepositoryException if another error occurs
   */
  public void exportSystemView(
      String path, ContentHandler handler, boolean skipBinary, boolean noRecurse)
      throws PathNotFoundException, SAXException, RepositoryException {

    // todo implement our own system view .. ?
    SystemViewExporter exporter = new SystemViewExporter(this, handler, !noRecurse, !skipBinary);
    Item item = getItem(path);
    if (item.isNode()) {
      exporter.export((JCRNodeWrapper) item);
    } else {
      throw new PathNotFoundException("XML export is not defined for properties: " + path);
    }
  }
 /**
  * Gets the subnode for <code>jcrPath</code> that contains the current value of the highest id.
  * This is "thread-safe".
  */
 private Node getLockableIDNode(Session session, String jcrPath) throws IDException {
   try {
     Item item = session.getItem(jcrPath);
     if (!item.isNode()) {
       throw new IDException("Path '" + jcrPath + "' is a property (should be a node)");
     } else {
       return ((Node) item).getNode(ID_NODE);
     }
   } catch (PathNotFoundException e) {
     throw new IDException("Repository path does not exist: " + jcrPath, e);
   } catch (RepositoryException e) {
     throw new IDException("Cannot lookup repository path: " + jcrPath, e);
   }
 }
 @Override
 public void removeModel(ModelId modelId) {
   try {
     ModelResource modelResource = getById(modelId);
     if (!modelResource.getReferencedBy().isEmpty()) {
       throw new ModelReferentialIntegrityException(
           "Cannot remove model because it is referenced by other model(s)",
           modelResource.getReferencedBy());
     }
     Item item = session.getItem(modelId.getFullPath());
     item.remove();
     session.save();
   } catch (RepositoryException e) {
     throw new FatalModelRepositoryException("Problem occured removing the model", e);
   }
 }
 public Node getEditNode(String nodeType) throws Exception {
   Node uploadNode = getUploadedNode();
   try {
     Item primaryItem = uploadNode.getPrimaryItem();
     if (primaryItem == null || !primaryItem.isNode()) return uploadNode;
     if (primaryItem != null && primaryItem.isNode()) {
       Node primaryNode = (Node) primaryItem;
       if (primaryNode.isNodeType(nodeType)) return primaryNode;
     }
   } catch (Exception e) {
     if (LOG.isWarnEnabled()) {
       LOG.warn(e.getMessage());
     }
   }
   return uploadNode;
 }
示例#10
0
 /**
  * Get an ItemLocation object by an item
  *
  * @param item the item
  * @return a ItemLocation object
  */
 public static final ItemLocation getItemLocationByItem(final Item item) {
   Session session = null;
   try {
     session = item.getSession();
     String repository =
         ((ManageableRepository) session.getRepository()).getConfiguration().getName();
     String workspace = session.getWorkspace().getName();
     String path = item.getPath();
     String uuid = null;
     try {
       if (item instanceof Node) uuid = ((Node) item).getUUID();
     } catch (Exception e) {
       // Do nothing}
     }
     boolean isSystemSession = IdentityConstants.SYSTEM.equals(session.getUserID());
     return new ItemLocation(repository, workspace, path, uuid, isSystemSession);
   } catch (Exception e) {
     return null;
   }
 }
  @Override
  public boolean hasPrivileges(final String absPath, final Privilege[] privileges)
      throws PathNotFoundException, RepositoryException {

    if (supportPrivileges) {
      // if the node is created in the same session, return true
      for (Item item : session.getNewItems()) {
        if (item.getPath().equals(absPath)) {
          return true;
        }
      }

      // check privilege names
      return hasPrivilegesLegacy(absPath, privileges);
    } else {
      // check ACLs
      Set<String> privs = new HashSet<>();
      for (Privilege privilege : privileges) {
        privs.add(privilege.getName());
      }
      String mountPoint = session.getRepository().getStoreProvider().getMountPoint();
      Session securitySession =
          JCRSessionFactory.getInstance()
              .getCurrentSystemSession(session.getWorkspace().getName(), null, null);
      PathWrapper pathWrapper =
          new ExternalPathWrapperImpl(
              StringUtils.equals(absPath, "/") ? mountPoint : mountPoint + absPath,
              securitySession);
      return AccessManagerUtils.isGranted(
          pathWrapper,
          privs,
          securitySession,
          jahiaPrincipal,
          workspaceName,
          false,
          pathPermissionCache,
          compiledAcls,
          registry);
    }
  }
 /**
  * @param item
  * @return
  */
 private boolean isFilteredNodeType(Item item) {
   // shortcut
   if (nodetypeFilter.isEmpty()) {
     return false;
   }
   try {
     String ntName;
     if (item.isNode()) {
       //                ntName = ((Node) item).getDefinition().getDeclaringNodeType().getName();
       ntName = ((Node) item).getPrimaryNodeType().getName();
     } else {
       ntName = ((Property) item).getDefinition().getDeclaringNodeType().getName();
     }
     return nodetypeFilter.contains(ntName);
   } catch (RepositoryException e) {
     log.warn(e.getMessage());
   }
   // nodetype info could not be retrieved
   return false;
 }
示例#13
0
  public JCRItemWrapper getItem(String path, final boolean checkVersion)
      throws PathNotFoundException, RepositoryException {
    if (sessionCacheByPath.containsKey(path)) {
      return sessionCacheByPath.get(path);
    }
    if (path.contains(DEREF_SEPARATOR)) {
      JCRNodeWrapper parent =
          (JCRNodeWrapper)
              getItem(StringUtils.substringBeforeLast(path, DEREF_SEPARATOR), checkVersion);
      return dereference(parent, StringUtils.substringAfterLast(path, DEREF_SEPARATOR));
    }
    Map<String, JCRStoreProvider> dynamicMountPoints = sessionFactory.getDynamicMountPoints();
    for (Map.Entry<String, JCRStoreProvider> mp : dynamicMountPoints.entrySet()) {
      if (path.startsWith(mp.getKey() + "/")) {
        String localPath = path.substring(mp.getKey().length());
        JCRStoreProvider provider = mp.getValue();
        Item item = getProviderSession(provider).getItem(provider.getRelativeRoot() + localPath);
        if (item.isNode()) {
          return provider.getNodeWrapper((Node) item, localPath, null, this);
        } else {
          return provider.getPropertyWrapper((Property) item, this);
        }
      }
    }
    Map<String, JCRStoreProvider> mountPoints = sessionFactory.getMountPoints();
    for (Map.Entry<String, JCRStoreProvider> mp : mountPoints.entrySet()) {
      String key = mp.getKey();
      if (key.equals("/") || path.equals(key) || path.startsWith(key + "/")) {
        String localPath = path;
        if (!key.equals("/")) {
          localPath = localPath.substring(key.length());
        }
        JCRStoreProvider provider = mp.getValue();
        if (localPath.equals("")) {
          localPath = "/";
        }
        //                Item item = getProviderSession(provider).getItem(localPath);
        Session session = getProviderSession(provider);
        if (session instanceof JahiaSessionImpl
            && getUser() != null
            && sessionFactory.getCurrentAliasedUser() != null
            && sessionFactory.getCurrentAliasedUser().equals(getUser())) {
          ((JahiaSessionImpl) session).toggleThisSessionAsAliased();
        }
        Item item = session.getItem(provider.getRelativeRoot() + localPath);
        if (item.isNode()) {
          final Node node = (Node) item;
          JCRNodeWrapper wrapper = provider.getNodeWrapper(node, localPath, null, this);
          if (getUser() != null
              && sessionFactory.getCurrentAliasedUser() != null
              && !sessionFactory.getCurrentAliasedUser().equals(getUser())) {
            final JCRNodeWrapper finalWrapper = wrapper;
            JCRTemplate.getInstance()
                .doExecuteWithUserSession(
                    sessionFactory.getCurrentAliasedUser().getUsername(),
                    getWorkspace().getName(),
                    getLocale(),
                    new JCRCallback<Object>() {
                      public Object doInJCR(JCRSessionWrapper session) throws RepositoryException {
                        return session.getNodeByUUID(finalWrapper.getIdentifier(), checkVersion);
                      }
                    });
          }
          if (checkVersion
              && (versionDate != null || versionLabel != null)
              && node.isNodeType("mix:versionable")) {
            wrapper = getFrozenVersionAsRegular(node, provider);
          }
          sessionCacheByPath.put(path, wrapper);
          sessionCacheByIdentifier.put(wrapper.getIdentifier(), wrapper);

          return wrapper;
        } else {
          return provider.getPropertyWrapper((Property) item, this);
        }
      }
    }
    throw new PathNotFoundException(path);
  }