/**
  * search book by name with limit of result(using SQL)
  *
  * @param name The name of book
  * @return List<Book>
  */
 public List<Book> searchBookByNameLimitSQL(String name) {
   /* replace "" sign and - sign */
   name = name.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY);
   /* create query string */
   StringBuffer sb = new StringBuffer("Select * from " + BookNodeTypes.EXO_BOOK);
   SessionProvider sProvider = SessionProvider.createSystemProvider();
   try {
     /* create QueryManager from session */
     QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager();
     /* create QueryImpl object */
     QueryImpl query = (QueryImpl) queryManager.createQuery(sb.toString(), QueryImpl.SQL);
     /* set offset(which first record will be get) */
     query.setOffset(2);
     /* set limit(how many record will be get after offset) */
     query.setLimit(3);
     /* execute query and return result to QueryResult */
     QueryResult result = query.execute();
     /* transfer data to NodeIterator */
     NodeIterator nodes = result.getNodes();
     List<Book> books = new ArrayList<Book>();
     while (nodes.hasNext()) {
       Node node = nodes.nextNode();
       books.add(createBookByNode(node));
     }
     return books;
   } catch (RepositoryException re) {
     log.error("Can not find book", re);
     return null;
   } finally {
     sProvider.close();
   }
 }
 /**
  * get user by name with xpath
  *
  * @param username
  * @return
  */
 public User getUserByNameXPath(String username) {
   username.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY);
   username = username.trim();
   SessionProvider sProvider = SessionProvider.createSystemProvider();
   StringBuffer queryString =
       new StringBuffer(
           "//element(*, "
               + BookNodeTypes.EXO_USER
               + ")[(jcr:like(@"
               + BookNodeTypes.EXO_USER_NAME
               + ",'%"
               + username
               + "%'"
               + ") and @"
               + BookNodeTypes.EXO_USER_ADDRESS
               + "='Hanoi'"
               + ")]");
   try {
     QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager();
     Query query = queryManager.createQuery(queryString.toString(), Query.XPATH);
     QueryResult result = query.execute();
     NodeIterator nodes = result.getNodes();
     if (nodes.getSize() > 0) {
       Node node = nodes.nextNode();
       PropertyReader reader = new PropertyReader(node);
       return createUserByNode(node);
     }
     return null;
   } catch (RepositoryException re) {
     log.error("Can not get user by name(XPath)", re);
     return null;
   } finally {
     sProvider.close();
   }
 }
 /**
  * search book by name with like condition(using SQL)
  *
  * @param name The name of book
  * @return List<Book>
  */
 public List<Book> searchBookByNameLikeSQL(String name) {
   /* replace "" sign and - sign */
   name.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY);
   /* create query string */
   StringBuffer sb = new StringBuffer("Select * from " + BookNodeTypes.EXO_BOOK);
   sb.append(" where " + BookNodeTypes.EXO_BOOK_NAME + " like '%" + name + "%'");
   SessionProvider sProvider = SessionProvider.createSystemProvider();
   try {
     /* create QueryManager from session */
     QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager();
     /* create Query object */
     Query query = queryManager.createQuery(sb.toString(), Query.SQL);
     /* execute query and return result to QueryResult */
     QueryResult result = query.execute();
     /* transfer data to NodeIterator */
     NodeIterator nodes = result.getNodes();
     List<Book> books = new ArrayList<Book>();
     while (nodes.hasNext()) {
       Node node = nodes.nextNode();
       books.add(createBookByNode(node));
     }
     return books;
   } catch (RepositoryException re) {
     log.error("Can not find book", re);
     return null;
   } finally {
     sProvider.close();
   }
 }
 /**
  * Gets the spell suggestion.
  *
  * @param checkingWord the checking word
  * @param manageableRepository the manageable repository
  * @return the spell suggestion
  * @throws Exception the exception
  */
 private String getSpellSuggestion(String checkingWord, ManageableRepository manageableRepository)
     throws Exception {
   // Retrieve spell suggestion in special way to avoid access denied exception
   String suggestion = null;
   Session session = null;
   try {
     session =
         manageableRepository.getSystemSession(
             manageableRepository.getConfiguration().getDefaultWorkspaceName());
     QueryManager queryManager = session.getWorkspace().getQueryManager();
     Query query =
         queryManager.createQuery(
             "SELECT rep:spellcheck() FROM nt:base WHERE jcr:path like '/' AND SPELLCHECK('"
                 + checkingWord
                 + "')",
             Query.SQL);
     RowIterator rows = query.execute().getRows();
     Value value = rows.nextRow().getValue("rep:spellcheck()");
     if (value != null) {
       suggestion = value.getString();
     }
   } catch (Exception e) {
     if (LOG.isWarnEnabled()) {
       LOG.warn(e.getMessage());
     }
   } finally {
     if (session != null) session.logout();
   }
   return suggestion;
 }
  /** TODO: Not fully implemented SEE: DirectSearchModule.getKeywordMapLive() */
  public static synchronized void refreshUserDocKeywords(Session session)
      throws RepositoryException {
    log.info("refreshUserDocKeywords({})", session);
    String statement = "/jcr:root/" + Repository.ROOT + "/element(*,okm:document)";

    try {
      Workspace workspace = session.getWorkspace();
      QueryManager queryManager = workspace.getQueryManager();
      Query query = queryManager.createQuery(statement, Query.XPATH);
      javax.jcr.query.QueryResult qResult = query.execute();
      Map<String, Set<String>> userDocKeywords = new HashMap<String, Set<String>>();

      for (NodeIterator nit = qResult.getNodes(); nit.hasNext(); ) {
        Node docNode = nit.nextNode();
        Value[] keywords = docNode.getProperty(Property.KEYWORDS).getValues();
        Set<String> keywordSet = new HashSet<String>();

        for (int i = 0; i < keywords.length; i++) {
          keywordSet.add(keywords[i].getString());
        }

        userDocKeywords.put(docNode.getUUID(), keywordSet);
      }

      // userDocumentKeywordsMgr.put(session.getUserID(), userDocKeywords);
    } catch (javax.jcr.RepositoryException e) {
      log.error(e.getMessage(), e);
      throw new RepositoryException(e.getMessage(), e);
    }

    log.info("refreshUserDocKeywords: void");
  }
  /**
   * {@inheritDoc}
   *
   * @see
   *     org.sakaiproject.nakamura.api.search.SearchResultProcessor#getSearchResultSet(org.apache.sling.api.SlingHttpServletRequest,
   *     javax.jcr.query.Query)
   */
  public SearchResultSet getSearchResultSet(SlingHttpServletRequest request, Query query)
      throws SearchException {
    try {
      // Perform the query
      QueryResult qr = query.execute();
      RowIterator iterator = qr.getRows();

      // Do another query to get the files.
      Session session = request.getResourceResolver().adaptTo(Session.class);
      QueryManager qm = session.getWorkspace().getQueryManager();
      String statement =
          "//element(*, sakai:site)//*[@sling:resourceType='sakai/link']/jcr:deref(@jcr:reference, '*')[jcr:contains(.,'*u*')]";
      Query q = qm.createQuery(statement, Query.XPATH);
      QueryResult filesQueryResult = q.execute();
      RowIterator filesIterator = filesQueryResult.getRows();

      MergedRowIterator mergedIterator = new MergedRowIterator(iterator, filesIterator);

      long siteHits = SearchUtil.getHits(qr);
      long filesHits = SearchUtil.getHits(filesQueryResult);
      long totalHits = siteHits + filesHits;

      return new AbstractSearchResultSet(mergedIterator, totalHits);

    } catch (RepositoryException e) {
      throw new SearchException(500, "Unable to do files query.");
    }
  }
  @Override
  public List<ModelResource> search(String queryExpression) {
    if (queryExpression == null || queryExpression.isEmpty()) {
      queryExpression = "*";
    }

    try {
      List<ModelResource> modelResources = new ArrayList<>();
      QueryManager queryManager = session.getWorkspace().getQueryManager();
      Query query =
          queryManager.createQuery(
              queryExpression, org.modeshape.jcr.api.query.Query.FULL_TEXT_SEARCH);
      logger.debug("Searching repository with expression " + query.getStatement());
      QueryResult result = query.execute();
      RowIterator rowIterator = result.getRows();

      while (rowIterator.hasNext()) {
        Row row = rowIterator.nextRow();
        Node currentNode = row.getNode();
        if (currentNode.hasProperty("vorto:type") && !isMappingNode(currentNode)) {
          modelResources.add(createModelResource(currentNode));
        }
      }

      return modelResources;
    } catch (RepositoryException e) {
      throw new RuntimeException("Could not create query manager", e);
    }
  }
  @Override
  public ResultSet query(String text, String lang) {
    Session session = (Session) this.getThreadLocalRequest().getSession().getAttribute("session");
    ResultSet rs = new ResultSet();
    try {
      QueryManager qm = session.getWorkspace().getQueryManager();
      Query q = qm.createQuery(text, lang);

      QueryResult qr = q.execute();

      rs.setColumnNames(qr.getColumnNames());
      ArrayList<String[]> rows = new ArrayList();
      RowIterator it = qr.getRows();
      while (it.hasNext()) {
        Row row = it.nextRow();
        String[] list = new String[qr.getColumnNames().length];

        for (int i = 0; i < qr.getColumnNames().length; i++) {
          Value v = row.getValue(qr.getColumnNames()[i]);
          list[i] = v != null ? v.getString() : "null";
        }

        rows.add(list);
      }

      rs.setRows(rows);
    } catch (RepositoryException e) {
      log.log(Level.SEVERE, "Error executing query: " + text, e);
    }
    return rs;
  }
 public Mail retrieve(String key) throws MessagingException {
   try {
     Session session = login();
     try {
       String name = toSafeName(key);
       QueryManager manager = session.getWorkspace().getQueryManager();
       @SuppressWarnings("deprecation")
       Query query =
           manager.createQuery(
               "/jcr:root/" + MAIL_PATH + "//element(" + name + ",james:mail)", Query.XPATH);
       NodeIterator iterator = query.execute().getNodes();
       if (iterator.hasNext()) {
         return getMail(iterator.nextNode());
       } else {
         return null;
       }
     } finally {
       session.logout();
     }
   } catch (IOException e) {
     throw new MessagingException("Unable to retrieve message: " + key, e);
   } catch (RepositoryException e) {
     throw new MessagingException("Unable to retrieve message: " + key, e);
   }
 }
Beispiel #10
0
  protected void performCheck(String statement, String expected) throws RepositoryException {
    QueryManager qm = superuser.getWorkspace().getQueryManager();
    Query query =
        qm.createQuery(
            "/jcr:root[rep:spellcheck('" + statement + "')]/(rep:spellcheck())", Query.XPATH);
    RowIterator rows = query.execute().getRows();
    assertEquals("no results returned", 1, rows.getSize());
    Row r = rows.nextRow();
    Value v = r.getValue("rep:spellcheck()");
    if (statement.equals(expected)) {
      assertNull("must not return a suggestion", v);
    } else {
      assertNotNull("no suggestion returned", v);
      assertEquals("wrong suggestion returned", expected, v.getString());
    }

    query =
        qm.createQuery(
            "select rep:spellcheck() from nt:base where "
                + "jcr:path = '/' and spellcheck('"
                + statement
                + "')",
            Query.SQL);
    rows = query.execute().getRows();
    assertEquals("no results returned", 1, rows.getSize());
    r = rows.nextRow();
    v = r.getValue("rep:spellcheck()");
    if (statement.equals(expected)) {
      assertNull("must not return a suggestion", v);
    } else {
      assertNotNull("no suggestion returned", v);
      assertEquals("wrong suggestion returned", expected, v.getString());
    }
  }
  @Test
  public void testCopiedFacetSelectIsIndexed() throws RepositoryException {
    String[] content = {
      "/test", "nt:unstructured",
      "jcr:mixinTypes", "mix:referenceable",
      "/test/target", "nt:unstructured",
      "jcr:mixinTypes", "mix:referenceable",
      "/test/target/dummy", "nt:unstructured",
      "/test/nav", "hippo:facetselect",
      "hippo:docbase", "/test/target",
      "hippo:facets", null,
      "hippo:modes", null,
      "hippo:values", null,
      "/test/nav2", "hippo:facetselect",
      "hippo:docbase", "/test/target",
      "hippo:facets", null,
      "hippo:modes", null,
      "hippo:values", null
    };
    build(content, session);
    session.save();
    session.refresh(false);

    recurse(session.getNode("/test"));
    JcrUtils.copy(session.getNode("/test/nav"), "mirror", session.getNode("/test"));
    session.save();
    session.refresh(false);

    QueryManager queryManager = session.getWorkspace().getQueryManager();
    Query query = queryManager.createQuery("//element(mirror,hippo:facetselect)", Query.XPATH);
    QueryResult result = query.execute();
    assertTrue(result.getNodes().hasNext());
    assertTrue(result.getNodes().hasNext());
    assertTrue(result.getNodes().hasNext());
  }
 @Override
 protected void internalRemove(String key) throws MessagingException {
   try {
     Session session = login();
     try {
       String name = ISO9075.encode(Text.escapeIllegalJcrChars(key));
       QueryManager manager = session.getWorkspace().getQueryManager();
       @SuppressWarnings("deprecation")
       Query query =
           manager.createQuery(
               "/jcr:root/" + MAIL_PATH + "//element(" + name + ",james:mail)", Query.XPATH);
       NodeIterator nodes = query.execute().getNodes();
       if (nodes.hasNext()) {
         while (nodes.hasNext()) {
           nodes.nextNode().remove();
         }
         session.save();
         logger.info("Mail " + key + " removed from repository");
       } else {
         logger.warn("Mail " + key + " not found");
       }
     } finally {
       session.logout();
     }
   } catch (RepositoryException e) {
     throw new MessagingException("Unable to remove message: " + key, e);
   }
 }
  @Override
  protected void internalStore(Mail mail) throws MessagingException, IOException {
    try {
      Session session = login();
      try {
        String name = Text.escapeIllegalJcrChars(mail.getName());
        final String xpath = "/jcr:root/" + MAIL_PATH + "//element(" + name + ",james:mail)";

        QueryManager manager = session.getWorkspace().getQueryManager();
        @SuppressWarnings("deprecation")
        Query query = manager.createQuery(xpath, Query.XPATH);
        NodeIterator iterator = query.execute().getNodes();

        if (iterator.hasNext()) {
          while (iterator.hasNext()) {
            setMail(iterator.nextNode(), mail);
          }
        } else {
          Node parent = session.getRootNode().getNode(MAIL_PATH);
          Node node = parent.addNode(name, "james:mail");
          Node resource = node.addNode("jcr:content", "nt:resource");
          resource.setProperty("jcr:mimeType", "message/rfc822");
          setMail(node, mail);
        }
        session.save();
        logger.info("Mail " + mail.getName() + " stored in repository");
      } finally {
        session.logout();
      }
    } catch (IOException e) {
      throw new MessagingException("Unable to store message: " + mail.getName(), e);
    } catch (RepositoryException e) {
      throw new MessagingException("Unable to store message: " + mail.getName(), e);
    }
  }
 /**
  * get all book in workspace
  *
  * @return List<Book>
  */
 public List<Book> getAllBook() {
   /* create query string */
   StringBuffer sb = new StringBuffer("Select * from " + BookNodeTypes.EXO_BOOK);
   SessionProvider sProvider = SessionProvider.createSystemProvider();
   try {
     /* create QueryManager from session */
     QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager();
     /* create Query object */
     Query query = queryManager.createQuery(sb.toString(), Query.SQL);
     /* execute query and return result to QueryResult */
     QueryResult result = query.execute();
     /* transfer data to NodeIterator */
     NodeIterator nodes = result.getNodes();
     List<Book> books = new ArrayList<Book>();
     while (nodes.hasNext()) {
       Node node = nodes.nextNode();
       books.add(createBookByNode(node));
     }
     return books;
   } catch (RepositoryException re) {
     log.error("Can not find book", re);
     return null;
   } finally {
     sProvider.close();
   }
 }
 /**
  * get user by name in range with sql statement
  *
  * @param username
  */
 public User getUserByNameLimtSQL(String username) {
   username.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY);
   username = username.trim();
   SessionProvider sProvider = SessionProvider.createSystemProvider();
   StringBuffer queryString = new StringBuffer("Select * from " + BookNodeTypes.EXO_USER);
   queryString.append(" where " + BookNodeTypes.EXO_USER_NAME + " = '" + username + "'");
   try {
     QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager();
     QueryImpl query = (QueryImpl) queryManager.createQuery(queryString.toString(), Query.SQL);
     query.setOffset(0L);
     query.setLimit(3L);
     QueryResult result = query.execute();
     NodeIterator nodes = result.getNodes();
     if (nodes.getSize() > 0) {
       Node node = nodes.nextNode();
       return createUserByNode(node);
     }
     return null;
   } catch (RepositoryException re) {
     log.error("Can not get user by name", re);
     return null;
   } finally {
     sProvider.close();
   }
 }
Beispiel #16
0
  /**
   * @see
   *     org.apache.jackrabbit.core.security.authorization.AccessControlProvider#getEffectivePolicies(java.util.Set,
   *     CompiledPermissions)
   */
  public AccessControlPolicy[] getEffectivePolicies(
      Set<Principal> principals, CompiledPermissions permissions) throws RepositoryException {
    String propName = ISO9075.encode(session.getJCRName(P_PRINCIPAL_NAME));

    StringBuilder stmt = new StringBuilder("/jcr:root");
    stmt.append("//element(*,");
    stmt.append(session.getJCRName(NT_REP_ACE));
    stmt.append(")[");
    int i = 0;
    for (Principal principal : principals) {
      if (i > 0) {
        stmt.append(" or ");
      }
      stmt.append("@");
      stmt.append(propName);
      stmt.append("='");
      stmt.append(principal.getName().replaceAll("'", "''"));
      stmt.append("'");
      i++;
    }
    stmt.append("]");

    QueryResult result;
    try {
      QueryManager qm = session.getWorkspace().getQueryManager();
      Query q = qm.createQuery(stmt.toString(), Query.XPATH);
      result = q.execute();
    } catch (RepositoryException e) {
      log.error("Unexpected error while searching effective policies.", e.getMessage());
      throw new UnsupportedOperationException(
          "Retrieve effective policies for set of principals not supported.", e);
    }

    Set<AccessControlPolicy> acls = new LinkedHashSet<AccessControlPolicy>();
    for (NodeIterator it = result.getNodes(); it.hasNext(); ) {
      NodeImpl aclNode = (NodeImpl) it.nextNode().getParent();
      Name aclName = aclNode.getQName();
      NodeImpl accessControlledNode = (NodeImpl) aclNode.getParent();

      if (N_POLICY.equals(aclName) && isAccessControlled(accessControlledNode)) {
        if (permissions.canRead(aclNode.getPrimaryPath(), aclNode.getNodeId())) {
          acls.add(getACL(accessControlledNode, N_POLICY, accessControlledNode.getPath()));
        } else {
          throw new AccessDeniedException(
              "Access denied at " + Text.getRelativeParent(aclNode.getPath(), 1));
        }
      } else if (N_REPO_POLICY.equals(aclName) && isRepoAccessControlled(accessControlledNode)) {
        if (permissions.canRead(aclNode.getPrimaryPath(), aclNode.getNodeId())) {
          acls.add(getACL(accessControlledNode, N_REPO_POLICY, null));
        } else {
          throw new AccessDeniedException(
              "Access denied at " + Text.getRelativeParent(aclNode.getPath(), 1));
        }
      } // else: not a regular policy node -> ignore.
    }

    return acls.toArray(new AccessControlPolicy[acls.size()]);
  }
  private List<Node> getLastEditedNode(String noOfItem, String showGadgetWs) throws Exception {
    if (showGadgetWs != null && showGadgetWs.length() > 0) {
      show_gadget = Boolean.parseBoolean(showGadgetWs);
    }
    ArrayList<Node> lstNode = new ArrayList<Node>();
    StringBuffer bf = new StringBuffer(1024);
    List<String> lstNodeType = templateService.getDocumentTemplates();
    if (lstNodeType != null) {
      for (String nodeType : lstNodeType) {
        bf.append("(")
            .append(JCR_PRIMARYTYPE)
            .append("=")
            .append("'")
            .append(nodeType)
            .append("'")
            .append(")")
            .append(" OR ");
      }
    }

    if (bf.length() == 1) return null;
    bf.delete(bf.lastIndexOf("OR") - 1, bf.length());
    if (noOfItem == null || noOfItem.trim().length() == 0) noOfItem = String.valueOf(NO_PER_PAGE);
    String queryStatement = StringUtils.replace(QUERY_STATEMENT, "$0", NT_BASE);
    queryStatement = StringUtils.replace(queryStatement, "$1", bf.toString());
    queryStatement = StringUtils.replace(queryStatement, "$2", DATE_MODIFIED);
    ManageableRepository manageableRepository = repositoryService.getCurrentRepository();
    try {
      String[] workspaces = manageableRepository.getWorkspaceNames();
      List<String> lstWorkspace = new ArrayList<String>();
      // Arrays.asList() return fixed size list;
      lstWorkspace.addAll(Arrays.asList(workspaces));
      if (!show_gadget && lstWorkspace.contains(GADGET)) {
        lstWorkspace.remove(GADGET);
      }
      SessionProvider provider = WCMCoreUtils.createAnonimProvider();
      QueryImpl query = null;
      Session session = null;
      QueryResult queryResult = null;
      QueryManager queryManager = null;
      for (String workspace : lstWorkspace) {
        session = provider.getSession(workspace, manageableRepository);
        queryManager = session.getWorkspace().getQueryManager();
        query = (QueryImpl) queryManager.createQuery(queryStatement, Query.SQL);
        query.setLimit(Integer.parseInt(noOfItem));
        query.setOffset(0);
        queryResult = query.execute();
        puttoList(lstNode, queryResult.getNodes());
        session.logout();
      }
    } catch (RepositoryException e) {
      if (LOG.isErrorEnabled()) {
        LOG.error("Exception when execute SQL " + queryStatement, e);
      }
    }
    return lstNode;
  }
 @Override
 public String[] supportedQueryLanguages() {
   Session session = (Session) this.getThreadLocalRequest().getSession().getAttribute("session");
   try {
     QueryManager qm = session.getWorkspace().getQueryManager();
     return qm.getSupportedQueryLanguages();
   } catch (RepositoryException e) {
     log.log(Level.SEVERE, "Error getting supported query languages", e);
   }
   return null;
 }
Beispiel #19
0
  public void postSave(Membership m, boolean isNew) throws Exception {

    String username = m.getUserName();
    String groupId = m.getGroupId();
    cservice_.addUserContactInAddressBook(username, groupId);
    DataStorage storage_ = new JCRDataStorage(nodeHierarchyCreator_, reposervice_);
    SessionProvider systemSession = SessionProvider.createSystemProvider();
    try {
      String usersPath = nodeHierarchyCreator_.getJcrPath(DataStorage.USERS_PATH);
      Contact contact = cservice_.getPublicContact(username);
      QueryManager qm = getSession(systemSession).getWorkspace().getQueryManager();
      Map<String, String> groups = new LinkedHashMap<String, String>();
      for (String group : contact.getAddressBookIds()) groups.put(group, group);
      groups.put(groupId, groupId);
      contact.setAddressBookIds(groups.keySet().toArray(new String[] {}));
      cservice_.saveContact(username, contact, false);
      StringBuffer queryString =
          new StringBuffer(
                  "/jcr:root"
                      + usersPath
                      + "//element(*,exo:contactGroup)[@exo:viewPermissionGroups='")
              .append(groupId + "']");
      Query query = qm.createQuery(queryString.toString(), Query.XPATH);
      QueryResult result = query.execute();
      NodeIterator nodes = result.getNodes();
      List<String> to = Arrays.asList(new String[] {username});
      while (nodes.hasNext()) {
        Node address = nodes.nextNode();
        String from = address.getProperty("exo:sharedUserId").getString();
        String addressBookId = address.getProperty("exo:id").getString();
        storage_.shareAddressBook(from, addressBookId, to);
      }
      queryString =
          new StringBuffer(
                  "/jcr:root" + usersPath + "//element(*,exo:contact)[@exo:viewPermissionGroups='")
              .append(groupId + "']");
      query = qm.createQuery(queryString.toString(), Query.XPATH);
      result = query.execute();
      nodes = result.getNodes();
      while (nodes.hasNext()) {
        Node contactNode = nodes.nextNode();
        String split = "/";
        String temp = contactNode.getPath().split(usersPath)[1];
        String userId = temp.split(split)[1];
        String[] addressBookIds = new String[] {contactNode.getProperty("exo:id").getString()};
        storage_.shareContact(userId, addressBookIds, to);
      }
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      systemSession.close();
    }
  }
 /**
  * This method will re-observer all nodes that have been ever observed with all repositories.
  *
  * @throws Exception
  */
 private void reInitObserver() throws Exception {
   RepositoryEntry repo = repoService_.getCurrentRepository().getConfiguration();
   ManageableRepository repository = repoService_.getCurrentRepository();
   String[] workspaceNames = repository.getWorkspaceNames();
   for (String workspace : workspaceNames) {
     Session session = repository.getSystemSession(workspace);
     QueryManager queryManager = null;
     try {
       queryManager = session.getWorkspace().getQueryManager();
     } catch (Exception e) {
       if (LOG.isErrorEnabled()) {
         LOG.error("Unexpected error", e);
       }
     }
     if (queryManager == null) {
       session.logout();
       continue;
     }
     try {
       Query query = queryManager.createQuery(WATCHABLE_MIXIN_QUERY, Query.XPATH);
       QueryResult queryResult = query.execute();
       for (NodeIterator iter = queryResult.getNodes(); iter.hasNext(); ) {
         Node observedNode = iter.nextNode();
         EmailNotifyListener emailNotifyListener = new EmailNotifyListener(observedNode);
         ObservationManager manager = session.getWorkspace().getObservationManager();
         List<String> list = getDocumentNodeTypes(observedNode);
         String[] observedNodeTypeNames = list.toArray(new String[list.size()]);
         manager.addEventListener(
             emailNotifyListener,
             Event.PROPERTY_CHANGED,
             observedNode.getPath(),
             true,
             null,
             observedNodeTypeNames,
             false);
       }
       session.logout();
     } catch (Exception e) {
       if (LOG.isWarnEnabled()) {
         LOG.warn(
             "==>>> Cannot init observer for node: "
                 + e.getLocalizedMessage()
                 + " in '"
                 + repo.getName()
                 + "' repository");
       }
       if (LOG.isErrorEnabled()) {
         LOG.error("Unexpected error", e);
       }
     }
   }
 }
Beispiel #21
0
  /** Get keyword map */
  private Map<String, Integer> getKeywordMapLive(String token, List<String> filter)
      throws RepositoryException, DatabaseException {
    log.debug("getKeywordMapLive({}, {})", token, filter);
    String statement =
        "/jcr:root//*[@jcr:primaryType eq 'okm:document' or @jcr:primaryType eq 'okm:mail' or @jcr:primaryType eq 'okm:folder']";
    HashMap<String, Integer> cloud = new HashMap<String, Integer>();
    Session session = null;

    try {
      if (token == null) {
        session = JCRUtils.getSession();
      } else {
        session = JcrSessionManager.getInstance().get(token);
      }

      Workspace workspace = session.getWorkspace();
      QueryManager queryManager = workspace.getQueryManager();
      Query query = queryManager.createQuery(statement, Query.XPATH);
      javax.jcr.query.QueryResult qResult = query.execute();

      for (NodeIterator nit = qResult.getNodes(); nit.hasNext(); ) {
        Node doc = nit.nextNode();
        Value[] keywordsValue = doc.getProperty(com.openkm.bean.Property.KEYWORDS).getValues();
        ArrayList<String> keywordCollection = new ArrayList<String>();

        for (int i = 0; i < keywordsValue.length; i++) {
          keywordCollection.add(keywordsValue[i].getString());
        }

        if (filter != null && keywordCollection.containsAll(filter)) {
          for (Iterator<String> it = keywordCollection.iterator(); it.hasNext(); ) {
            String keyword = it.next();

            if (!filter.contains(keyword)) {
              Integer occurs = cloud.get(keyword) != null ? cloud.get(keyword) : 0;
              cloud.put(keyword, occurs + 1);
            }
          }
        }
      }
    } catch (javax.jcr.RepositoryException e) {
      log.error(e.getMessage(), e);
      throw new RepositoryException(e.getMessage(), e);
    } finally {
      if (token == null) JCRUtils.logout(session);
    }

    log.debug("getKeywordMapLive: {}", cloud);
    return cloud;
  }
Beispiel #22
0
 /**
  * @purpose Check if a query is valid
  * @param workspace
  * @param strQuery
  * @param SQLLanguage
  * @return true as valid query, false as Invalid
  * @author vinh_nguyen from ECMS
  */
 public static boolean checkQuery(String workspace, String strQuery, String SQLLanguage) {
   try {
     Session session =
         WCMCoreUtils.getUserSessionProvider()
             .getSession(
                 workspace,
                 WCMCoreUtils.getService(RepositoryService.class).getCurrentRepository());
     QueryManager qm = session.getWorkspace().getQueryManager();
     Query query = qm.createQuery(strQuery, SQLLanguage);
     query.execute();
   } catch (Exception e) {
     return false;
   }
   return true;
 }
 /**
  * check user exist by name
  *
  * @param username
  * @param sProvider
  * @return
  */
 private boolean isExistUserName(String username, SessionProvider sProvider) {
   username.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY);
   StringBuffer queryString = new StringBuffer("Select * from " + BookNodeTypes.EXO_USER);
   queryString.append(" where " + BookNodeTypes.EXO_USER_NAME + " = '" + username + "'");
   try {
     QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager();
     Query query = queryManager.createQuery(queryString.toString(), Query.SQL);
     QueryResult result = query.execute();
     NodeIterator nodes = result.getNodes();
     return nodes.hasNext();
   } catch (RepositoryException re) {
     log.error("Failed to check exist user name", re);
     return false;
   }
 }
Beispiel #24
0
  private static boolean hasCheckOuts(Node node) throws RepositoryException {
    // Build xpath query of the form
    // '//path/to/node//*[jcr:isCheckedOut='true']'
    String xPath = "/*[jcr:isCheckedOut='true']";
    String path = node.getPath();
    if ("/".equals(path)) {
      path = "";
    }
    xPath = '/' + Util.escape(path) + xPath;

    // Execute query
    QueryManager queryManager = node.getSession().getWorkspace().getQueryManager();
    Query query = queryManager.createQuery(xPath, Query.XPATH);
    QueryResult queryResult = query.execute();
    return queryResult.getNodes().hasNext();
  }
Beispiel #25
0
 private Query createSearchPageQuery(QueryCriteria queryCriteria, QueryManager queryManager)
     throws Exception {
   SQLQueryBuilder queryBuilder = new SQLQueryBuilder();
   List<String> mopPages =
       this.searchPageByTitle(queryCriteria.getSiteName(), queryCriteria.getKeyword());
   List<QueryProperty> queryProps = new ArrayList<QueryCriteria.QueryProperty>();
   for (String page : mopPages) {
     QueryProperty prop = queryCriteria.new QueryProperty();
     prop.setName("mop:page");
     prop.setValue(page);
     prop.setComparisonType(COMPARISON_TYPE.EQUAL);
     queryProps.add(prop);
   }
   QueryProperty prop = queryCriteria.new QueryProperty();
   prop.setName("exo:name");
   prop.setValue("mop:" + queryCriteria.getKeyword().toLowerCase());
   queryProps.add(prop);
   queryCriteria.setQueryMetadatas(queryProps.toArray(new QueryProperty[queryProps.size()]));
   mapQueryTypes(queryCriteria, queryBuilder);
   if (queryCriteria.isFulltextSearch()) {
     mapQueryPath(queryCriteria, queryBuilder);
     mapFulltextQueryTearm(queryCriteria, queryBuilder, LOGICAL.OR);
   } else {
     searchByNodeName(queryCriteria, queryBuilder);
   }
   mapCategoriesCondition(queryCriteria, queryBuilder);
   mapDatetimeRangeSelected(queryCriteria, queryBuilder);
   mapMetadataProperties(queryCriteria, queryBuilder, LOGICAL.OR);
   orderBy(queryCriteria, queryBuilder);
   String queryStatement = queryBuilder.createQueryStatement();
   Query query = queryManager.createQuery(queryStatement, Query.SQL);
   return query;
 }
  private NodeIterator getDailyNodes(Node pluginDayNode, String userId) throws Exception {
    final boolean stats =
        NotificationContextFactory.getInstance().getStatistics().isStatisticsEnabled();
    long startTime = 0;
    if (stats) startTime = System.currentTimeMillis();
    //
    userId = userId.replace("'", "''");

    StringBuilder strQuery =
        new StringBuilder("SELECT * FROM ").append(NTF_MESSAGE).append(" WHERE ");
    strQuery
        .append(" (jcr:path LIKE '")
        .append(pluginDayNode.getPath())
        .append("/%'")
        .append(" AND NOT jcr:path LIKE '")
        .append(pluginDayNode.getPath())
        .append("/%/%')");
    strQuery.append(" AND (").append(NTF_SEND_TO_DAILY).append("='").append(userId).append("'");
    strQuery
        .append(" OR ")
        .append(NTF_SEND_TO_DAILY)
        .append("='")
        .append(NotificationInfo.FOR_ALL_USER)
        .append("') AND ")
        .append(NTF_FROM)
        .append("<>'")
        .append(userId)
        .append("'");
    strQuery
        .append(" order by ")
        .append(NTF_ORDER)
        .append(ASCENDING)
        .append(", exo:dateCreated")
        .append(DESCENDING);

    QueryManager qm = pluginDayNode.getSession().getWorkspace().getQueryManager();
    Query query = qm.createQuery(strQuery.toString(), Query.SQL);
    NodeIterator it = query.execute().getNodes();

    if (stats) {
      NotificationContextFactory.getInstance()
          .getStatisticsCollector()
          .queryExecuted(strQuery.toString(), it.getSize(), System.currentTimeMillis() - startTime);
    }
    return it;
  }
 /**
  * Configure.
  *
  * @param session the session
  * @param folderPath the folder path
  * @param portalName the portal name
  * @throws Exception the exception
  */
 private void configure(Node targetNode, String portalName) throws Exception {
   String statement =
       "select * from nt:resource where jcr:path like '"
           + targetNode.getPath()
           + "/%' order by jcr:dateModified ASC";
   QueryManager queryManager = targetNode.getSession().getWorkspace().getQueryManager();
   Query query = queryManager.createQuery(statement, Query.SQL);
   NodeIterator iterator = query.execute().getNodes();
   for (; iterator.hasNext(); ) {
     Node ntResource = iterator.nextNode();
     String mimeType = ntResource.getProperty("jcr:mimeType").getString();
     if (!mimeType.startsWith("text")) continue;
     String jcrData = ntResource.getProperty("jcr:data").getString();
     if (!jcrData.contains("{portalName}")) continue;
     String realData = StringUtils.replace(jcrData, "{portalName}", portalName);
     ntResource.setProperty("jcr:data", realData);
   }
 }
Beispiel #28
0
 private NodeIterator setQuery(boolean isQuery, String value) throws Exception {
   NodeIterator iter;
   Session session = sessionManager.getCurrentSession();
   if (session == null || !session.isLive()) {
     sessionManager.openSession();
     session = sessionManager.getCurrentSession();
   }
   if (isQuery) {
     QueryManager qm = session.getWorkspace().getQueryManager();
     Query query = qm.createQuery(value, Query.XPATH);
     QueryResult result = query.execute();
     iter = result.getNodes();
   } else {
     Node node = (Node) session.getItem(value);
     iter = node.getNodes();
   }
   return iter;
 }
 public Set<Node> getReferrers(Node document) throws RepositoryException {
   Set<Node> referrers =
       new TreeSet<Node>(
           new Comparator<Node>() {
             public int compare(Node node1, Node node2) {
               try {
                 return node1.getIdentifier().compareTo(node2.getIdentifier());
               } catch (UnsupportedRepositoryOperationException ex) {
                 // cannot happen
                 return 0;
               } catch (RepositoryException ex) {
                 return 0;
               }
             }
           });
   if (!document.isNodeType(HippoNodeType.NT_DOCUMENT)) {
     return null;
   }
   document = ((HippoNode) document).getCanonicalNode();
   Node handle = document.getParent();
   if (!handle.isNodeType(HippoNodeType.NT_HANDLE)
       || !handle.isNodeType(HippoNodeType.NT_HARDHANDLE)) {
     return null;
   }
   String uuid = handle.getIdentifier();
   QueryManager queryManager = document.getSession().getWorkspace().getQueryManager();
   String statement = "//*[@hippo:docbase='" + uuid + "']";
   Query query = queryManager.createQuery(statement, Query.XPATH);
   QueryResult result = query.execute();
   for (NodeIterator iter = result.getNodes(); iter.hasNext(); ) {
     Node node = iter.nextNode();
     while (node != null && !node.isNodeType(HippoNodeType.NT_DOCUMENT)) {
       node = (node.getDepth() > 0 ? node.getParent() : null);
     }
     if (node != null) {
       if (node.isNodeType("hippostd:publishable")
           && node.hasProperty("hippostd:state")
           && node.getProperty("hippostd:state").getString().equals("published")) {
         referrers.add(node);
       }
     }
   }
   return referrers;
 }
 /**
  * Set-up the configuration values used for the test. Per default retrieves a session, configures
  * testRoot, and nodetype and checks if the query language for the current language is available.
  * <br>
  */
 protected void setUp() throws Exception {
   super.setUp();
   jcrScore = superuser.getNamespacePrefix(NS_JCR_URI) + ":score";
   jcrPath = superuser.getNamespacePrefix(NS_JCR_URI) + ":path";
   jcrRoot = superuser.getNamespacePrefix(NS_JCR_URI) + ":root";
   jcrContains = superuser.getNamespacePrefix(NS_JCR_URI) + ":contains";
   jcrDeref = superuser.getNamespacePrefix(NS_JCR_URI) + ":deref";
   xpathRoot = "/" + jcrRoot + ISO9075.encodePath(testRoot);
   qm = superuser.getWorkspace().getQueryManager();
   qf = qm.getQOMFactory();
   vf = superuser.getValueFactory();
 }