/**
* {@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.");
}
}
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 shouldNotIndexNotQueryableConnector() throws Exception {
federationManager.createProjection(
"/testRoot", "mock-source-non-queryable", MockConnector.DOC2_LOCATION, "federated2");
Workspace workspace = session.getWorkspace();
workspace.reindex();
QueryManager queryManager = workspace.getQueryManager();
Query query =
queryManager.createQuery(
"select * FROM [nt:base] WHERE [jcr:path] LIKE '/testRoot/federated2'", Query.JCR_SQL2);
assertEquals(0, query.execute().getNodes().getSize());
query =
queryManager.createQuery(
"select * FROM [nt:base] WHERE [jcr:path] LIKE '/testRoot/federated2/federated3'",
Query.JCR_SQL2);
assertEquals(0, query.execute().getNodes().getSize());
Node externalNode = session.getNode("/testRoot/federated2/federated3");
externalNode.setProperty("test", "a value");
session.save();
query =
queryManager.createQuery(
"select * FROM [nt:base] as a WHERE a.test='a value'", Query.JCR_SQL2);
assertEquals(0, query.execute().getNodes().getSize());
}
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();
}
}
/**
* Executes a the given query string (based on the language information) against a JCR repository,
* returning a rest model based result.
*
* @param request a non-null {@link HttpServletRequest}
* @param repositoryName a non-null, URL encoded {@link String} representing the name of a
* repository
* @param workspaceName a non-null, URL encoded {@link String} representing the name of a
* workspace
* @param language a non-null String which should be a valid query language, as recognized by the
* {@link javax.jcr.query.QueryManager}
* @param statement a non-null String which should be a valid query string in the above language.
* @param offset a numeric value which indicates the index in the result set from where results
* should be returned.
* @param limit a numeric value indicating the maximum number of rows to return.
* @param uriInfo a non-null {@link UriInfo} object which is provided by RestEASY, allowing extra
* request parameters to be retrieved.
* @return a {@link RestQueryHandler} instance
* @throws RepositoryException if any operation fails at the JCR level
*/
public RestQueryResult executeQuery(
HttpServletRequest request,
String repositoryName,
String workspaceName,
String language,
String statement,
long offset,
long limit,
UriInfo uriInfo)
throws RepositoryException {
assert repositoryName != null;
assert workspaceName != null;
assert language != null;
assert statement != null;
Session session = getSession(request, repositoryName, workspaceName);
Query query = createQuery(language, statement, session);
bindExtraVariables(uriInfo, session.getValueFactory(), query);
QueryResult result = query.execute();
RestQueryResult restQueryResult = new RestQueryResult();
String[] columnNames = result.getColumnNames();
setColumns(result, restQueryResult, columnNames);
String baseUrl = RestHelper.repositoryUrl(request);
setRows(offset, limit, session, result, restQueryResult, columnNames, baseUrl);
return restQueryResult;
}
@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());
}
/** Execute query */
private ResultSet executeQuery(Session session, Query query, int offset, int limit)
throws RepositoryException {
log.debug("executeQuery({}, {}, {}, {})", new Object[] {session, query, offset, limit});
ResultSet rs = new ResultSet();
try {
ArrayList<QueryResult> al = new ArrayList<QueryResult>();
// http://n4.nabble.com/Query-performance-for-large-query-results-td531360.html
((QueryImpl) query).setLimit(limit);
((QueryImpl) query).setOffset(offset);
QueryResultImpl result = (QueryResultImpl) query.execute();
RowIterator rit = result.getRows();
rs.setTotal(result.getTotalSize());
while (rit.hasNext()) {
Row row = rit.nextRow();
QueryResult qr = queryRowResultDigester(session, row);
al.add(qr);
}
rs.setResults(al);
} catch (javax.jcr.RepositoryException e) {
log.error(e.getMessage(), e);
throw new RepositoryException(e.getMessage(), e);
}
log.debug("executeQuery: {}", rs);
return rs;
}
@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);
}
}
/**
* 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();
}
}
@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);
}
}
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);
}
}
/**
* 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();
}
}
/**
* 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();
}
}
/**
* get user by book name
*
* @param bookName
* @return
*/
public User getUserByBookQuery(String bookName) {
bookName.replaceAll("\"", "\\\"").replaceAll("-", StringUtils.EMPTY);
bookName = bookName.trim();
SessionProvider sProvider = SessionProvider.createSystemProvider();
StringBuffer queryString = new StringBuffer("Select * from " + BookNodeTypes.EXO_USER);
queryString.append(
" where /"
+ BookNodeTypes.EXO_BOOK
+ "/"
+ BookNodeTypes.EXO_BOOK_NAME
+ "="
+ bookName
+ "'");
try {
QueryManager queryManager = getSession(sProvider).getWorkspace().getQueryManager();
Query query = queryManager.createQuery(queryString.toString(), Query.SQL);
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();
}
}
@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);
}
}
/**
* 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");
}
@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;
}
/**
* @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 void assertExtractedTextHasNotBeenIndexed(String validationQuery)
throws RepositoryException {
Query query =
jcrSession()
.getWorkspace()
.getQueryManager()
.createQuery(validationQuery, JcrQuery.JCR_SQL2);
QueryResult result = query.execute();
assertEquals("Node with text content was found", 0, result.getNodes().getSize());
}
@Test
public void shouldIndexQueryableBranches() throws Exception {
Node git = gitNode();
Workspace workspace = session.getWorkspace();
// force reindexing of tags and check that they haven't been indexed
workspace.reindex(git.getPath() + "/tags");
Query query =
workspace
.getQueryManager()
.createQuery(
"SELECT * FROM [nt:base] WHERE [jcr:path] LIKE '%/tags/%'", Query.JCR_SQL2);
assertEquals(0, query.execute().getNodes().getSize());
// force reindexing of branches and check that they haven't been indexed
workspace.reindex(git.getPath() + "/branches");
query =
workspace
.getQueryManager()
.createQuery(
"SELECT * FROM [nt:base] WHERE [jcr:path] LIKE '%/branches/%'", Query.JCR_SQL2);
assertEquals(0, query.execute().getNodes().getSize());
// force reindexing of a file under master/tree and check that it has been indexed
// (indexing everything under /tree/master is way too expensive)
workspace.reindex(git.getPath() + "/tree/master/.gitignore");
query =
workspace
.getQueryManager()
.createQuery(
"SELECT * FROM [nt:base] WHERE [jcr:path] LIKE '%/tree/master/%'", Query.JCR_SQL2);
assertTrue(query.execute().getNodes().getSize() > 0);
// force reindexing of a file under another configured branch and check that it has been indexed
workspace.reindex(git.getPath() + "/tree/2.x/.gitignore");
query =
workspace
.getQueryManager()
.createQuery(
"SELECT * FROM [nt:base] WHERE [jcr:path] LIKE '%/tree/2.x/%'", Query.JCR_SQL2);
assertTrue(query.execute().getNodes().getSize() > 0);
}
private void queryContentInWorkspace(JcrRepository newRepository, String workspaceName)
throws RepositoryException {
JcrSession session = newRepository.login();
try {
String statement = "SELECT [car:model], [car:year], [car:msrp] FROM [car:Car] AS car";
Query query = session.getWorkspace().getQueryManager().createQuery(statement, Query.JCR_SQL2);
QueryResult results = query.execute();
assertThat(results.getRows().getSize(), is(13L));
} finally {
session.logout();
}
}
/**
* 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);
}
}
}
}
@Test
public void shouldNotIndexNotQueryableDocument() throws Exception {
federationManager.createProjection(
"/testRoot", SOURCE_NAME, MockConnector.NONT_QUERYABLE_DOC_LOCATION, "nonQueryableDoc");
Workspace workspace = session.getWorkspace();
workspace.reindex();
Node externalNode = assertNodeFound("/testRoot/nonQueryableDoc");
QueryManager queryManager = workspace.getQueryManager();
Query query =
queryManager.createQuery(
"select * FROM [nt:base] WHERE [jcr:path] LIKE '/testRoot/nonQueryableDoc'",
Query.JCR_SQL2);
validateQuery().rowCount(0).validate(query, query.execute());
// change the document and re-run the query
externalNode.setProperty("test", "a value");
session.save();
validateQuery().rowCount(0).validate(query, query.execute());
}
public void testSpellCheckerIncorrectWords() throws RepositoryException {
String text = "the quick brown fox jumps over the lazy dog";
testRootNode.setProperty("prop", text);
superuser.save();
// wait a couple of seconds, refresh interval in test config is 5 seconds
try {
Thread.sleep(5 * 1000);
// perform a dummy check
performCheck("quick", "quick");
// wait again because refresh is done asynchronous
Thread.sleep(1 * 1000);
} catch (InterruptedException e) {
// ignore
}
String statement = "gismeteo";
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()");
assertNull("must not return a suggestion", v);
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()");
assertNull("must not return a suggestion", v);
}
/** 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;
}
/**
* @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;
}
}
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();
}
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;
}