src/java/org/mxchange/pizzaapplication/beans/user/activity/PizzaUserActivityWebRequestBean.java

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