/**
* Load properties from the query node, request and property provider.<br>
* Overwrite order: query node < request < property provider<br>
* This ordering allows the query node to set defaults, the request to override those defaults but
* the property provider to have the final say in what value is set.
*
* @param request
* @param propertyProviderName
* @return
* @throws RepositoryException
*/
private Map<String, String> loadProperties(
SlingHttpServletRequest request, String propertyProviderName, Node node)
throws RepositoryException {
Map<String, String> propertiesMap = new HashMap<String, String>();
// 0. load authorizable (user) information
String userId = request.getRemoteUser();
String userPrivatePath = ClientUtils.escapeQueryChars(LitePersonalUtils.getPrivatePath(userId));
propertiesMap.put("_userPrivatePath", userPrivatePath);
propertiesMap.put("_userId", ClientUtils.escapeQueryChars(userId));
// 1. load in properties from the query template node so defaults can be set
PropertyIterator props = node.getProperties();
while (props.hasNext()) {
javax.jcr.Property prop = props.nextProperty();
if (!propertiesMap.containsKey(prop.getName()) && !prop.isMultiple()) {
propertiesMap.put(prop.getName(), prop.getString());
}
}
// 2. load in properties from the request
RequestParameterMap params = request.getRequestParameterMap();
for (Entry<String, RequestParameter[]> entry : params.entrySet()) {
String key = entry.getKey();
RequestParameter[] vals = entry.getValue();
String requestValue = vals[0].getString();
// blank values aren't cool
if (StringUtils.isBlank(requestValue)) {
continue;
}
// KERN-1601 Wildcard searches have to be manually lowercased for case insensitive
// matching as Solr bypasses the analyzer when dealing with a wildcard or fuzzy
// search.
if (StringUtils.contains(requestValue, '*') || StringUtils.contains(requestValue, '~')) {
requestValue = requestValue.toLowerCase();
}
// KERN-1703 Escape just :
requestValue = StringUtils.replace(requestValue, ":", "\\:");
propertiesMap.put(entry.getKey(), requestValue);
}
// 3. load properties from a property provider
if (propertyProviderName != null) {
LOGGER.debug("Trying Provider Name {} ", propertyProviderName);
SolrSearchPropertyProvider provider = propertyProvider.get(propertyProviderName);
if (provider != null) {
LOGGER.debug("Trying Provider {} ", provider);
provider.loadUserProperties(request, propertiesMap);
} else {
LOGGER.warn("No properties provider found for {} ", propertyProviderName);
}
} else {
LOGGER.debug("No Provider ");
}
return propertiesMap;
}
protected void dispatch(
SlingHttpServletRequest request, SlingHttpServletResponse response, boolean userInputStream)
throws ServletException, IOException {
try {
Resource resource = request.getResource();
if (!resource.getPath().startsWith(PROXY_PATH_PREFIX)) {
response.sendError(
HttpServletResponse.SC_FORBIDDEN,
"Proxying templates may only be stored in " + PROXY_PATH_PREFIX);
return;
}
Node node = resource.adaptTo(Node.class);
if (!userInputStream) {
Value[] v = JcrUtils.getValues(node, SAKAI_REQUEST_STREAM_BODY);
if (v != null && v.length > 0) {
userInputStream = Boolean.parseBoolean(v[0].getString());
}
}
Map<String, String> headers = new ConcurrentHashMap<String, String>();
for (Enumeration<?> enames = request.getHeaderNames(); enames.hasMoreElements(); ) {
String name = (String) enames.nextElement();
if (!headerBacklist.contains(name)) {
headers.put(name, request.getHeader(name));
}
}
// search for special headers.
if (headers.containsKey(BASIC_USER)) {
String user = headers.get(BASIC_USER);
String password = headers.get(BASIC_PASSWORD);
Base64 base64 = new Base64();
String passwordDigest =
new String(base64.encode((user + ":" + password).getBytes("UTF-8")));
String digest = BASIC + passwordDigest.trim();
headers.put(AUTHORIZATION, digest);
}
for (Entry<String, String> e : headers.entrySet()) {
if (e.getKey().startsWith(":")) {
headers.remove(e.getKey());
}
}
// collect the parameters and store into a mutable map.
RequestParameterMap parameterMap = request.getRequestParameterMap();
Map<String, Object> templateParams = new ConcurrentHashMap<String, Object>(parameterMap);
// search for special parameters.
if (parameterMap.containsKey(BASIC_USER)) {
String user = parameterMap.getValue(BASIC_USER).getString();
String password = parameterMap.getValue(BASIC_PASSWORD).getString();
Base64 base64 = new Base64();
String passwordDigest =
new String(base64.encode((user + ":" + password).getBytes("UTF-8")));
String digest = BASIC + passwordDigest.trim();
headers.put(AUTHORIZATION, digest);
}
// we might want to pre-process the headers
if (node.hasProperty(ProxyPreProcessor.SAKAI_PREPROCESSOR)) {
String preprocessorName =
node.getProperty(ProxyPreProcessor.SAKAI_PREPROCESSOR).getString();
ProxyPreProcessor preprocessor = preProcessors.get(preprocessorName);
if (preprocessor != null) {
preprocessor.preProcessRequest(request, headers, templateParams);
} else {
LOGGER.warn(
"Unable to find pre processor of name {} for node {} ",
preprocessorName,
node.getPath());
}
}
ProxyPostProcessor postProcessor = defaultPostProcessor;
// we might want to post-process the headers
if (node.hasProperty(ProxyPostProcessor.SAKAI_POSTPROCESSOR)) {
String postProcessorName =
node.getProperty(ProxyPostProcessor.SAKAI_POSTPROCESSOR).getString();
if (postProcessors.containsKey(postProcessorName)) {
postProcessor = postProcessors.get(postProcessorName);
}
if (postProcessor == null) {
LOGGER.warn(
"Unable to find post processor of name {} for node {} ",
postProcessorName,
node.getPath());
postProcessor = defaultPostProcessor;
}
}
ProxyResponse proxyResponse =
proxyClientService.executeCall(node, headers, templateParams, null, -1, null);
try {
postProcessor.process(templateParams, response, proxyResponse);
} finally {
proxyResponse.close();
}
} catch (IOException e) {
throw e;
} catch (ProxyClientException e) {
response.sendError(500, e.getMessage());
} catch (RepositoryException e) {
response.sendError(500, e.getMessage());
}
}
@Test
public void testCreate() throws Exception {
// activate
when(slingRepository.loginAdministrative(null)).thenReturn(adminSession);
when(request.getResourceResolver()).thenReturn(resourceResolver);
when(resourceResolver.adaptTo(javax.jcr.Session.class)).thenReturn(jcrSesson);
Session session = repository.loginAdministrative("ieb");
when(jcrSesson.getUserManager()).thenReturn(sparseMapUserManager);
when(sparseMapUserManager.getSession()).thenReturn(session);
when(clusterTrackingService.getClusterUniqueId())
.thenReturn(String.valueOf(System.currentTimeMillis()));
when(request.getRequestPathInfo()).thenReturn(requestPathInfo);
when(requestPathInfo.getExtension()).thenReturn(null);
when(adminSession.getUserManager()).thenReturn(userManager);
when(adminSession.getPrincipalManager()).thenReturn(principalManager);
when(adminSession.getAccessControlManager()).thenReturn(accessControlManager);
when(request.getRemoteUser()).thenReturn("ieb");
when(request.getRequestParameterMap()).thenReturn(requestParameterMap);
Map<String, RequestParameter[]> map = new HashMap<String, RequestParameter[]>();
RequestParameter[] requestParameters =
new RequestParameter[] {
requestParameter1, requestParameterNot, requestParameter2,
};
map.put("files", requestParameters);
when(requestParameterMap.entrySet()).thenReturn(map.entrySet());
when(requestParameter1.isFormField()).thenReturn(false);
when(requestParameter1.getContentType()).thenReturn("application/pdf");
when(requestParameter1.getFileName()).thenReturn("testfilename.pdf");
InputStream input1 = new ByteArrayInputStream(new byte[10]);
when(requestParameter1.getInputStream()).thenReturn(input1);
when(requestParameter2.isFormField()).thenReturn(false);
when(requestParameter2.getContentType()).thenReturn("text/html");
when(requestParameter2.getFileName()).thenReturn("index.html");
InputStream input2 = new ByteArrayInputStream(new byte[10]);
when(requestParameter2.getInputStream()).thenReturn(input2);
when(requestParameterNot.isFormField()).thenReturn(true);
// deep create
// when(adminSession.nodeExists(CreateContentPoolServlet.POOLED_CONTENT_ROOT)).thenReturn(true);
when(adminSession.itemExists(Mockito.anyString())).thenReturn(true);
// Because the pooled content paths are generated by a private method,
// mocking the repository is more problematic than usual. The test
// therefore relies on inside knowledge that there should be three
// calls to deepGetOrCreateNode for each file: one for the pooled content
// node, one for its members node, and one for the manager node.
when(adminSession.getItem(Mockito.anyString()))
.thenAnswer(
new Answer<Item>() {
public Item answer(InvocationOnMock invocation) throws Throwable {
Object[] args = invocation.getArguments();
String path = (String) args[0];
if (path.endsWith(POOLED_CONTENT_MEMBERS_NODE)) {
return membersNode;
} else if (path.endsWith("ieb")) {
return memberNode;
} else {
return parentNode;
}
}
});
when(parentNode.addNode(JCR_CONTENT, NT_RESOURCE)).thenReturn(resourceNode);
when(adminSession.getValueFactory()).thenReturn(valueFactory);
when(valueFactory.createBinary(Mockito.any(InputStream.class))).thenReturn(binary);
// access control utils
accessControlList =
new AccessControlList() {
// Add an "addEntry" method so AccessControlUtil can execute something.
// This method doesn't do anything useful.
@SuppressWarnings("unused")
public boolean addEntry(Principal principal, Privilege[] privileges, boolean isAllow)
throws AccessControlException {
return true;
}
public void removeAccessControlEntry(AccessControlEntry ace)
throws AccessControlException, RepositoryException {}
public AccessControlEntry[] getAccessControlEntries() throws RepositoryException {
return new AccessControlEntry[0];
}
public boolean addAccessControlEntry(Principal principal, Privilege[] privileges)
throws AccessControlException, RepositoryException {
return false;
}
};
when(accessControlManager.privilegeFromName(Mockito.anyString())).thenReturn(allPrivilege);
AccessControlPolicy[] acp = new AccessControlPolicy[] {accessControlList};
when(accessControlManager.getPolicies(Mockito.anyString())).thenReturn(acp);
StringWriter stringWriter = new StringWriter();
when(response.getWriter()).thenReturn(new PrintWriter(stringWriter));
CreateContentPoolServlet cp = new CreateContentPoolServlet();
cp.eventAdmin = eventAdmin;
cp.clusterTrackingService = clusterTrackingService;
cp.sparseRepository = repository;
cp.doPost(request, response);
// Verify that we created all the nodes.
JSONObject jsonObject = new JSONObject(stringWriter.toString());
Assert.assertNotNull(jsonObject.getString("testfilename.pdf"));
Assert.assertNotNull(jsonObject.getString("index.html"));
Assert.assertEquals(2, jsonObject.length());
}