public static String readPersonId() {
String personId = null;
try {
FacesContext context = FacesContext.getCurrentInstance();
IWContext iwContext = IWContext.getIWContext(context);
personId = iwContext.getCurrentUser().getPersonalID();
} catch (Throwable ex) {
log.warn("Unable to read Personal Id from IWContext", ex);
}
return personId == null ? EhealthConstants.DEFAULT_PERSON_ID : personId;
}
public Collection<Phone> getPhones() {
IWContext iwc = getIwc();
if (!iwc.isLoggedOn()) {
return Collections.emptyList();
}
User user = iwc.getCurrentUser();
@SuppressWarnings("unchecked")
Collection<Phone> phones = user.getPhones();
if (ListUtil.isEmpty(phones)) {
return Collections.emptyList();
}
return phones;
}
public Collection<Email> getEmails() {
IWContext iwc = getIwc();
if (!iwc.isLoggedOn()) {
return Collections.emptyList();
}
User user = iwc.getCurrentUser();
@SuppressWarnings("unchecked")
Collection<Email> emails = user.getEmails();
if (ListUtil.isEmpty(emails)) {
return Collections.emptyList();
}
return emails;
}
protected User getCurrentUser() {
User user = null;
try {
LoginSession loginSession = ELUtil.getInstance().getBean(LoginSession.class);
user = loginSession.getUser();
} catch (Exception e) {
LOGGER.log(Level.WARNING, "Error getting current user");
}
if (user == null) {
IWContext iwc = CoreUtil.getIWContext();
user = iwc == null ? null : iwc.isLoggedOn() ? iwc.getCurrentUser() : null;
}
return user;
}
public void main(IWContext iwc) {
if (!iwc.isLoggedOn()) {
return;
}
this.setResourceBundle(getResourceBundle(iwc));
this.user = iwc.getCurrentUser();
try {
int action = parseAction(iwc);
switch (action) {
case ACTION_VIEW_FORM:
viewPreferencesForm(iwc);
break;
case ACTION_FORM_SUBMIT:
updatePreferences(iwc);
break;
case ACTION_CANCEL:
viewPreferencesForm(iwc);
break;
}
} catch (Exception e) {
super.add(new ExceptionWrapper(e, this));
}
}
/**
* @param user2
* @return
* @throws RemoteException
*/
private boolean authorizedByBankID(IWContext iwc) throws RemoteException {
return noVerificationForBankLogins && getUserBusiness(iwc).hasBankLogin(iwc.getCurrentUser());
}
@SuppressWarnings("unchecked")
protected void processRequest(HttpServletRequest req, HttpServletResponse resp, boolean isPost)
throws ServletException, IOException {
ServerManager manager = getServerManager();
IWMainApplication iwma = IWMainApplication.getIWMainApplication(req);
// extract the parameters from the request
ParameterList requestParameters = new ParameterList(req.getParameterMap());
OpenIDServerBean serverBean = ELUtil.getInstance().getBean("openIDServerBean");
ParameterList sessionStoredParameterList = serverBean.getParameterList();
if (sessionStoredParameterList != null) {
if (!requestParameters.hasParameter(OpenIDConstants.PARAMETER_OPENID_MODE)) {
sessionStoredParameterList.addParams(requestParameters);
requestParameters = sessionStoredParameterList;
}
}
String mode =
requestParameters.hasParameter(OpenIDConstants.PARAMETER_OPENID_MODE)
? requestParameters.getParameterValue(OpenIDConstants.PARAMETER_OPENID_MODE)
: null;
String realm =
requestParameters.hasParameter(OpenIDConstants.PARAMETER_REALM)
? requestParameters.getParameterValue(OpenIDConstants.PARAMETER_REALM)
: null;
if (realm != null) {
serverBean.setReturnUrl(realm);
realm = getRealmName(realm);
serverBean.setRealm(realm);
}
Message response;
String responseText = null;
try {
if (OpenIDConstants.PARAMETER_ASSOCIATE.equals(mode)) {
// --- process an association request ---
response = manager.associationResponse(requestParameters);
responseText = response.keyValueFormEncoding();
} else if (OpenIDConstants.PARAMETER_CHECKID_SETUP.equals(mode)
|| OpenIDConstants.PARAMETER_CHECKID_IMMEDIATE.equals(mode)) {
IWContext iwc = new IWContext(req, resp, getServletContext());
boolean goToLogin = doRedirectToLoginPage(manager, requestParameters, iwc, realm);
if (!goToLogin) {
serverBean.setParameterList(null);
serverBean.setServerUrl(null);
serverBean.setDoRedirect(null);
serverBean.setUsername(null);
// interact with the user and obtain data needed to continue
User user = iwc.getCurrentUser();
String userSelectedClaimedId = getUserSelectedClaimedId(iwc, user);
// --- process an authentication request ---
AuthRequest authReq =
AuthRequest.createAuthRequest(requestParameters, manager.getRealmVerifier());
storeRequestedAttributesToSession(iwc, authReq);
Boolean authenticatedAndApproved = isAuthenticatedAndApproved(iwc, user, authReq);
String opLocalId = null;
// if the user chose a different claimed_id than the one in request
if (userSelectedClaimedId != null
&& !userSelectedClaimedId.equals(authReq.getClaimed())) {
opLocalId = userSelectedClaimedId;
}
response =
manager.authResponse(
requestParameters,
opLocalId,
userSelectedClaimedId,
authenticatedAndApproved.booleanValue(),
false); // Sign after we added extensions.
if (response instanceof DirectError) {
directResponse(resp, response.keyValueFormEncoding());
return;
} else if (response instanceof AuthFailure) {
redirectToAuthorisationPage(req, resp, requestParameters, serverBean);
return;
} else {
String[] extensionsToSign = prepareResponse(serverBean, response, iwc, user, authReq);
boolean signExtensions =
iwma.getSettings().getBoolean(OpenIDConstants.PROPERTY_SIGN_EXTENSIONS, false);
AuthSuccess success = (AuthSuccess) response;
if (signExtensions) {
success.setSignExtensions(extensionsToSign);
}
// Sign the auth success message.
// This is required as AuthSuccess.buildSignedList has a `todo' tag now.
manager.sign(success);
// caller will need to decide which of the following to use:
// option1: GET HTTP-redirect to the return_to URL
// cleanUpBeforeReturning(iwc, loginExpireHandle);
// Clean up before returning
serverBean.invalidate();
getDAO().createLogEntry(user.getUniqueId(), realm, "");
resp.sendRedirect(response.getDestinationUrl(true));
return;
// option2: HTML FORM Redirection
// RequestDispatcher dispatcher =
// getServletContext().getRequestDispatcher("formredirection.jsp");
// httpReq.setAttribute("parameterMap", response.getParameterMap());
// httpReq.setAttribute("destinationUrl", response.getDestinationUrl(false));
// dispatcher.forward(request, response);
// return null;
}
} else {
redirectToLoginPage(req, resp, requestParameters, serverBean, manager);
return;
}
} else if (OpenIDConstants.PARAMETER_CHECK_AUTHENTICATION.equals(mode)) {
// --- processing a verification request ---
response = manager.verify(requestParameters);
responseText = response.keyValueFormEncoding();
} else {
// --- error response ---
response = DirectError.createDirectError("Unknown request");
responseText = response.keyValueFormEncoding();
serverBean.invalidate();
}
} catch (MessageException me) {
me.printStackTrace();
responseText = me.getMessage();
serverBean.invalidate();
} catch (AssociationException ae) {
ae.printStackTrace();
responseText = ae.getMessage();
serverBean.invalidate();
} catch (ServerException se) {
se.printStackTrace();
responseText = se.getMessage();
serverBean.invalidate();
}
// return the result to the user
directResponse(resp, responseText);
}
@SuppressWarnings("unchecked")
private void storeRequestedAttributesToSession(IWContext iwc, AuthRequest authReq) {
if (authReq.hasExtension(AxMessage.OPENID_NS_AX)) {
MessageExtension ext;
try {
ext = authReq.getExtension(AxMessage.OPENID_NS_AX);
if (ext instanceof FetchRequest) {
FetchRequest fetchReq = (FetchRequest) ext;
OpenIDServerBean serverBean = ELUtil.getInstance().getBean("openIDServerBean");
Map<String, String> allAttributes = (Map<String, String>) fetchReq.getAttributes();
Map<String, String> required = (Map<String, String>) fetchReq.getAttributes(true);
List<AuthorizedAttribute> allAttributesList = new ArrayList<AuthorizedAttribute>();
List<AuthorizedAttribute> requiredAttributesList = new ArrayList<AuthorizedAttribute>();
List<AuthorizedAttribute> optionalAttributesList = new ArrayList<AuthorizedAttribute>();
String realm = serverBean.getRealm();
for (String alias : allAttributes.keySet()) {
ExchangeAttribute attribute =
getDAO().getExchangeAttribute(alias, allAttributes.get(alias));
if (attribute != null) {
User user = iwc.getCurrentUser();
AuthorizedAttribute aattr =
getDAO().getAuthorizedAttributes(user.getUniqueId(), realm, attribute);
if (aattr == null) {
aattr = new AuthorizedAttribute();
aattr.setExchangeAttribute(attribute);
aattr.setRealm(realm);
aattr.setUserUUID(user.getUniqueId());
aattr.setIsAllowed(true);
}
allAttributesList.add(aattr);
if (required.containsKey(alias) && attribute.getType().equals(required.get(alias))) {
requiredAttributesList.add(aattr);
} else {
optionalAttributesList.add(aattr);
}
} else {
LOGGER.warning(
"Requesting unknown exchange attribute: "
+ alias
+ " : "
+ allAttributes.get(alias));
// throw new UnsupportedOperationException("Requesting unknown exchange attribute.");
}
}
serverBean.setRequestedAttributes(allAttributesList);
serverBean.setRequiredAttributes(requiredAttributesList);
serverBean.setOptionalAttributes(optionalAttributesList);
return;
} else /*if (ext instanceof StoreRequest)*/ {
// TODO implement?
throw new UnsupportedOperationException("TODO");
}
} catch (MessageException e) {
e.printStackTrace();
}
}
if (authReq.hasExtension(SRegMessage.OPENID_NS_SREG11)) {
try {
MessageExtension ext = authReq.getExtension(SRegMessage.OPENID_NS_SREG11);
if (ext instanceof SRegRequest) {
SRegRequest sregReq = (SRegRequest) ext;
List<String> all = sregReq.getAttributes();
List<String> required = sregReq.getAttributes(true);
List<String> optional = sregReq.getAttributes(false);
List<AuthorizedAttribute> allAttributesList = new ArrayList<AuthorizedAttribute>();
List<AuthorizedAttribute> requiredAttributesList = new ArrayList<AuthorizedAttribute>();
List<AuthorizedAttribute> optionalAttributesList = new ArrayList<AuthorizedAttribute>();
OpenIDServerBean serverBean = ELUtil.getInstance().getBean("openIDServerBean");
String realm = serverBean.getRealm();
User user = iwc.getCurrentUser();
for (String alias : all) {
ExchangeAttribute attribute = getDAO().getExchangeAttribute(alias);
if (attribute != null) {
AuthorizedAttribute aattr =
getDAO().getAuthorizedAttributes(user.getUniqueId(), realm, attribute);
if (aattr == null) {
aattr = new AuthorizedAttribute();
aattr.setExchangeAttribute(attribute);
aattr.setRealm(realm);
aattr.setUserUUID(user.getUniqueId());
aattr.setIsAllowed(true);
}
allAttributesList.add(aattr);
if (required.contains(alias)) {
requiredAttributesList.add(aattr);
}
if (optional.contains(alias)) {
optionalAttributesList.add(aattr);
}
}
}
serverBean.setRequestedAttributes(allAttributesList);
serverBean.setRequiredAttributes(requiredAttributesList);
serverBean.setOptionalAttributes(optionalAttributesList);
return;
}
} catch (MessageException e) {
e.printStackTrace();
}
}
}