/**
* Registors the custome node types for the jackrabbit-jcr-demo application from a given CND file.
* Location of the CND file is given as an initial parameter
*
* @throws ServletException is thrown when registration not possible.
*/
private void registerCustomNodeTypes() throws ServletException {
// location of the CND file is kept as a servelt init parameter in the web.xml
String cndPath = getInitParameter("cnd.path");
String ocmPath = getInitParameter("ocm.path");
try {
Workspace ws = session.getWorkspace();
NodeTypeManagerImpl ntTypeMgr = (NodeTypeManagerImpl) ws.getNodeTypeManager();
// Registors the custom node types and namespaces
InputStream inputStream = getServletContext().getResourceAsStream(cndPath);
ntTypeMgr.registerNodeTypes(inputStream, JackrabbitNodeTypeManager.TEXT_X_JCR_CND, true);
InputStream nodeTypeStream = getServletContext().getResourceAsStream(ocmPath);
ntTypeMgr.registerNodeTypes(nodeTypeStream, JackrabbitNodeTypeManager.TEXT_XML, true);
// Register a namespace to be used with in the program
// ex. for a username "nandana" we can use demo:nandana
NamespaceRegistryImpl nsReg =
(NamespaceRegistryImpl) session.getWorkspace().getNamespaceRegistry();
nsReg.safeRegisterNamespace("demo", "http://code.google.com/p/jackrabbit-jcr-demo");
nsReg.safeRegisterNamespace("ocm", "http://jackrabbit.apache.org/ocm");
log("JACKRABBIT-JCR-DEMO: Custom Node types registered ...");
} catch (RepositoryException e) {
throw new ServletException("Failed to registor node types", e);
} catch (IOException e) {
throw new ServletException("Error occured while accessing the file" + cndPath, 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);
}
}
private Node populateCache(HtmlLibrary library, String root, Session session) {
Node cacheNode = null;
try {
String libPath = (new StringBuilder(CACHE_PATH).append(library.getPath(false))).toString();
Node src = JcrUtils.getNodeIfExists(libPath, session);
cacheNode = session.getNode(root);
if (null != src) {
// this.lock.readLock().lock();
// produced closure compiled src
String compiled = compile(library, this.optimization, JcrUtils.readFile(src));
// this.lock.readLock().unlock();
// this.lock.writeLock().lock();
//
JcrUtils.putFile(
cacheNode.getParent(),
getLibraryName(library),
library.getType().contentType,
IOUtils.toInputStream(compiled, "UTF-8"));
session.save();
// this.lock.writeLock().unlock();
}
} catch (RepositoryException re) {
log.debug(re.getMessage());
} catch (IOException ioe) {
log.debug(ioe.getMessage());
}
return cacheNode;
}
public void updateFolderAllowed(String path) {
UIFormSelectBox sltWorkspace = getChildById(UIDriveInputSet.FIELD_WORKSPACE);
String strWorkspace = sltWorkspace.getSelectedValues()[0];
SessionProvider sessionProvider = WCMCoreUtils.getSystemSessionProvider();
try {
Session session =
sessionProvider.getSession(
strWorkspace,
getApplicationComponent(RepositoryService.class).getCurrentRepository());
Node rootNode = (Node) session.getItem(path);
List<SelectItemOption<String>> foldertypeOptions = new ArrayList<SelectItemOption<String>>();
RequestContext context = RequestContext.getCurrentInstance();
ResourceBundle res = context.getApplicationResourceBundle();
for (String foldertype : setFoldertypes) {
if (isChildNodePrimaryTypeAllowed(rootNode, foldertype)) {
try {
foldertypeOptions.add(
new SelectItemOption<String>(
res.getString(getId() + ".label." + foldertype.replace(":", "_")), foldertype));
} catch (MissingResourceException mre) {
foldertypeOptions.add(new SelectItemOption<String>(foldertype, foldertype));
}
}
}
Collections.sort(foldertypeOptions, new ItemOptionNameComparator());
getUIFormSelectBox(FIELD_ALLOW_CREATE_FOLDERS).setOptions(foldertypeOptions);
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error("Unexpected problem occurs while updating", 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);
}
}
/** {@inheritDoc} */
public void undeleteFile(
final Session session,
final PentahoJcrConstants pentahoJcrConstants,
final Serializable fileId)
throws RepositoryException {
Node fileToUndeleteNode = session.getNodeByIdentifier(fileId.toString());
String trashFileIdNodePath = fileToUndeleteNode.getParent().getPath();
String origParentFolderPath =
getOriginalParentFolderPath(session, pentahoJcrConstants, fileToUndeleteNode, false);
String absDestPath =
origParentFolderPath + RepositoryFile.SEPARATOR + fileToUndeleteNode.getName();
if (session.itemExists(absDestPath)) {
RepositoryFile file =
JcrRepositoryFileUtils.nodeToFile(
session,
pentahoJcrConstants,
pathConversionHelper,
lockHelper,
(Node) session.getItem(absDestPath));
throw new RepositoryFileDaoFileExistsException(file);
}
session.move(fileToUndeleteNode.getPath(), absDestPath);
session.getItem(trashFileIdNodePath).remove();
}
/**
* Tests if restoring the <code>Version</code> of an existing node throws an <code>
* ItemExistsException</code> if removeExisting is set to FALSE.
*/
public void testWorkspaceRestoreWithUUIDConflictJcr2()
throws RepositoryException, NotExecutableException {
try {
// Verify that nodes used for the test are indeed versionable
NodeDefinition nd = wVersionableNode.getDefinition();
if (nd.getOnParentVersion() != OnParentVersionAction.COPY
&& nd.getOnParentVersion() != OnParentVersionAction.VERSION) {
throw new NotExecutableException("Nodes must be versionable in order to run this test.");
}
VersionManager versionManager =
wVersionableNode.getSession().getWorkspace().getVersionManager();
String path = wVersionableNode.getPath();
Version v = versionManager.checkin(path);
versionManager.checkout(path);
wSuperuser.move(
wVersionableChildNode.getPath(),
wVersionableNode2.getPath() + "/" + wVersionableChildNode.getName());
wSuperuser.save();
wSuperuser.getWorkspace().getVersionManager().restore(new Version[] {v}, false);
fail(
"Node.restore( Version, boolean ): An ItemExistsException must be thrown if the node to be restored already exsits and removeExisting was set to false.");
} catch (ItemExistsException e) {
// success
}
}
public AbstractPageList<ResultNode> searchPageContents(
SessionProvider sessionProvider,
QueryCriteria queryCriteria,
int pageSize,
boolean isSearchContent)
throws Exception {
ManageableRepository currentRepository = repositoryService.getCurrentRepository();
Session session = sessionProvider.getSession("portal-system", currentRepository);
QueryManager queryManager = session.getWorkspace().getQueryManager();
long startTime = System.currentTimeMillis();
Query query = createSearchPageQuery(queryCriteria, queryManager);
String suggestion = getSpellSuggestion(queryCriteria.getKeyword(), currentRepository);
if (LOG.isDebugEnabled()) {
LOG.debug("execute query: " + query.getStatement().toLowerCase());
}
AbstractPageList<ResultNode> pageList =
PageListFactory.createPageList(
query.getStatement(),
session.getWorkspace().getName(),
query.getLanguage(),
true,
new PageNodeFilter(),
new PageDataCreator(),
pageSize,
0);
long queryTime = System.currentTimeMillis() - startTime;
pageList.setQueryTime(queryTime);
pageList.setSpellSuggestion(suggestion);
return pageList;
}
/**
* 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;
}
/**
* {@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.");
}
}
public String getHomePageLogoURI() {
SessionProvider sProvider = SessionProvider.createSystemProvider();
Node rootNode = null;
Node publicApplicationNode = null;
String pathImageNode = null;
Node ImageNode = null;
Session session = null;
try {
publicApplicationNode = nodeCreator.getPublicApplicationNode(sProvider);
session = publicApplicationNode.getSession();
rootNode = session.getRootNode();
Node logosNode = rootNode.getNode(path);
if (logosNode.hasNode(logo_name)) {
ImageNode = logosNode.getNode(logo_name);
pathImageNode = ImageNode.getPath() + "?" + System.currentTimeMillis();
}
} catch (Exception e) {
LOG.error("Can not get path of Logo : default LOGO will be used" + e.getMessage(), e);
return null;
} finally {
if (session != null) session.logout();
if (sProvider != null) sProvider.close();
}
return pathImageNode;
}
private boolean removeNode(String path) {
Resource templateResource = resourceResolver.getResource(path);
if (templateResource != null) {
Node nodeToDelete = templateResource.adaptTo(Node.class);
if (nodeToDelete != null) {
try {
nodeToDelete.remove();
TemplateUtils.saveNode(nodeToDelete);
session.save();
return true;
} catch (VersionException ex) {
java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
.log(Level.SEVERE, null, ex);
} catch (LockException ex) {
java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
.log(Level.SEVERE, null, ex);
} catch (ConstraintViolationException ex) {
java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
.log(Level.SEVERE, null, ex);
} catch (AccessDeniedException ex) {
java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
.log(Level.SEVERE, null, ex);
} catch (RepositoryException ex) {
java.util.logging.Logger.getLogger(TemplateManagerDeleteServlet.class.getName())
.log(Level.SEVERE, null, ex);
} finally {
session.logout();
}
}
}
return false;
}
public void writeNodes(
SlingHttpServletRequest request,
JSONWriter write,
Aggregator aggregator,
RowIterator iterator)
throws JSONException, RepositoryException {
Session session = request.getResourceResolver().adaptTo(Session.class);
// TODO Get size from somewhere else.
long total = iterator.getSize();
long start = SearchUtil.getPaging(request, total);
iterator.skip(start);
for (long i = 0; i < start && iterator.hasNext(); i++) {
Row row = iterator.nextRow();
String path = row.getValue("jcr:path").getString();
Node node = (Node) session.getItem(path);
if (aggregator != null) {
aggregator.add(node);
}
ExtendedJSONWriter.writeNodeToWriter(write, node);
}
}
@Test
public void testWrapper() throws Exception {
Connection conn = getConnection();
assertTrue(conn.isWrapperFor(JcrConnection.class));
try {
conn.isWrapperFor(null);
fail();
} catch (IllegalArgumentException ignore) {
}
assertFalse(conn.isWrapperFor(Session.class));
JcrConnection jcrConn = conn.unwrap(JcrConnection.class);
Session jcrSession = jcrConn.getSession();
assertNotNull(jcrSession);
assertTrue(jcrSession.isLive());
try {
conn.unwrap(null);
fail();
} catch (IllegalArgumentException ignore) {
}
try {
conn.unwrap(Session.class);
fail();
} catch (SQLException ignore) {
}
conn.close();
}
@Override
public ImportantFile[] listFiles(String path) {
ArrayList<ImportantFile> importantFiles = new ArrayList<ImportantFile>();
try {
NodeIterator itr = session.getRootNode().getNodes();
if (path != null && !path.equals("")) {
itr = session.getNode(path).getNodes();
}
while (itr.hasNext()) {
Node currentNode = itr.nextNode();
if (!isNodeVisible(currentNode)) {
continue;
}
ImportantFile iF = new ImportantFile(currentNode.getPath(), isNodeFolder(currentNode));
importantFiles.add(iF);
// PropertyIterator pi = currentNode.getProperties("jcr:primaryType");
// while (pi.hasNext()) {
// Property p = pi.nextProperty();
// LOG.debug("name - " + p.getName());
// LOG.debug("value - " + p.getValue());
// }
}
} catch (RepositoryException e) {
LOG.error(e);
}
return importantFiles.toArray(new ImportantFile[importantFiles.size()]);
}
@Override
public List<String> getEnabledExtensions() throws OKMException {
List<String> extensions = new ArrayList<String>();
Session session = null;
try {
Profile up = new Profile();
session = JCRUtils.getSession();
UserConfig uc = UserConfigDAO.findByPk(session, session.getUserID());
up = uc.getProfile();
extensions = new ArrayList<String>(up.getMisc().getExtensions());
} catch (LoginException e) {
log.error(e.getMessage(), e);
throw new OKMException(
ErrorCode.get(ErrorCode.ORIGIN_OKMGeneralService, ErrorCode.CAUSE_Repository),
e.getMessage());
} catch (javax.jcr.RepositoryException e) {
log.error(e.getMessage(), e);
throw new OKMException(
ErrorCode.get(ErrorCode.ORIGIN_OKMGeneralService, ErrorCode.CAUSE_Repository),
e.getMessage());
} catch (DatabaseException e) {
log.warn(e.getMessage(), e);
throw new OKMException(
ErrorCode.get(ErrorCode.ORIGIN_OKMGeneralService, ErrorCode.CAUSE_Database),
e.getMessage());
} finally {
JCRUtils.logout(session);
}
return extensions;
}
/**
* Returns an internal folder to store all files deleted from a given folder. Provides fast access
* when searching for files deleted from a given folder.
*/
private Node legacyGetTrashFolderIdNode(
final Session session,
final PentahoJcrConstants pentahoJcrConstants,
final String origParentFolderPath)
throws RepositoryException {
// get folder id
String folderId = null;
if (session.itemExists(origParentFolderPath)) {
folderId = ((Node) session.getItem(origParentFolderPath)).getIdentifier();
} else {
throw new RuntimeException(
Messages.getInstance()
.getString("DefaultDeleteHelper.ERROR_0001_PATH_NOT_FOUND")); // $NON-NLS-1$
}
final String prefix = session.getNamespacePrefix(PentahoJcrConstants.PHO_NS) + ":";
Node trashInternalFolderNode = getOrCreateTrashInternalFolderNode(session, pentahoJcrConstants);
if (NodeHelper.hasNode(trashInternalFolderNode, prefix, folderId)) {
return NodeHelper.getNode(trashInternalFolderNode, prefix, folderId);
} else {
// if Trash Structure 1 (legacy) doesn't exist, no need to create it now
return null;
}
}
public void initDefaultUsers() {
Session session = null;
try {
session = repository.loginAdministrative(null);
UserManager userManager = AccessControlUtil.getUserManager(session);
// Apply default user properties from JSON files.
Pattern fileNamePattern = Pattern.compile("/users/|\\.json");
@SuppressWarnings("rawtypes")
Enumeration entriesEnum = bundle.findEntries("users", "*.json", true);
while (entriesEnum.hasMoreElements()) {
Object entry = entriesEnum.nextElement();
URL jsonUrl = new URL(entry.toString());
String jsonFileName = jsonUrl.getFile();
String authorizableId = fileNamePattern.matcher(jsonFileName).replaceAll("");
Authorizable authorizable = userManager.getAuthorizable(authorizableId);
if (authorizable != null) {
applyJsonToAuthorizable(jsonUrl, authorizable, session);
LOGGER.info("Initialized default authorizable {}", authorizableId);
} else {
LOGGER.warn("Configured default authorizable {} not found", authorizableId);
}
}
} catch (RepositoryException e) {
LOGGER.error("Could not configure default authorizables", e);
} catch (IOException e) {
LOGGER.error("Could not configure default authorizables", e);
} finally {
if (session != null) {
session.logout();
}
}
}
/** Test if the removeExisting-flag removes an existing node in case of uuid conflict. */
public void testWorkspaceRestoreWithRemoveExistingJcr2()
throws NotExecutableException, RepositoryException {
// create version for parentNode of childNode
superuser
.getWorkspace()
.clone(
workspaceName, wVersionableChildNode.getPath(), wVersionableChildNode.getPath(), false);
Version parentV =
versionableNode
.getSession()
.getWorkspace()
.getVersionManager()
.checkin(versionableNode.getPath());
// move child node in order to produce the uuid conflict
String newChildPath = wVersionableNode2.getPath() + "/" + wVersionableChildNode.getName();
wSuperuser.move(wVersionableChildNode.getPath(), newChildPath);
wSuperuser.save();
// restore the parent with removeExisting == true >> moved child node
// must be removed.
wSuperuser.getWorkspace().getVersionManager().restore(new Version[] {parentV}, true);
if (wSuperuser.itemExists(newChildPath)) {
fail(
"Workspace.restore(Version[], boolean) with the boolean flag set to true, must remove the existing node in case of Uuid conflict.");
}
}
@Override
protected void doPost(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws ServletException, IOException {
String paramUser = request.getParameter(SiteService.SiteEvent.USER);
logger.info("Request to add user " + paramUser);
String paramGroup = "";
try {
Node requestedNode = request.getResource().adaptTo(Node.class);
Value[] authorizables = requestedNode.getProperty("sakai:authorizables").getValues();
paramGroup = authorizables[1].getString();
request.setAttribute(JoinRequestConstants.PARAM_SITENODE, requestedNode);
Session session = slingRepository.loginAdministrative(null);
UserManager userManager = AccessControlUtil.getUserManager(session);
Authorizable userAuth = userManager.getAuthorizable(paramUser);
Group groupAuth = (Group) userManager.getAuthorizable(paramGroup);
if (siteJoinIsAuthorized(request)) {
groupAuth.addMember(userAuth);
logger.info(paramUser + " added as member of group " + paramGroup);
} else {
response.sendError(403, "Not authorized to add member to site.");
}
if (session.hasPendingChanges()) {
session.save();
}
} catch (Exception e) {
response.sendError(500, e.getMessage());
}
}
/**
* 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);
}
}
/**
* Test method TaxonomyService.init() Expect: Create system taxonomy tree in dms-system
*
* @see {@link # testInit()}
*/
public void testInit() throws Exception {
Node systemTreeDef = (Node) dmsSesssion.getItem(definitionPath + "/System");
Node systemTreeStorage = (Node) dmsSesssion.getItem(storagePath + "/System");
assertNotNull(systemTreeDef);
assertNotNull(systemTreeStorage);
assertEquals(systemTreeStorage, linkManage.getTarget(systemTreeDef, true));
}
@Override
protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws ServletException, IOException {
response.setContentType("application/json");
response.setCharacterEncoding("utf-8");
String[] prefixes;
try {
Session session = (Session) request.getResourceResolver().adaptTo(Session.class);
prefixes = session.getNamespacePrefixes();
} catch (RepositoryException re) {
prefixes = new String[] {""};
}
try {
TidyJSONWriter out = new TidyJSONWriter(response.getWriter());
out.setTidy("true".equals(request.getParameter(TIDY)));
out.object();
out.key("namespaces");
out.array();
for (String p : prefixes) {
out.value(p);
}
out.endArray();
out.endObject();
} catch (JSONException e) {
// todo...
}
}
@Override
public void deleteDirectory(long companyId, long repositoryId, String dirName)
throws PortalException {
Session session = null;
try {
session = JCRFactoryUtil.createSession();
Node rootNode = getRootNode(session, companyId);
Node repositoryNode = getFolderNode(rootNode, repositoryId);
Node dirNode = repositoryNode.getNode(dirName);
dirNode.remove();
session.save();
} catch (PathNotFoundException pnfe) {
throw new NoSuchDirectoryException(dirName);
} catch (RepositoryException re) {
String message = GetterUtil.getString(re.getMessage());
if (message.contains("failed to resolve path")) {
throw new NoSuchDirectoryException(dirName);
} else {
throw new PortalException(re);
}
} finally {
JCRFactoryUtil.closeSession(session);
}
}
@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
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;
}
/** {@inheritDoc} */
public void onEvent(EventIterator eventIterator) {
// waiting for Event.PROPERTY_ADDED, Event.PROPERTY_REMOVED,
// Event.PROPERTY_CHANGED
Session session = null;
try {
while (eventIterator.hasNext()) {
Event event = eventIterator.nextEvent();
String path = event.getPath();
if (path.endsWith("/jcr:data")) {
// jcr:data removed 'exo:groovyResourceContainer' then unbind resource
if (event.getType() == Event.PROPERTY_REMOVED) {
unloadScript(path.substring(0, path.lastIndexOf('/')));
} else if (event.getType() == Event.PROPERTY_ADDED
|| event.getType() == Event.PROPERTY_CHANGED) {
if (session == null) {
session = repository.getSystemSession(workspaceName);
}
Node node = session.getItem(path).getParent();
if (node.getProperty("exo:autoload").getBoolean()) loadScript(node);
}
}
}
} catch (Exception e) {
LOG.error("Process event failed. ", e);
} finally {
if (session != null) {
session.logout();
}
}
}
public void testRestoreSNS() throws RepositoryException {
Session session = getHelper().getSuperuserSession();
// - Create a node 'a' with nodetype nt:unstructured
// (defining it's childnodes to show OPV Version behaviour)
Node node = session.getRootNode().addNode("RestoreSameNameSiblingTest");
try {
// - Create a child node 'b'
node.addNode("test");
// - Make 'a' versionable (add mixin mix:versionable)
node.addMixin(mixVersionable);
session.save();
// - Checkin/Checkout 'a'
Version version = node.checkin();
node.checkout();
assertEquals(1, node.getNodes("test").getSize());
// - Restore any version of 'a'
node.restore(version, true);
assertEquals(1, node.getNodes("test").getSize());
} finally {
node.remove();
session.save();
session.logout();
}
}
private Node createEmptyCache(HtmlLibrary library, String root, Session session) {
Node node = null;
// this.lock.writeLock().lock();
try {
Node swap =
JcrUtils.getOrCreateByPath(
root,
JcrResourceConstants.NT_SLING_FOLDER,
JcrResourceConstants.NT_SLING_FOLDER,
session,
true);
node = swap.addNode(getLibraryName(library), JcrConstants.NT_FILE);
swap = node.addNode(JcrConstants.JCR_CONTENT, JcrConstants.NT_RESOURCE);
swap.setProperty(JcrConstants.JCR_LASTMODIFIED, 0L);
swap.setProperty(JcrConstants.JCR_MIMETYPE, library.getType().contentType);
swap.setProperty(
JcrConstants.JCR_DATA,
session.getValueFactory().createBinary(new ByteArrayInputStream(new byte[0])));
session.save();
// this.lock.writeLock().unlock();
} catch (RepositoryException re) {
log.debug(re.getMessage());
}
return node;
}
private void persistBinaryContent(JcrRepository repository)
throws RepositoryException, IOException {
assertNotNull(repository);
long minimumBinarySize =
repository.getConfiguration().getBinaryStorage().getMinimumBinarySizeInBytes();
long binarySize = minimumBinarySize + 1;
Session session = repository.login();
InputStream binaryValueStream = null;
try {
byte[] content = new byte[(int) binarySize];
new Random().nextBytes(content);
JCR_TOOLS.uploadFile(session, "folder/file", new ByteArrayInputStream(content));
session.save();
Node nodeWithBinaryContent = session.getNode("/folder/file/jcr:content");
Binary binaryValue = nodeWithBinaryContent.getProperty("jcr:data").getBinary();
binaryValueStream = binaryValue.getStream();
byte[] retrievedContent = IoUtil.readBytes(binaryValueStream);
assertArrayEquals(content, retrievedContent);
} finally {
if (binaryValueStream != null) {
binaryValueStream.close();
}
session.logout();
}
}
