/**
* Converts file to JCR binary content and stores to new node
*
* @param userNode note to which children node will be created with binary content * @param
* cvIStream CV file input stream
* @param fileType type of file stored to node
*/
public static void convertFileStreamToNode(
Node userNode, InputStream cvIStream, AllowedFileType fileType) {
if (userNode == null) {
throw new IllegalArgumentException("User node is null");
}
if (cvIStream == null) {
throw new IllegalArgumentException("CV file input stream is null");
}
if (fileType == null) {
throw new IllegalArgumentException("File type is null");
}
try {
Node cvNode = userNode.addNode(fileType.getNodeType().toString(), "nt:file");
cvNode.addMixin(MIXIN_HASCONTENT.toString());
Node content = cvNode.addNode("jcr:content", "nt:resource");
content.setProperty(
"jcr:data", userNode.getSession().getValueFactory().createBinary(cvIStream));
content.setProperty("jcr:mimeType", fileType.getMimeType());
cvNode.setProperty(
PROP_CONTENT.toString(),
Utils.extractText(content.getProperty("jcr:data").getBinary().getStream(), fileType));
} catch (RepositoryException e) {
logger.error(
"Failed to convert " + fileType.toString() + " file to binary node. " + e.getMessage());
}
}
public void send(
SlingHttpServletRequest request, SlingHttpServletResponse response, HtmlLibrary library) {
InputStream libraryInputStream = null;
// NOTE: HtmlLibraryManager#getLibrary should have prepared ClientLibraryImpl
// and related binary stream should be ready
try {
Node node =
JcrUtils.getNodeIfExists(getLibraryNode(request, library), JcrConstants.JCR_CONTENT);
response.setDateHeader(
"Last-Modified", JcrUtils.getLongProperty(node, JcrConstants.JCR_LASTMODIFIED, 0L));
response.setContentType(library.getType().contentType);
response.setCharacterEncoding("utf-8");
libraryInputStream = JcrUtils.readFile(node);
} catch (RepositoryException re) {
log.debug("JCR issue retrieving library node at {}: ", library.getPath(), re.getMessage());
}
try {
if (libraryManager.isGzipEnabled()) {
response.setHeader("Content-Encoding", "gzip");
GZIPOutputStream gzipOut = new GZIPOutputStream(response.getOutputStream());
IOUtils.copy(libraryInputStream, gzipOut);
gzipOut.finish();
} else {
IOUtils.copy(libraryInputStream, response.getOutputStream());
}
} catch (IOException ioe) {
log.debug("gzip IO issue for library {}: ", library.getPath(), ioe.getMessage());
} finally {
IOUtils.closeQuietly(libraryInputStream);
}
}
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;
}
@Override
public List<JcrNode> childNodes(String path) throws RemoteException {
List<JcrNode> children = null;
if (path == null || path.trim().length() == 0) {
return Collections.emptyList();
}
try {
Node node = (Node) session().getItem(path);
NodeIterator it = node.getNodes();
children = new ArrayList<JcrNode>((int) it.getSize());
while (it.hasNext()) {
Node n = it.nextNode();
JcrNode childNode = new JcrNode(n.getName(), n.getPath(), n.getPrimaryNodeType().getName());
childNode.setProperties(getProperties(n));
childNode.setAcessControlList(getAccessList(session().getAccessControlManager(), node));
childNode.setMixins(mixins(n));
childNode.setPropertyDefs(propertyDefs(n));
children.add(childNode);
}
} catch (PathNotFoundException e) {
log.log(Level.FINER, e.getLocalizedMessage());
} catch (RepositoryException e) {
log.log(Level.SEVERE, "Unexpected error", e);
throw new RemoteException(e.getMessage());
}
return children;
}
private JcrNodeModel getPhysicalNode(JcrNodeModel model) {
Node node = model.getNode();
if (node != null) {
try {
if (node.isNodeType("nt:version")) {
Node frozen = node.getNode("jcr:frozenNode");
String uuid = frozen.getProperty("jcr:frozenUuid").getString();
try {
Node docNode = node.getSession().getNodeByUUID(uuid);
if (docNode.getDepth() > 0) {
Node parent = docNode.getParent();
if (parent.isNodeType(HippoNodeType.NT_HANDLE)) {
return new JcrNodeModel(parent);
}
}
return new JcrNodeModel(docNode);
} catch (ItemNotFoundException infe) {
// node doesn't exist anymore. If it's a document, the handle
// should still be available though.
if (frozen.hasProperty(HippoNodeType.HIPPO_PATHS)) {
Value[] ancestors = frozen.getProperty(HippoNodeType.HIPPO_PATHS).getValues();
if (ancestors.length > 1) {
uuid = ancestors[1].getString();
return new JcrNodeModel(node.getSession().getNodeByUUID(uuid));
}
}
throw infe;
}
}
} catch (RepositoryException ex) {
log.error(ex.getMessage());
}
}
return model;
}
public void execute(WorkItem item, WorkflowSession session, MetaDataMap args)
throws WorkflowException {
WorkflowData workflowData = item.getWorkflowData();
log.info("==================== <> ======================");
Iterator props = args.entrySet().iterator();
String pathToArchive = args.get("PROCESS_ARGS", String.class);
if (pathToArchive != null)
if (workflowData.getPayloadType().equals(TYPE_JCR_PATH)) {
String path = workflowData.getPayload().toString();
try {
Node node = (Node) session.getSession().getItem(path + "/jcr:content");
String orderBy = node.getProperty("orderby").getString();
log.info("----------orderby: " + orderBy);
Node nodeToOrder = (Node) session.getSession().getItem(pathToArchive);
Iterator<Node> iterator = nodeToOrder.getNodes();
List<Node> nodes = copyIterator(iterator);
Collections.sort(nodes, new NodeComparator(orderBy));
for (Node orderNode : nodes) {
session
.getSession()
.getWorkspace()
.move(
pathToArchive + "/" + orderNode.getName(),
pathToArchive + "/" + orderNode.getName());
}
} catch (RepositoryException e) {
throw new WorkflowException(e.getMessage(), e);
}
}
}
@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;
}
@Test
@FixFor("MODE-1977")
public void shouldNotAllowMoveIfSourceIsFederatedAndTargetIsNot() throws Exception {
federationManager.createProjection(
"/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, "fed1");
((Node) session.getRootNode()).addNode("testRoot2");
session.save();
try {
session.move("/testRoot", "/testRoot2");
fail("Should not allow move is source is federated is target is not.");
} catch (RepositoryException e) {
// expected
if (print) {
e.printStackTrace();
}
}
try {
session.move("/testRoot/fed1", "/testRoot2");
fail("Should not allow move is source is federated is target is not.");
} catch (RepositoryException e) {
// expected
if (print) {
e.printStackTrace();
}
}
}
@Test
@FixFor("MODE-1977")
public void shouldNotAllowMoveIfSourceOrTargetIsProjection() throws Exception {
federationManager.createProjection(
"/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, "fed1");
federationManager.createProjection(
"/testRoot", SOURCE_NAME, MockConnector.DOC2_LOCATION, "fed2");
try {
session.move("/testRoot/fed2/federated3", "/testRoot/fed1");
fail("Should not allow move if target is projection");
} catch (RepositoryException e) {
// expected
if (print) {
e.printStackTrace();
}
}
try {
session.move("/testRoot/fed2", "/testRoot/fed1");
fail("Should not allow move if source is projection");
} catch (RepositoryException e) {
// expected
if (print) {
e.printStackTrace();
}
}
}
public JcrRepository call() throws Exception {
JcrRepository repository = null;
try {
repository = doCreateJcrRepository(repositoryName);
getLogger().info(JcrI18n.completedStartingRepository, repositoryName);
return repository;
} catch (RepositoryException t) {
// Record this in the problems ...
problems()
.addError(
t,
JcrI18n.errorStartingRepositoryCheckConfiguration,
repositoryName,
t.getMessage());
throw t;
} catch (Throwable t) {
// Record this in the problems ...
problems()
.addError(
t,
JcrI18n.errorStartingRepositoryCheckConfiguration,
repositoryName,
t.getMessage());
String msg =
JcrI18n.errorStartingRepositoryCheckConfiguration.text(repositoryName, t.getMessage());
throw new RepositoryException(msg, t);
} finally {
if (latch != null) latch.countDown();
}
}
@Test
public void shouldNotAllowInternalNodesAsReferrers() throws Exception {
federationManager.createProjection(
"/testRoot", SOURCE_NAME, MockConnector.DOC1_LOCATION, "federated1");
Node doc1Federated = session.getNode("/testRoot/federated1");
Node externalNode = doc1Federated.addNode("federated1_1", null);
externalNode.addMixin("mix:referenceable");
session.save();
Value weakRef = session.getValueFactory().createValue(externalNode, true);
testRoot.setProperty("weakRef", weakRef);
try {
session.save();
fail(
"It should not be possible to create weak references from internal nodes to external nodes");
} catch (RepositoryException e) {
assertTrue(e.getCause() instanceof ConnectorException);
}
Value strongRef = session.getValueFactory().createValue(externalNode, false);
testRoot.setProperty("strongRef", strongRef);
try {
session.save();
fail(
"It should not be possible to create strong references from internal nodes to external nodes");
} catch (RepositoryException e) {
assertTrue(e.getCause() instanceof ConnectorException);
}
}
@Override
public void doTag() throws JspException {
this.setUp();
try {
Content imageContentNode = ContentUtil.asContent(getImageContentNode());
String[] subStrings = this.getTextSubStrings(this.text);
String[] imageURIs =
this.getImageURIs(
subStrings,
(HttpServletRequest) ((PageContext) this.getJspContext()).getRequest(),
imageContentNode);
this.drawTextImages(imageURIs, subStrings);
} catch (PathNotFoundException e) {
log.error(
"PathNotFoundException occured during text-to-image conversion: " + e.getMessage(), e);
} catch (AccessDeniedException e) {
log.error(
"AccessDeniedException occured during text-to-image conversion: " + e.getMessage(), e);
} catch (RepositoryException e) {
log.error(
"RepositoryException occured during text-to-image conversion: " + e.getMessage(), e);
} catch (FileNotFoundException e) {
log.error(
"FileNotFoundException occured during text-to-image conversion: " + e.getMessage(), e);
} catch (IOException e) {
log.error("IOException occured during text-to-image conversion: " + e.getMessage(), e);
} catch (FontFormatException e) {
log.error(
"FontFormatException occured during text-to-image conversion: " + e.getMessage(), e);
}
this.cleanUp();
}
/** {@inheritDoc} */
public void start() {
configuredTemplates_ = new HashMap<String, Set<String>>();
RepositoryEntry repositoryEntry = null;
try {
repositoryEntry = repositoryService.getCurrentRepository().getConfiguration();
} catch (RepositoryException e) {
if (LOG.isErrorEnabled()) {
LOG.error(e.getMessage(), e);
}
}
String repoName = repositoryEntry.getName();
String workspaceName = repositoryEntry.getSystemWorkspaceName();
storedWorkspaces.put(repoName, workspaceName);
basedApplicationTemplatesPath = hierarchyCreator.getJcrPath(BasePath.CMS_VIEWTEMPLATES_PATH);
SessionProvider sessionProvider = SessionProvider.createSystemProvider();
for (Iterator<String> repositories = storedWorkspaces.keySet().iterator();
repositories.hasNext(); ) {
String repository = repositories.next();
try {
Node storedTemplateHome = getBasedApplicationTemplatesHome(sessionProvider);
importPredefinedTemplateToDB(storedTemplateHome);
} catch (Exception e) {
if (LOG.isErrorEnabled()) {
LOG.error(
"Exception when import predefine application template into repository: " + repository,
e);
}
}
}
sessionProvider.close();
}
public String pasteNode(String pathOrigin, String pathSelected, int pasteType, int action)
throws ExchangeException, RepositoryException {
boolean move = false;
if (action == Tree.ACTION_MOVE) {
move = true;
}
String label = StringUtils.substringAfterLast(pathOrigin, "/"); // $NON-NLS-1$
String slash = "/"; // $NON-NLS-1$
if (pathSelected.equals("/")) { // $NON-NLS-1$
slash = StringUtils.EMPTY;
}
String destination = pathSelected + slash + label;
if (pasteType == Tree.PASTETYPE_SUB
&& action != Tree.ACTION_COPY
&& destination.equals(pathOrigin)) {
// drag node to parent node: move to last position
pasteType = Tree.PASTETYPE_LAST;
}
if (pasteType == Tree.PASTETYPE_SUB) {
destination = pathSelected + slash + label;
Content touchedContent = this.copyMoveNode(pathOrigin, destination, move);
if (touchedContent == null) {
return StringUtils.EMPTY;
}
return touchedContent.getHandle();
} else if (pasteType == Tree.PASTETYPE_LAST) {
// LAST only available for sorting inside the same directory
try {
Content touchedContent = getHierarchyManager().getContent(pathOrigin);
return touchedContent.getHandle();
} catch (RepositoryException re) {
return StringUtils.EMPTY;
}
} else {
try {
// PASTETYPE_ABOVE | PASTETYPE_BELOW
String nameSelected = StringUtils.substringAfterLast(pathSelected, "/"); // $NON-NLS-1$
String nameOrigin = StringUtils.substringAfterLast(pathOrigin, "/"); // $NON-NLS-1$
Content tomove = getHierarchyManager().getContent(pathOrigin);
Content selected = getHierarchyManager().getContent(pathSelected);
if (tomove.getParent().getUUID().equals(selected.getParent().getUUID())) {
tomove.getParent().orderBefore(nameOrigin, nameSelected);
tomove.getParent().save();
} else {
String newOrigin = selected.getParent().getHandle() + "/" + nameOrigin;
getHierarchyManager().moveTo(pathOrigin, newOrigin);
Content newNode = getHierarchyManager().getContent(newOrigin);
if (pasteType == Tree.PASTETYPE_ABOVE) {
newNode.getParent().orderBefore(nameOrigin, nameSelected);
}
}
return tomove.getHandle();
} catch (RepositoryException re) {
re.printStackTrace();
log.error("Problem when pasting node", re);
return StringUtils.EMPTY;
}
}
}
/**
* Add a new version-able <code>EcmDocument</code> under the parent folder name provided
*
* @param pFolderPath the name of the parent folder
* @param document the <code>EcmDocument</code> object
* @throws EcmException if there is any error
*/
public void addNewVersionableDocumentToFolder(String pFolderPath, EcmDocument document)
throws EcmException {
logger.debug("Adding versionable document to folder:" + pFolderPath);
try {
Node parentNode = this.getNode(pFolderPath);
Node fileNode = parentNode.addNode(document.getMetadata().getFileName(), NodeType.NT_FILE);
fileNode.addMixin(NodeType.MIX_VERSIONABLE);
this.createFileContentNode(fileNode, document);
this.session.save();
/** Get the version manager */
VersionManager vm = this.session.getWorkspace().getVersionManager();
/** Check in the changes as a new version */
vm.checkin(fileNode.getPath());
this.session.save();
} catch (RepositoryException e) {
e.printStackTrace();
}
logger.debug("A document has been added to the folder:" + pFolderPath);
}
@Override
public ResultSet findSimpleQueryPaginated(String token, String statement, int offset, int limit)
throws RepositoryException, DatabaseException {
log.debug(
"findSimpleQueryPaginated({}, {}, {}, {})", new Object[] {token, statement, offset, limit});
ResultSet rs = new ResultSet();
Session session = null;
try {
if (token == null) {
session = JCRUtils.getSession();
} else {
session = JcrSessionManager.getInstance().get(token);
}
rs = executeSimpleQuery(session, statement, offset, limit);
} 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("findSimpleQueryPaginated: {}", rs);
return rs;
}
private void badNodeNameParam(String name, String exception) throws RepositoryException {
CreateSakaiUserServlet csus = new CreateSakaiUserServlet();
csus.requestTrustValidatorService = requestTrustValidatorService;
JackrabbitSession session = createMock(JackrabbitSession.class);
ResourceResolver rr = createMock(ResourceResolver.class);
SlingHttpServletRequest request = createMock(SlingHttpServletRequest.class);
UserManager userManager = createMock(UserManager.class);
User user = createMock(User.class);
expect(request.getResourceResolver()).andReturn(rr).anyTimes();
expect(rr.adaptTo(Session.class)).andReturn(session).anyTimes();
expect(session.getUserManager()).andReturn(userManager);
expect(session.getUserID()).andReturn("userID");
expect(userManager.getAuthorizable("userID")).andReturn(user);
expect(user.isAdmin()).andReturn(false);
expect(request.getParameter(":create-auth")).andReturn("reCAPTCHA");
expect(request.getParameter(SlingPostConstants.RP_NODE_NAME)).andReturn(name);
HtmlResponse response = new HtmlResponse();
replay();
try {
csus.handleOperation(request, response, null);
fail();
} catch (RepositoryException e) {
assertEquals(exception, e.getMessage());
}
verify();
}
/** 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;
}
/** 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 void updateSearch(String token, QueryParams params)
throws AccessDeniedException, RepositoryException, DatabaseException {
log.debug("updateSearch({}, {})", token, params);
Session session = null;
if (Config.SYSTEM_READONLY) {
throw new AccessDeniedException("System is in read-only mode");
}
try {
// TODO This JCR Session could be removed
if (token == null) {
session = JCRUtils.getSession();
} else {
session = JcrSessionManager.getInstance().get(token);
}
params.setUser(session.getUserID());
QueryParamsDAO.update(params);
// Activity log
UserActivity.log(
session.getUserID(), "UPDATE_SEARCH", params.getName(), null, params.toString());
} catch (javax.jcr.RepositoryException e) {
throw new RepositoryException(e.getMessage(), e);
} catch (DatabaseException e) {
throw e;
} finally {
if (token == null) JCRUtils.logout(session);
}
log.debug("updateSearch: void");
}
@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);
}
}
@Before
public void setUp() throws RepositoryException {
initMocks(this);
final String relPath = "/" + testPid;
final NodeType[] types = new NodeType[0];
try {
when(mockObjNode.getName()).thenReturn(testPid);
when(mockObjNode.getSession()).thenReturn(mockSession);
when(mockObjNode.getMixinNodeTypes()).thenReturn(types);
NodeType mockNodeType = mock(NodeType.class);
when(mockNodeType.getName()).thenReturn("nt:folder");
when(mockObjNode.getPrimaryNodeType()).thenReturn(mockNodeType);
when(mockSession.getRootNode()).thenReturn(mockRootNode);
when(mockRootNode.getNode(relPath)).thenReturn(mockObjNode);
when(mockSession.getUserID()).thenReturn(mockUser);
testFedoraObject = new FedoraObject(mockObjNode);
mockNodetypes = new NodeType[2];
mockNodetypes[0] = mock(NodeType.class);
mockNodetypes[1] = mock(NodeType.class);
when(mockObjNode.getMixinNodeTypes()).thenReturn(mockNodetypes);
when(mockPredicate.apply(mockObjNode)).thenReturn(true);
} catch (final RepositoryException e) {
e.printStackTrace();
fail(e.getMessage());
}
}
public String printProperty(javax.jcr.Property property) {
try {
return printObject(JcrResourceUtil.toJavaObject(property));
} catch (RepositoryException e1) {
return e1.getMessage();
}
}
public static void main(String[] argv) {
// Create and start the engine ...
ModeShapeEngine engine = new ModeShapeEngine();
engine.start();
// Load the configuration for a repository via the classloader (can also use path to a file)...
Repository repository = null;
String repositoryName = null;
try {
URL url = ModeShapeExample.class.getClassLoader().getResource("my-repository-config.json");
RepositoryConfiguration config = RepositoryConfiguration.read(url);
// We could change the name of the repository programmatically ...
// config = config.withName("Some Other Repository");
// Verify the configuration for the repository ...
Problems problems = config.validate();
if (problems.hasErrors()) {
System.err.println("Problems starting the engine.");
System.err.println(problems);
System.exit(-1);
}
// Deploy the repository ...
repository = engine.deploy(config);
repositoryName = config.getName();
} catch (Throwable e) {
e.printStackTrace();
System.exit(-1);
return;
}
Session session = null;
try {
// Get the repository
repository = engine.getRepository(repositoryName);
// Create a session ...
session = repository.login("default");
// Get the root node ...
Node root = session.getRootNode();
assert root != null;
System.out.println(
"Found the root node in the \"" + session.getWorkspace().getName() + "\" workspace");
} catch (RepositoryException e) {
e.printStackTrace();
} finally {
if (session != null) session.logout();
System.out.println("Shutting down engine ...");
try {
engine.shutdown().get();
System.out.println("Success!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
/** {@inheritDoc} */
public void doPost(SlingHttpServletRequest request, SlingHttpServletResponse response)
throws ServletException, IOException {
try {
Resource resource = request.getResource();
Node node = resource.adaptTo(Node.class);
if (node == null) {
response.sendError(HttpServletResponse.SC_NOT_FOUND);
return;
}
Version version = versionService.saveNode(node, request.getRemoteUser());
response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");
ExtendedJSONWriter write = new ExtendedJSONWriter(response.getWriter());
write.object();
write.key("versionName");
write.value(version.getName());
ExtendedJSONWriter.writeNodeContentsToWriter(write, version);
write.endObject();
} catch (RepositoryException e) {
LOGGER.info("Failed to save version ", e);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
return;
} catch (JSONException e) {
LOGGER.info("Failed to save version ", e);
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
return;
}
}
protected void fillRecipients(Message email, Execution execution, JCRSessionWrapper session)
throws MessagingException {
try {
// to
AddressTemplate to = getTemplate().getTo();
if (to != null) {
fillRecipients(to, email, Message.RecipientType.TO, execution, session);
}
// cc
AddressTemplate cc = getTemplate().getCc();
if (cc != null) {
fillRecipients(cc, email, Message.RecipientType.CC, execution, session);
}
// bcc
AddressTemplate bcc = getTemplate().getBcc();
if (bcc != null) {
fillRecipients(bcc, email, Message.RecipientType.BCC, execution, session);
}
} catch (ScriptException e) {
logger.error(e.getMessage(), e);
} catch (RepositoryException e) {
logger.error(e.getMessage(), e);
}
}
public Node getLibraryNode(SlingHttpServletRequest request, HtmlLibrary library) {
Node node = null;
try {
// we want the non-minified version as the root path
String cacheRoot =
Text.getRelativeParent(
(new StringBuilder(CACHE_PATH).append(library.getPath(false))).toString(), 1);
String optPath =
(new StringBuilder(cacheRoot).append("/").append(getLibraryName(library))).toString();
node = JcrUtils.getNodeIfExists(optPath, getAdminSession());
if (null == node) {
// generate empty jcr:data to cache
node = createEmptyCache(library, cacheRoot, getAdminSession());
}
// lib was modified after last cache write
if (!node.hasNode(JcrConstants.JCR_CONTENT)
|| library.getLastModified(false)
> JcrUtils.getLongProperty(
node.getNode(JcrConstants.JCR_CONTENT), JcrConstants.JCR_LASTMODIFIED, 0L)) {
// generate new binary, if possible
node = populateCache(library, node.getPath(), getAdminSession());
}
// reassign with user session
node = request.getResourceResolver().resolve(node.getPath()).adaptTo(Node.class);
} catch (RepositoryException re) {
log.debug(re.getMessage());
} finally {
getResolver().close();
}
return node;
}
/**
* {@inheritDoc}
*
* @return the next frozen node.
*/
public Node nextNode() {
try {
return ((Version) next()).getFrozenNode();
} catch (RepositoryException e) {
throw (IllegalStateException) new IllegalStateException(e.toString()).initCause(e);
}
}
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;
}
/**
* Imports custom node types into repository
*
* @param session JCR session
* @param cndFile CND file with node types definition
*/
public static void importCustomNodeTypes(Session session, InputStream cndFile) {
if (logger.isInfoEnabled()) {
logger.info("Importing custom node types into repository");
}
NodeType[] nodeTypes = new NodeType[0];
try {
nodeTypes =
CndImporter.registerNodeTypes(
new BufferedReader(new InputStreamReader(cndFile)), session);
} catch (ParseException e) {
logger.error("Failed to parse CND file with repository custom node types. " + e.getMessage());
} catch (RepositoryException e) {
logger.error("Failed to import custom node types into repository. " + e.getMessage());
} catch (IOException e) {
logger.error(
"IO Exception while importing custom node types into repository. " + e.getMessage());
}
if (logger.isDebugEnabled()) {
logger.debug("Registered node types: ");
for (NodeType nt : nodeTypes) {
logger.debug("\t" + nt.getName());
}
}
}