@Component(
immediate = true,
property = {"javax.portlet.name=" + AdminNotificationPortletKeys.ADMIN_NOTIFICATION},
service = UserNotificationDefinition.class
)
public class AdminLoginUserNotificationDefinition extends UserNotificationDefinition {
public AdminLoginUserNotificationDefinition() {
// pass in our portlet key, 0 for a class name id (don't care about it), the notification type (not really), and
// finally the resource bundle key for the message the user sees.
super(AdminNotificationPortletKeys.ADMIN_NOTIFICATION, 0,
AdminNotificationType.NOTIFICATION_TYPE_ADMINISTRATOR_LOGIN,
"receive-a-notification-when-an-admin-logs-in");
// add a notification type for each sort of notification that we want to support.
addUserNotificationDeliveryType(
new UserNotificationDeliveryType(
"email", UserNotificationDeliveryConstants.TYPE_EMAIL, true, true));
addUserNotificationDeliveryType(
new UserNotificationDeliveryType(
"website", UserNotificationDeliveryConstants.TYPE_WEBSITE, true, true));
}
}
@Component(
immediate = true,
property = {"javax.portlet.name=" + AdminNotificationPortletKeys.ADMIN_NOTIFICATION},
service = UserNotificationHandler.class
)
public class AdminLoginUserNotificationHandler extends BaseUserNotificationHandler {
/**
* AdminLoginUserNotificationHandler: Constructor class.
*/
public AdminLoginUserNotificationHandler() {
setPortletId(AdminNotificationPortletKeys.ADMIN_NOTIFICATION);
}
@Override
protected String getBody(UserNotificationEvent userNotificationEvent, ServiceContext serviceContext) throws Exception {
String username = LanguageUtil.get(serviceContext.getLocale(), _UKNOWN_USER_KEY);
// okay, we need to get the user for the event
User user = _userLocalService.fetchUser(userNotificationEvent.getUserId());
if (Validator.isNotNull(user)) {
// get the company the user belongs to.
Company company = _companyLocalService.fetchCompany(user.getCompanyId());
// based on the company auth type, find the user name to display.
// so we'll get screen name or email address or whatever they're using to log in.
if (Validator.isNotNull(company)) {
if (company.getAuthType().equals(CompanyConstants.AUTH_TYPE_EA)) {
username = user.getEmailAddress();
} else if (company.getAuthType().equals(CompanyConstants.AUTH_TYPE_SN)) {
username = user.getScreenName();
} else if (company.getAuthType().equals(CompanyConstants.AUTH_TYPE_ID)) {
username = String.valueOf(user.getUserId());
}
}
}
// we'll be stashing the client address in the payload of the event, so let's extract it here.
JSONObject jsonObject = JSONFactoryUtil.createJSONObject(
userNotificationEvent.getPayload());
String fromHost = jsonObject.getString(Constants.FROM_HOST);
// fetch our strings via the language bundle.
String title = LanguageUtil.get(serviceContext.getLocale(), _TITLE_KEY);
String body = LanguageUtil.format(serviceContext.getLocale(), _BODY_KEY, new Object[] {username, fromHost});
// build the html using our template.
String html = StringUtil.replace(_BODY_TEMPLATE, _BODY_REPLACEMENTS, new String[] {title, body});
return html;
}
@Reference(unbind = "-")
protected void setUserLocalService(final UserLocalService userLocalService) {
_userLocalService = userLocalService;
}
@Reference(unbind = "-")
protected void setCompanyLocalService(final CompanyLocalService companyLocalService) {
_companyLocalService = companyLocalService;
}
private UserLocalService _userLocalService;
private CompanyLocalService _companyLocalService;
private static final String _TITLE_KEY = "title.admin.login";
private static final String _BODY_KEY = "body.admin.login";
private static final String _UKNOWN_USER_KEY = "unknown.user";
private static final String _BODY_TEMPLATE = "[$TITLE$][$BODY$]"; private static final String[] _BODY_REPLACEMENTS = new String[] {"[$TITLE$]", "[$BODY$]"};
private static final Log _log = LogFactoryUtil.getLog(AdminLoginUserNotificationHandler.class); }
@Component(
immediate = true, property = {"key=login.events.post"},
service = LifecycleAction.class
)
public class AdminLoginNotificationEventSender implements LifecycleAction {
@Override
public void processLifecycleEvent(LifecycleEvent lifecycleEvent)
throws ActionException {
// get the request associated with the event
HttpServletRequest request = lifecycleEvent.getRequest();
// get the user associated with the event
User user = null;
try {
user = PortalUtil.getUser(request);
} catch (PortalException e) {
// failed to get the user, just ignore this
}
if (user == null) {
// failed to get a valid user, just return.
return;
}
// We have the user, but are they an admin?
PermissionChecker permissionChecker = null;
try {
permissionChecker = PermissionCheckerFactoryUtil.create(user);
} catch (Exception e) {
// ignore the exception
}
if (permissionChecker == null) {
// failed to get a permission checker
return;
}
// If the permission checker indicates the user is not omniadmin, nothing to report.
if (! permissionChecker.isOmniadmin()) {
return;
}
// this user is an administrator, need to issue the event
ServiceContext serviceContext = null;
try {
// create a service context for the call
serviceContext = ServiceContextFactory.getInstance(request);
// note that when you're behind an LB, the remote host may be the address
// for the LB instead of the remote client. In these cases the LB will often
// add a request header with a special key that holds the remote client host
// so you'd want to use that if it is available.
String fromHost = request.getRemoteHost();
// notify subscribers
notifySubscribers(user.getUserId(), fromHost, user.getCompanyId(), serviceContext);
} catch (PortalException e) {
// ignored
}
}
protected void notifySubscribers(long userId, String fromHost, long companyId, ServiceContext serviceContext)
throws PortalException {
// so all of this stuff should normally come from some kind of configuration.
// As this is just an example, we're using a lot of hard coded values and portal-ext.properties values.
String entryTitle = "Admin User Login";
String fromName = PropsUtil.get(Constants.EMAIL_FROM_NAME);
String fromAddress = GetterUtil.getString(PropsUtil.get(Constants.EMAIL_FROM_ADDRESS), PropsUtil.get(PropsKeys.ADMIN_EMAIL_FROM_ADDRESS));
LocalizedValuesMap subjectLocalizedValuesMap = new LocalizedValuesMap();
LocalizedValuesMap bodyLocalizedValuesMap = new LocalizedValuesMap();
subjectLocalizedValuesMap.put(Locale.ENGLISH, "Administrator Login");
bodyLocalizedValuesMap.put(Locale.ENGLISH, "Adminstrator has logged in.");
AdminLoginSubscriptionSender subscriptionSender =
new AdminLoginSubscriptionSender();
subscriptionSender.setFromHost(fromHost);
subscriptionSender.setClassPK(0);
subscriptionSender.setClassName(AdminNotificationPortlet.class.getName());
subscriptionSender.setCompanyId(companyId);
subscriptionSender.setCurrentUserId(userId);
subscriptionSender.setEntryTitle(entryTitle);
subscriptionSender.setFrom(fromAddress, fromName);
subscriptionSender.setHtmlFormat(true);
int notificationType = AdminNotificationType.NOTIFICATION_TYPE_ADMINISTRATOR_LOGIN;
subscriptionSender.setNotificationType(notificationType);
String portletId = PortletProviderUtil.getPortletId(AdminNotificationPortletKeys.ADMIN_NOTIFICATION, PortletProvider.Action.VIEW);
subscriptionSender.setPortletId(portletId);
subscriptionSender.setReplyToAddress(fromAddress);
subscriptionSender.setServiceContext(serviceContext);
subscriptionSender.addPersistedSubscribers(
AdminNotificationPortlet.class.getName(), 0);
subscriptionSender.flushNotificationsAsync();
}
}
public class AdminLoginSubscriptionSender extends SubscriptionSender {
private static final long serialVersionUID = -7152698157653361441L;
protected void populateNotificationEventJSONObject(
JSONObject notificationEventJSONObject) {
super.populateNotificationEventJSONObject(notificationEventJSONObject);
notificationEventJSONObject.put(Constants.FROM_HOST, _fromHost);
}
@Override
protected boolean hasPermission(Subscription subscription, String className, long classPK, User user) throws Exception {
return true;
}
@Override
protected boolean hasPermission(Subscription subscription, User user) throws Exception {
return true;
}
@Override
protected void sendNotification(User user) throws Exception {
// remove the super classes filtering of not notifying user who is self.
// makes sense in most cases, but we want a notification of admin login so
// we know when never any admin logs in from anywhere at any time.
// will be a pain if we get notified because of our own login, but we want to
// know if some hacker gets our admin credentials and logs in and it's not really us.
sendEmailNotification(user);
sendUserNotification(user);
}
public void setFromHost(String fromHost) {
this._fromHost = fromHost;
}
private String _fromHost;
}
