git.mxchange.org Git - addressbook-war.git/blob

   1 /*
   2  * Copyright (C) 2016, 2017 Roland Häder
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU Affero General Public License as
   6  * published by the Free Software Foundation, either version 3 of the
   7  * License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Affero General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Affero General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 package org.mxchange.addressbook.beans.user.activity;
  18
  19 import java.text.MessageFormat;
  20 import java.util.Collections;
  21 import java.util.GregorianCalendar;
  22 import java.util.LinkedHashMap;
  23 import java.util.LinkedList;
  24 import java.util.List;
  25 import java.util.Map;
  26 import javax.annotation.PostConstruct;
  27 import javax.enterprise.context.ApplicationScoped;
  28 import javax.enterprise.event.Observes;
  29 import javax.faces.view.facelets.FaceletException;
  30 import javax.inject.Inject;
  31 import javax.inject.Named;
  32 import javax.naming.Context;
  33 import javax.naming.InitialContext;
  34 import javax.naming.NamingException;
  35 import org.mxchange.addressbook.beans.BaseAddressbookController;
  36 import org.mxchange.addressbook.beans.helper.AddressbookWebRequestHelperController;
  37 import org.mxchange.jusercore.events.user.add.ObservableAdminAddedUserEvent;
  38 import org.mxchange.jusercore.events.user.created.ObservableCreatedUserEvent;
  39 import org.mxchange.jusercore.events.user.delete.ObservableAdminDeletedUserEvent;
  40 import org.mxchange.jusercore.events.user.linked.ObservableAdminLinkedUserEvent;
  41 import org.mxchange.jusercore.events.user.locked.ObservableAdminLockedUserEvent;
  42 import org.mxchange.jusercore.events.user.unlocked.ObservableAdminUnlockedUserEvent;
  43 import org.mxchange.jusercore.events.user.update.ObservableAdminUpdatedUserDataEvent;
  44 import org.mxchange.jusercore.events.user.update.ObservableUpdatedUserPersonalDataEvent;
  45 import org.mxchange.jusercore.model.user.User;
  46 import org.mxchange.jusercore.model.user.activity.LogableUserActivity;
  47 import org.mxchange.jusercore.model.user.activity.UserActivityLog;
  48 import org.mxchange.jusercore.model.user.activity.UserActivityLogSessionBeanRemote;
  49 import org.mxchange.jusercore.model.user.activity.comparator.UserActivityLogTimestampComparator;
  50 import org.mxchange.juserlogincore.events.confirmation.ObservableUserConfirmedAccountEvent;
  51 import org.mxchange.juserlogincore.events.login.ObservableUserLoggedInEvent;
  52 import org.mxchange.juserlogincore.events.logout.ObservableUserLogoutEvent;
  53 import org.mxchange.juserlogincore.events.registration.ObservableUserRegisteredEvent;
  54 import org.mxchange.juserlogincore.events.resendlink.ObservableUserResendLinkAccountEvent;
  55 import org.mxchange.juserlogincore.events.user.password_change.ObservableUpdatedUserPasswordEvent;
  56
  57 /**
  58  * A controller (bean) for user activity log
  59  * <p>
  60  * @author Roland Häder<roland@mxchange.org>
  61  */
  62 @Named ("userActivityController")
  63 @ApplicationScoped
  64 public class AddressbookUserActivityWebApplicationBean extends BaseAddressbookController implements AddressbookUserActivityWebApplicationController {
  65
  66         /**
  67          * Serial number
  68          */
  69         private static final long serialVersionUID = 192_586_376_717_856_904L;
  70
  71         /**
  72          * Bean helper
  73          */
  74         @Inject
  75         private AddressbookWebRequestHelperController beanHelper;
  76
  77         /**
  78          * User instance
  79          */
  80         private User user;
  81
  82         /**
  83          * EJB for user activity log
  84          */
  85         private UserActivityLogSessionBeanRemote userActivityBean;
  86
  87         /**
  88          * "Cache" for activity log per user
  89          */
  90         private final Map<User, List<LogableUserActivity>> usersActivity;
  91
  92         /**
  93          * Default constructor
  94          */
  95         @SuppressWarnings ("CollectionWithoutInitialCapacity")
  96         public AddressbookUserActivityWebApplicationBean () {
  97                 // Try to get EJB instance
  98                 try {
  99                         // Get initial context
 100                         Context context = new InitialContext();
 101
 102                         // Try to lookup
 103                         this.userActivityBean = (UserActivityLogSessionBeanRemote) context.lookup("java:global/addressbook-ejb/userActivity!org.mxchange.jusercore.model.user.activity.UserActivityLogSessionBeanRemote"); //NOI18N
 104                 } catch (final NamingException e) {
 105                         // Throw again
 106                         throw new FaceletException(e);
 107                 }
 108
 109                 // Init cache
 110                 this.usersActivity = new LinkedHashMap<>();
 111         }
 112
 113         /**
 114          * Adds user activity entry with given type
 115          * <p>
 116          * @param user User instance
 117          * @param activityType Activity type
 118          */
 119         private void addUserActivity (final User user, final String activityType) {
 120                 // Better re-validate
 121                 if (null == user) {
 122                         // Throw NPE
 123                         throw new NullPointerException("user is null"); //NOI18N
 124                 } else if (user.getUserId() == null) {
 125                         // Throw again
 126                         throw new NullPointerException("user.userId is null"); //NOI18N
 127                 } else if (user.getUserId() < 1) {
 128                         // Invalid id number
 129                         throw new IllegalArgumentException(MessageFormat.format("user.userId={0} is not valid", user.getUserId())); //NOI18N
 130                 } else if (null == activityType) {
 131                         // Throw NPE again
 132                         throw new NullPointerException("activityType is null"); //NOI18N
 133                 } else if (activityType.isEmpty()) {
 134                         // Is empty
 135                         throw new IllegalArgumentException("activityType is empty"); //NOI18N
 136                 }
 137
 138                 // Create new activity object
 139                 LogableUserActivity userActivity = new UserActivityLog(activityType, user, new GregorianCalendar(), this.determinePrincipalName());
 140
 141                 // Call bean to add it
 142                 this.userActivityBean.addUserActivityLog(userActivity);
 143
 144                 // Add to cache, too
 145                 this.addUserActivityToCache(userActivity);
 146         }
 147
 148         /**
 149          * Adds user activity log with type and message
 150          * <p>
 151          * @param user User instance
 152          * @param activityType Activity type
 153          * @param message Activity message
 154          */
 155         private void addUserActivity (final User user, final String activityType, final String message) {
 156                 // Better re-validate
 157                 if (null == user) {
 158                         // Throw NPE
 159                         throw new NullPointerException("user is null"); //NOI18N
 160                 } else if (user.getUserId() == null) {
 161                         // Throw again
 162                         throw new NullPointerException("user.userId is null"); //NOI18N
 163                 } else if (user.getUserId() < 1) {
 164                         // Invalid id number
 165                         throw new IllegalArgumentException(MessageFormat.format("user.userId={0} is not valid", user.getUserId())); //NOI18N
 166                 } else if (null == activityType) {
 167                         // Throw NPE again
 168                         throw new NullPointerException("activityType is null"); //NOI18N
 169                 } else if (activityType.isEmpty()) {
 170                         // Is empty
 171                         throw new IllegalArgumentException("activityType is empty"); //NOI18N
 172                 } else if (null == message) {
 173                         // Throw NPE again
 174                         throw new NullPointerException("message is null"); //NOI18N
 175                 } else if (message.isEmpty()) {
 176                         // Is empty
 177                         throw new IllegalArgumentException("message is empty"); //NOI18N
 178                 }
 179
 180                 // Create new activity object
 181                 LogableUserActivity userActivity = new UserActivityLog(message, activityType, user, new GregorianCalendar(), this.determinePrincipalName());
 182
 183                 // Call bean to add it
 184                 this.userActivityBean.addUserActivityLog(userActivity);
 185
 186                 // Add to cache, too
 187                 this.addUserActivityToCache(userActivity);
 188         }
 189
 190         /**
 191          * Event observer for newly added users by administrator
 192          * <p>
 193          * @param event Event being fired
 194          */
 195         public void afterAdminAddedUserEvent (@Observes final ObservableAdminAddedUserEvent event) {
 196                 // event should not be null
 197                 if (null == event) {
 198                         // Throw NPE
 199                         throw new NullPointerException("event is null"); //NOI18N
 200                 } else if (event.getAddedUser() == null) {
 201                         // Throw NPE again
 202                         throw new NullPointerException("event.addedUser is null"); //NOI18N
 203                 } else if (event.getAddedUser().getUserId() == null) {
 204                         // userId is null
 205                         throw new NullPointerException("event.addedUser.userId is null"); //NOI18N
 206                 } else if (event.getAddedUser().getUserId() < 1) {
 207                         // Not avalid id
 208                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getAddedUser(), event.getAddedUser().getUserId())); //NOI18N
 209                 }
 210
 211                 // Update user list
 212                 this.addUserActivity(event.getAddedUser(), "ADMIN_ADDED_USER_ACCOUNT"); //NOI18N
 213         }
 214
 215         /**
 216          * Event observer for deleted user accounts (by administrator)
 217          * <p>
 218          * @param event Event being fired
 219          */
 220         public void afterAdminDeletedUserEvent (@Observes final ObservableAdminDeletedUserEvent event) {
 221                 // event should not be null
 222                 if (null == event) {
 223                         // Throw NPE
 224                         throw new NullPointerException("event is null"); //NOI18N
 225                 } else if (event.getDeletedUser() == null) {
 226                         // Throw NPE again
 227                         throw new NullPointerException("event.deletedUser is null"); //NOI18N
 228                 } else if (event.getDeletedUser().getUserId() == null) {
 229                         // userId is null
 230                         throw new NullPointerException("event.deletedUser.userId is null"); //NOI18N
 231                 } else if (event.getDeletedUser().getUserId() < 1) {
 232                         // Not avalid id
 233                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getDeletedUser(), event.getDeletedUser().getUserId())); //NOI18N
 234                 }
 235
 236                 // Add acitivity
 237                 this.addUserActivity(event.getDeletedUser(), "ADMIN_DELETED_USER_ACCOUNT", event.getUserDeleteReason()); //NOI18N
 238         }
 239
 240         /**
 241          * Event observer for linked users with existing contact data
 242          * <p>
 243          * @param event Event being fired
 244          */
 245         public void afterAdminLinkedUserEvent (@Observes final ObservableAdminLinkedUserEvent event) {
 246                 // event should not be null
 247                 if (null == event) {
 248                         // Throw NPE
 249                         throw new NullPointerException("event is null"); //NOI18N
 250                 } else if (event.getLinkedUser() == null) {
 251                         // Throw NPE again
 252                         throw new NullPointerException("event.linkedUser is null"); //NOI18N
 253                 } else if (event.getLinkedUser().getUserId() == null) {
 254                         // userId is null
 255                         throw new NullPointerException("event.linkedUser.userId is null"); //NOI18N
 256                 } else if (event.getLinkedUser().getUserId() < 1) {
 257                         // Not avalid id
 258                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getLinkedUser(), event.getLinkedUser().getUserId())); //NOI18N
 259                 }
 260
 261                 // Update user list
 262                 this.addUserActivity(event.getLinkedUser(), "ADMIN_LINKED_USER_ACCOUNT"); //NOI18N
 263         }
 264
 265         /**
 266          * Event observer for locked users
 267          * <p>
 268          * @param event Event being fired
 269          */
 270         public void afterAdminLockedUserEvent (@Observes final ObservableAdminLockedUserEvent event) {
 271                 // event should not be null
 272                 if (null == event) {
 273                         // Throw NPE
 274                         throw new NullPointerException("event is null"); //NOI18N
 275                 } else if (event.getLockedUser() == null) {
 276                         // Throw NPE again
 277                         throw new NullPointerException("event.lockedUser is null"); //NOI18N
 278                 } else if (event.getLockedUser().getUserId() == null) {
 279                         // userId is null
 280                         throw new NullPointerException("event.lockedUser.userId is null"); //NOI18N
 281                 } else if (event.getLockedUser().getUserId() < 1) {
 282                         // Not avalid id
 283                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getLockedUser(), event.getLockedUser().getUserId())); //NOI18N
 284                 }
 285
 286                 // Update user list
 287                 this.addUserActivity(event.getLockedUser(), "ADMIN_LOCKED_USER_ACCOUNT", event.getLockedUser().getUserLastLockedReason()); //NOI18N
 288         }
 289
 290         /**
 291          * Event observer for unlocked users
 292          * <p>
 293          * @param event Event being fired
 294          */
 295         public void afterAdminUnlockedUserEvent (@Observes final ObservableAdminUnlockedUserEvent event) {
 296                 // event should not be null
 297                 if (null == event) {
 298                         // Throw NPE
 299                         throw new NullPointerException("event is null"); //NOI18N
 300                 } else if (event.getUnlockedUser() == null) {
 301                         // Throw NPE again
 302                         throw new NullPointerException("event.unlockedUser is null"); //NOI18N
 303                 } else if (event.getUnlockedUser().getUserId() == null) {
 304                         // userId is null
 305                         throw new NullPointerException("event.unlockedUser.userId is null"); //NOI18N
 306                 } else if (event.getUnlockedUser().getUserId() < 1) {
 307                         // Not avalid id
 308                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getUnlockedUser(), event.getUnlockedUser().getUserId())); //NOI18N
 309                 }
 310
 311                 // Update user list
 312                 this.addUserActivity(event.getUnlockedUser(), "ADMIN_UNLOCKED_USER_ACCOUNT"); //NOI18N
 313         }
 314
 315         /**
 316          * Event observer for updated user data by administrator
 317          * <p>
 318          * @param event Event being updated
 319          */
 320         public void afterAdminUpdatedUserDataEvent (@Observes final ObservableAdminUpdatedUserDataEvent event) {
 321                 // event should not be null
 322                 if (null == event) {
 323                         // Throw NPE
 324                         throw new NullPointerException("event is null"); //NOI18N
 325                 } else if (event.getUpdatedUser() == null) {
 326                         // Throw NPE again
 327                         throw new NullPointerException("event.updatedUser is null"); //NOI18N
 328                 } else if (event.getUpdatedUser().getUserId() == null) {
 329                         // userId is null
 330                         throw new NullPointerException("event.updatedUser.userId is null"); //NOI18N
 331                 } else if (event.getUpdatedUser().getUserId() < 1) {
 332                         // Not avalid id
 333                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getUpdatedUser(), event.getUpdatedUser().getUserId())); //NOI18N
 334                 }
 335
 336                 // Update user list
 337                 this.addUserActivity(event.getUpdatedUser(), "ADMIN_UPDATED_USER_PERSONAL_DATA"); //NOI18N
 338         }
 339
 340         /**
 341          * Event observer for when a bean helper has successfully created a user
 342          * instance, means the user exists. If the user does not exist, this event
 343          * should not fire but instead a proper exception must be thrown.
 344          * <p>
 345          * @param event User created event
 346          */
 347         public void afterCreatedUserEvent (@Observes final ObservableCreatedUserEvent event) {
 348                 // Is the instance valid?
 349                 if (null == event) {
 350                         // Throw NPE
 351                         throw new NullPointerException("event is null"); //NOI18N
 352                 } else if (event.getCreatedUser() == null) {
 353                         // Throw NPE again
 354                         throw new NullPointerException("event.createdUser is null"); //NOI18N
 355                 } else if (event.getCreatedUser().getUserId() == null) {
 356                         // Throw NPE again
 357                         throw new NullPointerException("event.createdUser.userId is null"); //NOI18N
 358                 } else if (event.getCreatedUser().getUserId() < 1) {
 359                         // Throw NPE again
 360                         throw new NullPointerException(MessageFormat.format("event.createdUser.userId={0} is not valid", event.getCreatedUser().getUserId())); //NOI18N
 361                 }
 362
 363                 // Set whole user
 364                 this.setUser(event.getCreatedUser());
 365         }
 366
 367         /**
 368          * Event observer when user confirmed account.
 369          * <p>
 370          * @param event Event being fired
 371          */
 372         public void afterUserConfirmedAccountEvent (@Observes final ObservableUserConfirmedAccountEvent event) {
 373                 // event should not be null
 374                 if (null == event) {
 375                         // Throw NPE
 376                         throw new NullPointerException("event is null"); //NOI18N
 377                 } else if (event.getConfirmedUser() == null) {
 378                         // Throw NPE again
 379                         throw new NullPointerException("event.confirmedUser is null"); //NOI18N
 380                 } else if (event.getConfirmedUser().getUserId() == null) {
 381                         // userId is null
 382                         throw new NullPointerException("event.confirmedUser.userId is null"); //NOI18N
 383                 } else if (event.getConfirmedUser().getUserId() < 1) {
 384                         // Not avalid id
 385                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getConfirmedUser(), event.getConfirmedUser().getUserId())); //NOI18N
 386                 }
 387
 388                 // Update user list
 389                 this.addUserActivity(event.getConfirmedUser(), "USER_CONFIRMED_ACCOUNT"); //NOI18N
 390         }
 391
 392         /**
 393          * Event observer for logged-in user
 394          * <p>
 395          * @param event Event being fired
 396          */
 397         public void afterUserLoginEvent (@Observes final ObservableUserLoggedInEvent event) {
 398                 // event should not be null
 399                 if (null == event) {
 400                         // Throw NPE
 401                         throw new NullPointerException("event is null"); //NOI18N
 402                 } else if (event.getLoggedInUser() == null) {
 403                         // Throw NPE again
 404                         throw new NullPointerException("event.registeredUser is null"); //NOI18N
 405                 } else if (event.getLoggedInUser().getUserId() == null) {
 406                         // userId is null
 407                         throw new NullPointerException("event.registeredUser.userId is null"); //NOI18N
 408                 } else if (event.getLoggedInUser().getUserId() < 1) {
 409                         // Not avalid id
 410                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getLoggedInUser(), event.getLoggedInUser().getUserId())); //NOI18N
 411                 }
 412
 413                 // Copy all data to this bean
 414                 this.addUserActivity(event.getLoggedInUser(), "USER_LOGGED_IN"); //NOI18N
 415         }
 416
 417         /**
 418          * Event observer for logged-out user
 419          * <p>
 420          * @param event Event instance
 421          */
 422         public void afterUserLogoutEvent (@Observes final ObservableUserLogoutEvent event) {
 423                 // event should not be null
 424                 if (null == event) {
 425                         // Throw NPE
 426                         throw new NullPointerException("event is null"); //NOI18N
 427                 } else if (event.getLoggedOutUser() == null) {
 428                         // Throw NPE again
 429                         throw new NullPointerException("event.loggedOutUser is null"); //NOI18N
 430                 } else if (event.getLoggedOutUser().getUserId() == null) {
 431                         // userId is null
 432                         throw new NullPointerException("event.loggedOutUser.userId is null"); //NOI18N
 433                 } else if (event.getLoggedOutUser().getUserId() < 1) {
 434                         // Not avalid id
 435                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getLoggedOutUser(), event.getLoggedOutUser().getUserId())); //NOI18N
 436                 }
 437
 438                 // Update user list
 439                 this.addUserActivity(event.getLoggedOutUser(), "USER_LOGGED_OUT"); //NOI18N
 440         }
 441
 442         /**
 443          * Event observer for new user registrations
 444          * <p>
 445          * @param event Event being fired
 446          */
 447         public void afterUserRegistrationEvent (@Observes final ObservableUserRegisteredEvent event) {
 448                 // event should not be null
 449                 if (null == event) {
 450                         // Throw NPE
 451                         throw new NullPointerException("event is null"); //NOI18N
 452                 } else if (event.getRegisteredUser() == null) {
 453                         // Throw NPE again
 454                         throw new NullPointerException("event.registeredUser is null"); //NOI18N
 455                 } else if (event.getRegisteredUser().getUserId() == null) {
 456                         // userId is null
 457                         throw new NullPointerException("event.registeredUser.userId is null"); //NOI18N
 458                 } else if (event.getRegisteredUser().getUserId() < 1) {
 459                         // Not avalid id
 460                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getRegisteredUser(), event.getRegisteredUser().getUserId())); //NOI18N
 461                 }
 462
 463                 // Update user list
 464                 this.addUserActivity(event.getRegisteredUser(), "USER_REGISTERED_NEW_ACCOUNT"); //NOI18N
 465         }
 466
 467         /**
 468          * Event observer for users resending their confirmation link
 469          * <p>
 470          * @param event Event being fired
 471          */
 472         public void afterUserResendConfirmationLinkEvent (@Observes final ObservableUserResendLinkAccountEvent event) {
 473                 // event should not be null
 474                 if (null == event) {
 475                         // Throw NPE
 476                         throw new NullPointerException("event is null"); //NOI18N
 477                 } else if (event.getResendLinkUser() == null) {
 478                         // Throw NPE again
 479                         throw new NullPointerException("event.resendLinkUser is null"); //NOI18N
 480                 } else if (event.getResendLinkUser().getUserId() == null) {
 481                         // userId is null
 482                         throw new NullPointerException("event.resendLinkUser.userId is null"); //NOI18N
 483                 } else if (event.getResendLinkUser().getUserId() < 1) {
 484                         // Not avalid id
 485                         throw new IllegalArgumentException(MessageFormat.format("userId of user={0} is not valid: {1}", event.getResendLinkUser(), event.getResendLinkUser().getUserId())); //NOI18N
 486                 }
 487
 488                 // Copy all data to this bean
 489                 this.addUserActivity(event.getResendLinkUser(), "USER_RESEND_CONFIRMATION_LINK"); //NOI18N
 490         }
 491
 492         /**
 493          * Method being call after user's password has been updated (and history
 494          * entry has been created).
 495          * <p>
 496          * @param event Event being observed
 497          */
 498         public void afterUserUpdatedPasswordEvent (@Observes final ObservableUpdatedUserPasswordEvent event) {
 499                 // Check parameter
 500                 if (null == event) {
 501                         // Throw NPE
 502                         throw new NullPointerException("event is null"); //NOI18N
 503                 } else if (event.getPasswordHistory() == null) {
 504                         // Throw NPE again
 505                         throw new NullPointerException("event.passwordHistory is null"); //NOI18N
 506                 } else if (event.getPasswordHistory().getUserPasswordHistoryId() == null) {
 507                         // ... and again
 508                         throw new NullPointerException("event.passwordHistory.userPasswordHistoryId is null"); //NOI18N
 509                 } else if (event.getPasswordHistory().getUserPasswordHistoryId() < 1) {
 510                         // Invalid value
 511                         throw new IllegalArgumentException(MessageFormat.format("event.passwordHistory.userPasswordHistoryId={0} is in valid", event.getPasswordHistory().getUserPasswordHistoryId())); //NOI18N
 512                 }
 513
 514                 // Update user list
 515                 this.addUserActivity(event.getPasswordHistory().getUserPasswordHistoryUser(), "USER_UPDATED_PASSWORD"); //NOI18N
 516         }
 517
 518         /**
 519          * Listens to fired event when user updated personal data
 520          * <p>
 521          * @param event Event being fired
 522          */
 523         public void afterUserUpdatedPersonalDataEvent (@Observes final ObservableUpdatedUserPersonalDataEvent event) {
 524                 // Check parameter
 525                 if (null == event) {
 526                         // Throw NPE
 527                         throw new NullPointerException("event is null"); //NOI18N
 528                 } else if (event.getUpdatedUser() == null) {
 529                         // Throw NPE again
 530                         throw new NullPointerException("event.updatedUser is null"); //NOI18N
 531                 } else if (event.getUpdatedUser().getUserId() == null) {
 532                         // ... and again
 533                         throw new NullPointerException("event.updatedUser.userId is null"); //NOI18N
 534                 } else if (event.getUpdatedUser().getUserId() < 1) {
 535                         // Invalid value
 536                         throw new IllegalArgumentException(MessageFormat.format("event.updatedUser.userId={0} is in valid", event.getUpdatedUser().getUserId())); //NOI18N
 537                 }
 538
 539                 // Update user list
 540                 this.addUserActivity(event.getUpdatedUser(), "USER_UPDATED_PERSONAL_DATA"); //NOI18N
 541         }
 542
 543         /**
 544          * Expands given activity type into a i18n string for administrators
 545          * <p>
 546          * @param activityType Activity type
 547          * <p>
 548          * @return Expanded i18n string
 549          */
 550         public String expandAdminActivityType (final String activityType) {
 551                 // Is it valid?
 552                 if (null == activityType) {
 553                         // Throw NPE
 554                         throw new NullPointerException("activityType is null"); //NOI18N
 555                 } else if (activityType.isEmpty()) {
 556                         // Is empty
 557                         throw new IllegalArgumentException("activityType is empty"); //NOI18N
 558                 }
 559
 560                 // Expand it
 561                 return "ADMIN_ACTIVITY_" + activityType; //NOI18N
 562         }
 563
 564         /**
 565          * Expands given activity type into a i18n string for users
 566          * <p>
 567          * @param activityType Activity type
 568          * <p>
 569          * @return Expanded i18n string
 570          */
 571         public String expandUserActivityType (final String activityType) {
 572                 // Is it valid?
 573                 if (null == activityType) {
 574                         // Throw NPE
 575                         throw new NullPointerException("activityType is null"); //NOI18N
 576                 } else if (activityType.isEmpty()) {
 577                         // Is empty
 578                         throw new IllegalArgumentException("activityType is empty"); //NOI18N
 579                 }
 580
 581                 // Expand it
 582                 return "USER_ACTIVITY_" + activityType; //NOI18N
 583         }
 584
 585         /**
 586          * Returns a list of in beanHelper set user instance's activity log
 587          * <p>
 588          * @return List of user's activity log
 589          */
 590         public List<LogableUserActivity> fetchCurrentUsersActivityLog () {
 591                 // beanHelper.user should be set and valid
 592                 if (this.getUser() == null) {
 593                         // Is not set
 594                         throw new NullPointerException("this.beanHelper.user is null"); //NOI18N
 595                 } else if (this.getUser().getUserId() == null) {
 596                         // Throw NPE again
 597                         throw new NullPointerException("this.beanHelper.user.userId is null"); //NOI18N
 598                 } else if (this.getUser().getUserId() < 1) {
 599                         // Invalid id number
 600                         throw new IllegalArgumentException(MessageFormat.format("this.beanHelper.user.userId={0} is not valid", this.getUser().getUserId())); //NOI18N
 601                 }
 602
 603                 // Init list
 604                 List<LogableUserActivity> list = new LinkedList<>();
 605
 606                 // Is the user set?
 607                 if (this.usersActivity.containsKey(this.getUser())) {
 608                         // Return it
 609                         list.addAll(this.usersActivity.get(this.getUser()));
 610
 611                         // Sort list and reverse it
 612                         Collections.sort(list, new UserActivityLogTimestampComparator());
 613                         Collections.reverse(list);
 614                 }
 615
 616                 // Return it
 617                 return list;
 618         }
 619
 620         /**
 621          * Getter for user instance
 622          * <p>
 623          * @return User instance
 624          */
 625         public User getUser () {
 626                 return this.user;
 627         }
 628
 629         /**
 630          * Setter for user instance
 631          * <p>
 632          * @param user User instance
 633          */
 634         public void setUser (final User user) {
 635                 this.user = user;
 636         }
 637
 638         /**
 639          * Post-constructor method
 640          */
 641         @PostConstruct
 642         public void init () {
 643                 // Get whole list
 644                 List<LogableUserActivity> list = this.userActivityBean.fetchAllUserActivityLog();
 645
 646                 // Put all in map, per-user
 647                 for (final LogableUserActivity userActivity : list) {
 648                         // Is the list there?
 649                         if (!this.usersActivity.containsKey(userActivity.getActivityUser())) {
 650                                 // Init list
 651                                 this.usersActivity.put(userActivity.getActivityUser(), new LinkedList<LogableUserActivity>());
 652                         }
 653
 654                         // Add by user instance
 655                         boolean added = this.usersActivity.get(userActivity.getActivityUser()).add(userActivity);
 656
 657                         // Should be added
 658                         assert (added) : "Activity log not added"; //NOI18N
 659                 }
 660         }
 661
 662         /**
 663          * Adds given user activity instance to "cache" (local map)
 664          * <p>
 665          * @param userActivity User activity instance
 666          */
 667         private void addUserActivityToCache (final LogableUserActivity userActivity) {
 668                 // Is the instance valid
 669                 if (null == userActivity) {
 670                         // Throw NPE again
 671                         throw new NullPointerException("userActivity is null");
 672                 } else if (userActivity.getActivityId() instanceof Long) {
 673                         // Is not null
 674                         throw new IllegalArgumentException("userActivity.activityId=" + userActivity.getActivityId() + " is not null");
 675                 } else if (userActivity.getActivityUser() == null) {
 676                         // Throw NPE again
 677                         throw new NullPointerException("userActivity.activityUser is null");
 678                 } else if (userActivity.getActivityUser().getUserId() == null) {
 679                         // Throw it again
 680                         throw new NullPointerException("userActivity.activityUser.userId is null");
 681                 } else if (userActivity.getActivityUser().getUserId() < 1) {
 682                         // Invalid id number
 683                         throw new IllegalArgumentException("userActivity.activityUser.userId=" + userActivity.getActivityUser().getUserId() + " is not valid");
 684                 }
 685
 686                 // Is it there?
 687                 if (!this.usersActivity.containsKey(userActivity.getActivityUser())) {
 688                         // Init it
 689                         this.usersActivity.put(userActivity.getActivityUser(), new LinkedList<LogableUserActivity>());
 690                 }
 691
 692                 // Add activity to log
 693                 this.usersActivity.get(userActivity.getActivityUser()).add(userActivity);
 694         }
 695
 696 }