예제 #1
0
  @Override
  @Transactional
  public UserProfile setAlerts(
      String userAuthId, List<String> monthlyAlerts, List<String> weeklyAlerts) {
    UserProfile user = getUserByAuthId(userAuthId);

    log.debug(
        "updating alerts for user: {}; Montly alerts: {}; weekly alerts: {}",
        new Object[] {
          user.getDisplayName(),
          StringUtils.join(monthlyAlerts, ","),
          StringUtils.join(weeklyAlerts, ",")
        });
    List<String> allAlerts;

    if (monthlyAlerts != null && weeklyAlerts != null) {
      allAlerts = new ArrayList<String>(monthlyAlerts.size() + weeklyAlerts.size());
      allAlerts.addAll(getAlertsList(monthlyAlerts, UserProfile.MONTHLY_ALERT_SUFFIX));
      allAlerts.addAll(getAlertsList(weeklyAlerts, UserProfile.WEEKLY_ALERT_SUFFIX));
    } else if (monthlyAlerts != null) {
      allAlerts = new ArrayList<String>(monthlyAlerts.size());
      allAlerts.addAll(getAlertsList(monthlyAlerts, UserProfile.MONTHLY_ALERT_SUFFIX));
    } else if (weeklyAlerts != null) {
      allAlerts = new ArrayList<String>(weeklyAlerts.size());
      allAlerts.addAll(getAlertsList(weeklyAlerts, UserProfile.WEEKLY_ALERT_SUFFIX));
    } else {
      allAlerts = new ArrayList<String>(0);
    }
    user.setAlertsList(allAlerts);
    hibernateTemplate.update(user);
    return user;
  }
예제 #2
0
  /**
   * Save the user's search
   *
   * @return
   */
  @Transactional(rollbackFor = {Throwable.class})
  @SuppressWarnings("unchecked")
  public String saveSearch() {
    final UserProfile user = getCurrentUser();

    if (user == null) {
      log.info("User is null for saving search");
      addActionError("You must be logged in");

      return ERROR;
    }

    // Make sure the user is authenticated, is this redundant?
    this.permissionsService.checkLogin(user.getAuthId());

    if (searchName == null || searchName.length() == 0) {
      addActionError("Search name must be specified.");
      return INPUT;
    }

    List<SavedSearchView> savedSearchViewList =
        userService.getSavedSearches(this.getCurrentUser().getID());

    for (SavedSearchView savedSearchView : savedSearchViewList) {
      if (savedSearchView.getSearchName().equals(this.searchName)) {
        addActionError("Search name must be unique.");
        return INPUT;
      }
    }

    userService.saveSearch(
        user.getID(), getSearchParameters(), searchName, this.weekly, this.monthly);

    return SUCCESS;
  }
예제 #3
0
 @Override
 @Transactional(rollbackFor = {Throwable.class})
 public UserProfile login(final String authId, final UserLogin loginInfo) {
   log.debug("logging in user with auth id {}", authId);
   UserProfile user = getUserByAuthId(authId);
   if (user != null && this.advancedLogging) {
     loginInfo.setUserProfileID(user.getID());
     hibernateTemplate.save(loginInfo);
   }
   return user;
 }
예제 #4
0
 @Override
 @Transactional(rollbackFor = {Throwable.class})
 public UserProfile updateProfile(final UserProfile userProfile) throws NoSuchUserException {
   // get the user by auth id
   UserProfile existingUser = getUserByAuthId(userProfile.getAuthId());
   if (existingUser == null) {
     throw new NoSuchUserException();
   }
   log.debug("Found a user with authID: {}, updating profile", userProfile.getAuthId());
   copyFields(userProfile, existingUser);
   hibernateTemplate.update(existingUser);
   return existingUser;
 }
예제 #5
0
  /** {@inheritDoc} */
  @Transactional(rollbackFor = {Throwable.class})
  public void deleteSavedSearch(Long userProfileId, Long savedSearchId) {

    UserProfile userProfile =
        (UserProfile)
            DataAccessUtils.uniqueResult(
                hibernateTemplate.findByCriteria(
                    DetachedCriteria.forClass(UserProfile.class)
                        .add(Restrictions.eq("ID", userProfileId))
                        .setFetchMode("savedSearches", FetchMode.JOIN)
                        .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)));
    List<SavedSearch> savedSearches = userProfile.getSavedSearches();
    for (Iterator<SavedSearch> it = savedSearches.iterator(); it.hasNext(); ) {
      SavedSearch savedSearch = it.next();
      if (savedSearch.getID().equals(savedSearchId)) {
        it.remove();
      }
    }
    hibernateTemplate.update(userProfile);
  }
예제 #6
0
  /** {@inheritDoc} */
  @Transactional(rollbackFor = {Throwable.class})
  public List<SavedSearchView> getSavedSearches(Long userProfileId) {
    UserProfile userProfile =
        (UserProfile)
            DataAccessUtils.uniqueResult(
                hibernateTemplate.findByCriteria(
                    DetachedCriteria.forClass(UserProfile.class)
                        .add(Restrictions.eq("ID", userProfileId))
                        .setFetchMode("savedSearches", FetchMode.JOIN)
                        .setResultTransformer(Criteria.DISTINCT_ROOT_ENTITY)));

    List<SavedSearch> searches = userProfile.getSavedSearches();
    List<SavedSearchView> searchViews = new ArrayList<SavedSearchView>(searches.size());

    for (SavedSearch savedSearch : searches) {
      searchViews.add(new SavedSearchView(savedSearch));
    }

    return searchViews;
  }
예제 #7
0
  @Override
  @Transactional
  public UserProfile setSavedSearchAlerts(
      String userAuthId,
      List<String> monthlyAlerts,
      List<String> weeklyAlerts,
      List<String> deleteAlerts) {
    UserProfile user = getUserByAuthId(userAuthId);

    log.debug(
        "updating alerts for user: {}; Montly alerts: {}; weekly alerts: {}; delete alerts: {}",
        new Object[] {
          user.getDisplayName(),
          StringUtils.join(monthlyAlerts, ","),
          StringUtils.join(weeklyAlerts, ","),
          StringUtils.join(deleteAlerts, ",")
        });
    List<SavedSearchView> searches = getSavedSearches(user.getID());

    Set<String> weeklyItems = new HashSet<String>(weeklyAlerts);
    Set<String> monthlyItems = new HashSet<String>(monthlyAlerts);
    Set<String> deleteItems = new HashSet<String>(deleteAlerts);

    for (SavedSearchView savedSearch : searches) {
      // This method should only change user defined search alerts, not journal alerts
      if (savedSearch.getSearchType() == SavedSearchType.USER_DEFINED) {
        String idstr = String.valueOf(savedSearch.getSavedSearchId());
        boolean delete = deleteItems.contains(idstr);
        if (delete) {
          deleteSavedSearch(user.getID(), savedSearch.getSavedSearchId());
        } else {
          boolean weekly = weeklyItems.contains(idstr);
          boolean monthly = monthlyItems.contains(idstr);
          if (weekly != savedSearch.getWeekly() || monthly != savedSearch.getMonthly()) {
            updateSavedSearch(savedSearch.getSavedSearchId(), weekly, monthly);
          }
        }
      }
    }
    return user;
  }
예제 #8
0
  /** {@inheritDoc} */
  @Transactional(rollbackFor = {Throwable.class})
  public UserProfile setFilteredWeeklySearchAlert(
      Long userProfileId, String[] subjects, String journal) {
    SearchParameters searchParameters = new SearchParameters();

    searchParameters.setQuery("*:*");
    searchParameters.setFilterJournals(new String[] {journal});
    searchParameters.setFilterSubjectsDisjunction(subjects);

    // We store the saved search here as JSON instead of serializing the object cuz JSON rocks
    SavedSearchQuery query = saveSearchQuery(searchParameters);

    UserProfile user = getUser(userProfileId);
    SavedSearch newSearch = null;

    // See if a record exists already, we only allow one weekly alert of type JOURNAL_ALERT per
    // journal
    // We key off of the title as it is not user facing
    for (SavedSearch savedSearch : user.getSavedSearches()) {
      if (savedSearch.getSearchType() == SavedSearchType.JOURNAL_ALERT
          && savedSearch.getWeekly()
          && savedSearch.getSearchName().equals(journal)) {
        newSearch = savedSearch;
      }
    }

    if (newSearch == null) {
      newSearch = new SavedSearch(journal, query);
      newSearch.setSearchType(SavedSearchType.JOURNAL_ALERT);
      newSearch.setWeekly(true);
      newSearch.setMonthly(false);
      user.getSavedSearches().add(newSearch);
    } else {
      newSearch.setSearchQuery(query);
    }

    hibernateTemplate.save(user);

    return user;
  }
예제 #9
0
  /** {@inheritDoc} */
  @Transactional(rollbackFor = {Throwable.class})
  @SuppressWarnings("unchecked")
  public void saveSearch(
      Long userProfileId,
      SearchParameters searchParameters,
      String name,
      boolean weekly,
      boolean monthly) {

    UserProfile user = hibernateTemplate.get(UserProfile.class, userProfileId);

    SavedSearchQuery query = saveSearchQuery(searchParameters);

    SavedSearch savedSearch = new SavedSearch(name, query);
    savedSearch.setSearchType(SavedSearchType.USER_DEFINED);
    savedSearch.setWeekly(weekly);
    savedSearch.setMonthly(monthly);

    user.getSavedSearches().add(savedSearch);

    hibernateTemplate.save(user);
  }
예제 #10
0
  /** {@inheritDoc} */
  @Transactional(rollbackFor = {Throwable.class})
  public UserProfile removedFilteredWeeklySearchAlert(Long userProfileId, String journal) {
    UserProfile user = getUser(userProfileId);

    SavedSearch oldSearch = null;

    // We key off of the title as it is not user facing
    for (SavedSearch savedSearch : user.getSavedSearches()) {
      if (savedSearch.getSearchType() == SavedSearchType.JOURNAL_ALERT
          && savedSearch.getWeekly()
          && savedSearch.getSearchName().equals(journal)) {

        oldSearch = savedSearch;
      }
    }

    if (oldSearch != null) {
      user.getSavedSearches().remove(oldSearch);
    }

    hibernateTemplate.save(user);

    return user;
  }
예제 #11
0
  @Override
  @Transactional
  public Long createComment(
      UserProfile user, String articleDoi, String title, String body, String ciStatement) {
    if (articleDoi == null) {
      throw new IllegalArgumentException("Attempted to create comment with null article id");
    } else if (user == null || user.getID() == null) {
      throw new IllegalArgumentException("Attempted to create comment without a creator");
    } else if (body == null || body.isEmpty()) {
      throw new IllegalArgumentException("Attempted to create comment with no body");
    }

    log.debug(
        "Creating comment on article: {}; title: {}; body: {}",
        new Object[] {articleDoi, title, body});
    Long articleID;
    try {
      articleID =
          (Long)
              hibernateTemplate
                  .findByCriteria(
                      DetachedCriteria.forClass(Article.class)
                          .add(Restrictions.eq("doi", articleDoi))
                          .setProjection(Projections.id()))
                  .get(0);
    } catch (IndexOutOfBoundsException e) {
      throw new IllegalArgumentException("Invalid doi: " + articleDoi);
    }

    // generate an annotation uri
    Annotation comment = new Annotation(user, AnnotationType.COMMENT, articleID);
    comment.setAnnotationUri(URIGenerator.generate(comment));
    comment.setTitle(title);
    comment.setBody(body);
    comment.setCompetingInterestBody(ciStatement);

    Long id = (Long) hibernateTemplate.save(comment);

    return id;
  }
예제 #12
0
  @Override
  public UserProfile getProfileForDisplay(UserProfile userProfile, boolean showPrivateFields) {
    UserProfile display = new UserProfile();
    copyFields(userProfile, display);
    if (!showPrivateFields) {
      log.debug("Removing private fields for display on user: {}", userProfile.getDisplayName());
      display.setOrganizationName(null);
      display.setOrganizationType(null);
      display.setPostalAddress(null);
      display.setPositionType(null);
    }

    // escape html in all string fields
    BeanWrapper wrapper = new BeanWrapperImpl(display);
    for (PropertyDescriptor property : wrapper.getPropertyDescriptors()) {
      if (String.class.isAssignableFrom(property.getPropertyType())) {
        String name = property.getName();
        wrapper.setPropertyValue(
            name, TextUtils.escapeHtml((String) wrapper.getPropertyValue(name)));
      }
    }

    return display;
  }
예제 #13
0
  /**
   * Some unit tests delete all users. This is a way to restore them. This logic is very similar to
   * logic in HibernateTestSessionFactory afterPropertiesSet function
   */
  protected void restoreDefaultUsers() {

    try {
      // Create an admin user to test admin functions
      UserRole adminRole = new UserRole("admin");

      Set<UserRole.Permission> perms = new HashSet<UserRole.Permission>();
      perms.add(UserRole.Permission.ACCESS_ADMIN);
      perms.add(UserRole.Permission.INGEST_ARTICLE);
      perms.add(UserRole.Permission.MANAGE_FLAGS);
      perms.add(UserRole.Permission.MANAGE_ANNOTATIONS);
      perms.add(UserRole.Permission.MANAGE_USERS);
      perms.add(UserRole.Permission.MANAGE_ROLES);
      perms.add(UserRole.Permission.MANAGE_JOURNALS);
      perms.add(UserRole.Permission.MANAGE_SEARCH);
      perms.add(UserRole.Permission.MANAGE_CACHES);
      perms.add(UserRole.Permission.CROSS_PUB_ARTICLES);
      perms.add(UserRole.Permission.DELETE_ARTICLES);
      perms.add(UserRole.Permission.VIEW_UNPUBBED_ARTICLES);

      adminRole.setPermissions(perms);
      dummyDataStore.store(adminRole);

      UserProfile admin = new UserProfile();
      admin.setAuthId(BaseTest.DEFAULT_ADMIN_AUTHID);
      admin.setEmail("*****@*****.**");
      admin.setDisplayName("testAdmin");
      admin.setPassword("adminPass");
      admin.setRoles(new HashSet<UserRole>(1));
      admin.getRoles().add(adminRole);
      dummyDataStore.store(admin);

      UserRole editorialRole = new UserRole("editorial");
      perms = new HashSet<UserRole.Permission>();
      perms.add(UserRole.Permission.ACCESS_ADMIN);
      perms.add(UserRole.Permission.VIEW_UNPUBBED_ARTICLES);
      editorialRole.setPermissions(perms);
      dummyDataStore.store(editorialRole);

      UserProfile editorial = new UserProfile();
      editorial.setAuthId(BaseTest.DEFAULT_EDITORIAL_AUTHID);
      editorial.setEmail("*****@*****.**");
      editorial.setDisplayName("editorialAdmin");
      editorial.setPassword("pass");
      editorial.setRoles(new HashSet<UserRole>(1));
      editorial.getRoles().add(editorialRole);
      dummyDataStore.store(editorial);

      UserProfile nonAdmin = new UserProfile();
      nonAdmin.setAuthId(BaseTest.DEFAULT_USER_AUTHID);
      nonAdmin.setEmail("*****@*****.**");
      nonAdmin.setDisplayName("testNonAdmin");
      nonAdmin.setPassword("nonAdminPass");
      dummyDataStore.store(nonAdmin);

    } catch (DataAccessException ex) {
      // must've already inserted the users
    }
  }
예제 #14
0
 /**
  * Copy fields for updating or display. Does <b>not</b> copy some fields:
  *
  * <ul>
  *   <li>ID: never overwrite IDs on hibernate objects
  *   <li>userAccountUri: these don't come down from display layer, so we don't want to overwrite
  *       with null
  *   <li>userProfileUri: these don't come down from display layer, so we don't want to overwrite
  *       with null
  *   <li>roles: don't want to overwrite a user's roles when updating their profile
  * </ul>
  *
  * @param source
  * @param destination
  */
 private void copyFields(UserProfile source, UserProfile destination) {
   destination.setAuthId(source.getAuthId());
   destination.setRealName(source.getRealName());
   destination.setGivenNames(source.getGivenNames());
   destination.setSurname(source.getSurname());
   destination.setTitle(source.getTitle());
   destination.setGender(source.getGender());
   destination.setEmail(source.getEmail());
   destination.setHomePage(source.getHomePage());
   destination.setWeblog(source.getWeblog());
   destination.setPublications(source.getPublications());
   destination.setDisplayName(source.getDisplayName());
   destination.setSuffix(source.getSuffix());
   destination.setPositionType(source.getPositionType());
   destination.setOrganizationName(source.getOrganizationName());
   destination.setOrganizationType(source.getOrganizationType());
   destination.setPostalAddress(source.getPostalAddress());
   destination.setCity(source.getCity());
   destination.setCountry(source.getCountry());
   destination.setBiography(source.getBiography());
   destination.setInterests(source.getInterests());
   destination.setResearchAreas(source.getResearchAreas());
   destination.setOrganizationVisibility(source.getOrganizationVisibility());
   destination.setAlertsJournals(source.getAlertsJournals());
 }