/**
* Returns all query parameters.
*
* @return parameters
*/
public Map<String, String[]> params() {
final Map<String, String[]> params = new HashMap<String, String[]>();
final Map<?, ?> map = req.getParameterMap();
for (final Entry<?, ?> s : map.entrySet()) {
final String key = s.getKey().toString();
final String[] vals =
s.getValue() instanceof String[]
? (String[]) s.getValue()
: new String[] {s.getValue().toString()};
params.put(key, vals);
}
return params;
}
// Get parameter map either directly from an Servlet 2.4 compliant implementation
// or by looking it up explictely (thanks to codewax for the patch)
private Map<String, String[]> getParameterMap(HttpServletRequest pReq) {
try {
// Servlet 2.4 API
return pReq.getParameterMap();
} catch (UnsupportedOperationException exp) {
// Thrown by 'pseudo' 2.4 Servlet API implementations which fake a 2.4 API
// As a service for the parameter map is build up explicitely
Map<String, String[]> ret = new HashMap<String, String[]>();
Enumeration params = pReq.getParameterNames();
while (params.hasMoreElements()) {
String param = (String) params.nextElement();
ret.put(param, pReq.getParameterValues(param));
}
return ret;
}
}
@Override
public void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
resp.setContentType("text/html");
resp.getWriter().println("<html><body>");
String keyname = req.getParameter("keyname");
String value = req.getParameter("value");
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
// Using the synchronous cache.
MemcacheService syncCache = MemcacheServiceFactory.getMemcacheService();
syncCache.setErrorHandler(ErrorHandlers.getConsistentLogAndContinue(Level.INFO));
// display every element of kind TaskData for /datastore
if (req.getParameterMap().isEmpty()) {
// querying from datastore
resp.getWriter().println("<h3>Datastore results:</h3>");
List<String> listOfKeys = new ArrayList<String>();
Query q = new Query("TaskData");
PreparedQuery pq = datastore.prepare(q);
for (Entity result : pq.asIterable()) {
String datastore_key = result.getKey().getName();
String taskData_value = (String) result.getProperty("value");
Date taskData_date = (Date) result.getProperty("date");
resp.getWriter()
.println(
"<p>keyname = "
+ datastore_key
+ " value = "
+ taskData_value
+ " date = "
+ taskData_date.toString()
+ "</p>");
listOfKeys.add(datastore_key);
}
// check which of the keys exist in memcache
String memcache_value;
resp.getWriter().println("<h3>Memcache results:</h3>");
for (String datastore_key : listOfKeys) {
memcache_value = (String) syncCache.get(datastore_key);
if (memcache_value != null) {
// String decoded = new String(memcache_value, "UTF-8");
resp.getWriter()
.println("<p>keyname = " + datastore_key + " value = " + memcache_value + "</p>");
}
}
}
// display element of kind TaskData with key=keyname
else if (keyname != null && value == null) {
// first check in the cache
String memcache_value = (String) syncCache.get(keyname); // Read from cache.
// Get value from datastore
Key task_key = KeyFactory.createKey("TaskData", keyname);
try {
Entity tne = datastore.get(task_key);
if (memcache_value == null) {
resp.getWriter().println("<h2>Datastore</h2>");
} else {
resp.getWriter().println("<h2>Both</h2>");
}
} catch (EntityNotFoundException e) {
resp.getWriter().println("<h2>Neither</h2>");
}
}
// store element of kind TaskData with key=keyname and value=value
else if (keyname != null && value != null) {
Entity tne = new Entity("TaskData", keyname);
tne.setProperty("value", value);
tne.setProperty("date", new Date());
datastore.put(tne);
syncCache.put(keyname, value); // Populate cache.
resp.getWriter()
.println("<h2>Stored " + keyname + " and " + value + " in Datastore and Memcache</h2>");
} else {
resp.getWriter().println("<h2>You entered wrong query parameters</h2>");
}
/*
Entity tne = new Entity("TaskData", "Person");
alice.setProperty("gender", "female");
alice.setProperty("age", 20);
*/
resp.getWriter().println("</body></html>");
}
public Map getParameterMap() {
return request.getParameterMap();
}
// authentication response
public Account verifyResponse(HttpServletRequest httpReq) throws ServletException {
try {
// extract the parameters from the authentication response
// (which comes in as a HTTP request from the OpenID provider)
ParameterList response = new ParameterList(httpReq.getParameterMap());
// retrieve the previously stored discovery information
DiscoveryInformation discovered =
(DiscoveryInformation) httpReq.getSession().getAttribute("openid-disc");
// extract the receiving URL from the HTTP request
StringBuffer receivingURL = httpReq.getRequestURL();
String queryString = httpReq.getQueryString();
if (queryString != null && queryString.length() > 0)
receivingURL.append("?").append(httpReq.getQueryString());
// verify the response; ConsumerManager needs to be the same
// (static) instance used to place the authentication request
VerificationResult verification =
manager.verify(receivingURL.toString(), response, discovered);
// examine the verification result and extract the verified
// identifier
Identifier verified = verification.getVerifiedId();
if (verified != null) {
// success
String accountName = AccountImpl.escape(verified.getIdentifier());
AbstractAccount account = (AbstractAccount) OpenIDRealm.instance.getAccount(accountName);
if (account == null) {
Database db = OpenIDRealm.instance.getDatabase();
org.exist.security.Subject currentSubject = db.getSubject();
try {
db.setSubject(db.getSecurityManager().getSystemSubject());
// XXX: set OpenID group by default
account =
(AbstractAccount)
OpenIDRealm.instance.addAccount(
new UserAider(OpenIDRealm.instance.getId(), accountName));
} finally {
db.setSubject(currentSubject);
}
}
org.exist.security.Subject principal = new SubjectAccreditedImpl(account, verified);
AuthSuccess authSuccess = (AuthSuccess) verification.getAuthResponse();
authSuccess.getExtensions();
if (authSuccess.hasExtension(SRegMessage.OPENID_NS_SREG)) {
MessageExtension ext = authSuccess.getExtension(SRegMessage.OPENID_NS_SREG);
if (ext instanceof SRegResponse) {
SRegResponse sregResp = (SRegResponse) ext;
for (Iterator iter = sregResp.getAttributeNames().iterator(); iter.hasNext(); ) {
String name = (String) iter.next();
if (LOG.isDebugEnabled()) LOG.debug(name + " : " + sregResp.getParameterValue(name));
principal.setMetadataValue(
AXSchemaType.valueOfNamespace(name), sregResp.getParameterValue(name));
}
}
}
if (authSuccess.hasExtension(AxMessage.OPENID_NS_AX)) {
FetchResponse fetchResp =
(FetchResponse) authSuccess.getExtension(AxMessage.OPENID_NS_AX);
List aliases = fetchResp.getAttributeAliases();
for (Iterator iter = aliases.iterator(); iter.hasNext(); ) {
String alias = (String) iter.next();
List values = fetchResp.getAttributeValues(alias);
if (values.size() > 0) {
if (LOG.isDebugEnabled()) LOG.debug(alias + " : " + values.get(0));
principal.setMetadataValue(AXSchemaType.valueOfAlias(alias), (String) values.get(0));
}
}
}
// update metadata
Database db = OpenIDRealm.instance.getDatabase();
org.exist.security.Subject currentSubject = db.getSubject();
try {
db.setSubject(db.getSecurityManager().getSystemSubject());
OpenIDRealm.instance.updateAccount(principal);
} finally {
db.setSubject(currentSubject);
}
OpenIDUtility.registerUser(principal);
return principal;
}
} catch (OpenIDException e) {
LOG.error(e);
} catch (ConfigurationException e) {
LOG.error(e);
} catch (PermissionDeniedException e) {
LOG.error(e);
} catch (EXistException e) {
LOG.error(e);
}
return null;
}