@Override
  public int compareTo(PasswordTracker passwordTracker) {
    int value = 0;

    if (getUserId() < passwordTracker.getUserId()) {
      value = -1;
    } else if (getUserId() > passwordTracker.getUserId()) {
      value = 1;
    } else {
      value = 0;
    }

    value = value * -1;

    if (value != 0) {
      return value;
    }

    value = DateUtil.compareTo(getCreateDate(), passwordTracker.getCreateDate());

    value = value * -1;

    if (value != 0) {
      return value;
    }

    return 0;
  }
  @Test
  public void testFetchByPrimaryKeyExisting() throws Exception {
    PasswordTracker newPasswordTracker = addPasswordTracker();

    PasswordTracker existingPasswordTracker =
        _persistence.fetchByPrimaryKey(newPasswordTracker.getPrimaryKey());

    Assert.assertEquals(existingPasswordTracker, newPasswordTracker);
  }
Пример #3
0
  @Override
  public PasswordTracker updateImpl(com.liferay.portal.model.PasswordTracker passwordTracker)
      throws SystemException {
    passwordTracker = toUnwrappedModel(passwordTracker);

    boolean isNew = passwordTracker.isNew();

    PasswordTrackerModelImpl passwordTrackerModelImpl = (PasswordTrackerModelImpl) passwordTracker;

    Session session = null;

    try {
      session = openSession();

      if (passwordTracker.isNew()) {
        session.save(passwordTracker);

        passwordTracker.setNew(false);
      } else {
        session.merge(passwordTracker);
      }
    } catch (Exception e) {
      throw processException(e);
    } finally {
      closeSession(session);
    }

    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);

    if (isNew || !PasswordTrackerModelImpl.COLUMN_BITMASK_ENABLED) {
      FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
    } else {
      if ((passwordTrackerModelImpl.getColumnBitmask()
              & FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID.getColumnBitmask())
          != 0) {
        Object[] args = new Object[] {passwordTrackerModelImpl.getOriginalUserId()};

        FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
        FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID, args);

        args = new Object[] {passwordTrackerModelImpl.getUserId()};

        FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_USERID, args);
        FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID, args);
      }
    }

    EntityCacheUtil.putResult(
        PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
        PasswordTrackerImpl.class,
        passwordTracker.getPrimaryKey(),
        passwordTracker);

    passwordTracker.resetOriginalValues();

    return passwordTracker;
  }
Пример #4
0
  /**
   * Creates a new password tracker with the primary key. Does not add the password tracker to the
   * database.
   *
   * @param passwordTrackerId the primary key for the new password tracker
   * @return the new password tracker
   */
  @Override
  public PasswordTracker create(long passwordTrackerId) {
    PasswordTracker passwordTracker = new PasswordTrackerImpl();

    passwordTracker.setNew(true);
    passwordTracker.setPrimaryKey(passwordTrackerId);

    return passwordTracker;
  }
  @Test
  public void testCreate() throws Exception {
    long pk = RandomTestUtil.nextLong();

    PasswordTracker passwordTracker = _persistence.create(pk);

    Assert.assertNotNull(passwordTracker);

    Assert.assertEquals(passwordTracker.getPrimaryKey(), pk);
  }
Пример #6
0
  /**
   * Caches the password tracker in the entity cache if it is enabled.
   *
   * @param passwordTracker the password tracker
   */
  @Override
  public void cacheResult(PasswordTracker passwordTracker) {
    EntityCacheUtil.putResult(
        PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
        PasswordTrackerImpl.class,
        passwordTracker.getPrimaryKey(),
        passwordTracker);

    passwordTracker.resetOriginalValues();
  }
  @Test
  public void testRemove() throws Exception {
    PasswordTracker newPasswordTracker = addPasswordTracker();

    _persistence.remove(newPasswordTracker);

    PasswordTracker existingPasswordTracker =
        _persistence.fetchByPrimaryKey(newPasswordTracker.getPrimaryKey());

    Assert.assertNull(existingPasswordTracker);
  }
Пример #8
0
  @Override
  public void clearCache(List<PasswordTracker> passwordTrackers) {
    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);

    for (PasswordTracker passwordTracker : passwordTrackers) {
      EntityCacheUtil.removeResult(
          PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
          PasswordTrackerImpl.class,
          passwordTracker.getPrimaryKey());
    }
  }
Пример #9
0
 /**
  * Caches the password trackers in the entity cache if it is enabled.
  *
  * @param passwordTrackers the password trackers
  */
 @Override
 public void cacheResult(List<PasswordTracker> passwordTrackers) {
   for (PasswordTracker passwordTracker : passwordTrackers) {
     if (EntityCacheUtil.getResult(
             PasswordTrackerModelImpl.ENTITY_CACHE_ENABLED,
             PasswordTrackerImpl.class,
             passwordTracker.getPrimaryKey())
         == null) {
       cacheResult(passwordTracker);
     } else {
       passwordTracker.resetOriginalValues();
     }
   }
 }
  @Test
  public void testFetchByPrimaryKeysWithOnePrimaryKey() throws Exception {
    PasswordTracker newPasswordTracker = addPasswordTracker();

    Set<Serializable> primaryKeys = new HashSet<Serializable>();

    primaryKeys.add(newPasswordTracker.getPrimaryKey());

    Map<Serializable, PasswordTracker> passwordTrackers =
        _persistence.fetchByPrimaryKeys(primaryKeys);

    Assert.assertEquals(1, passwordTrackers.size());
    Assert.assertEquals(
        newPasswordTracker, passwordTrackers.get(newPasswordTracker.getPrimaryKey()));
  }
Пример #11
0
  @Override
  protected PasswordTracker removeImpl(PasswordTracker passwordTracker) throws SystemException {
    passwordTracker = toUnwrappedModel(passwordTracker);

    Session session = null;

    try {
      session = openSession();

      if (!session.contains(passwordTracker)) {
        passwordTracker =
            (PasswordTracker)
                session.get(PasswordTrackerImpl.class, passwordTracker.getPrimaryKeyObj());
      }

      if (passwordTracker != null) {
        session.delete(passwordTracker);
      }
    } catch (Exception e) {
      throw processException(e);
    } finally {
      closeSession(session);
    }

    if (passwordTracker != null) {
      clearCache(passwordTracker);
    }

    return passwordTracker;
  }
  @Test
  public void testDynamicQueryByPrimaryKeyExisting() throws Exception {
    PasswordTracker newPasswordTracker = addPasswordTracker();

    DynamicQuery dynamicQuery =
        DynamicQueryFactoryUtil.forClass(PasswordTracker.class, _dynamicQueryClassLoader);

    dynamicQuery.add(
        RestrictionsFactoryUtil.eq("passwordTrackerId", newPasswordTracker.getPasswordTrackerId()));

    List<PasswordTracker> result = _persistence.findWithDynamicQuery(dynamicQuery);

    Assert.assertEquals(1, result.size());

    PasswordTracker existingPasswordTracker = result.get(0);

    Assert.assertEquals(existingPasswordTracker, newPasswordTracker);
  }
  @Test
  public void testFetchByPrimaryKeysWithMultiplePrimaryKeysWhereSomePrimaryKeysExist()
      throws Exception {
    PasswordTracker newPasswordTracker = addPasswordTracker();

    long pk = RandomTestUtil.nextLong();

    Set<Serializable> primaryKeys = new HashSet<Serializable>();

    primaryKeys.add(newPasswordTracker.getPrimaryKey());
    primaryKeys.add(pk);

    Map<Serializable, PasswordTracker> passwordTrackers =
        _persistence.fetchByPrimaryKeys(primaryKeys);

    Assert.assertEquals(1, passwordTrackers.size());
    Assert.assertEquals(
        newPasswordTracker, passwordTrackers.get(newPasswordTracker.getPrimaryKey()));
  }
  @Override
  public boolean equals(Object obj) {
    if (this == obj) {
      return true;
    }

    if (!(obj instanceof PasswordTracker)) {
      return false;
    }

    PasswordTracker passwordTracker = (PasswordTracker) obj;

    long primaryKey = passwordTracker.getPrimaryKey();

    if (getPrimaryKey() == primaryKey) {
      return true;
    } else {
      return false;
    }
  }
  @Test
  public void testDynamicQueryByProjectionExisting() throws Exception {
    PasswordTracker newPasswordTracker = addPasswordTracker();

    DynamicQuery dynamicQuery =
        DynamicQueryFactoryUtil.forClass(PasswordTracker.class, _dynamicQueryClassLoader);

    dynamicQuery.setProjection(ProjectionFactoryUtil.property("passwordTrackerId"));

    Object newPasswordTrackerId = newPasswordTracker.getPasswordTrackerId();

    dynamicQuery.add(
        RestrictionsFactoryUtil.in("passwordTrackerId", new Object[] {newPasswordTrackerId}));

    List<Object> result = _persistence.findWithDynamicQuery(dynamicQuery);

    Assert.assertEquals(1, result.size());

    Object existingPasswordTrackerId = result.get(0);

    Assert.assertEquals(existingPasswordTrackerId, newPasswordTrackerId);
  }
Пример #16
0
  protected PasswordTracker toUnwrappedModel(PasswordTracker passwordTracker) {
    if (passwordTracker instanceof PasswordTrackerImpl) {
      return passwordTracker;
    }

    PasswordTrackerImpl passwordTrackerImpl = new PasswordTrackerImpl();

    passwordTrackerImpl.setNew(passwordTracker.isNew());
    passwordTrackerImpl.setPrimaryKey(passwordTracker.getPrimaryKey());

    passwordTrackerImpl.setPasswordTrackerId(passwordTracker.getPasswordTrackerId());
    passwordTrackerImpl.setUserId(passwordTracker.getUserId());
    passwordTrackerImpl.setCreateDate(passwordTracker.getCreateDate());
    passwordTrackerImpl.setPassword(passwordTracker.getPassword());

    return passwordTrackerImpl;
  }
  protected PasswordTracker addPasswordTracker() throws Exception {
    long pk = RandomTestUtil.nextLong();

    PasswordTracker passwordTracker = _persistence.create(pk);

    passwordTracker.setMvccVersion(RandomTestUtil.nextLong());

    passwordTracker.setCompanyId(RandomTestUtil.nextLong());

    passwordTracker.setUserId(RandomTestUtil.nextLong());

    passwordTracker.setCreateDate(RandomTestUtil.nextDate());

    passwordTracker.setPassword(RandomTestUtil.randomString());

    _passwordTrackers.add(_persistence.update(passwordTracker));

    return passwordTracker;
  }
  @Test
  public void testFetchByPrimaryKeysWithMultiplePrimaryKeysWhereAllPrimaryKeysExist()
      throws Exception {
    PasswordTracker newPasswordTracker1 = addPasswordTracker();
    PasswordTracker newPasswordTracker2 = addPasswordTracker();

    Set<Serializable> primaryKeys = new HashSet<Serializable>();

    primaryKeys.add(newPasswordTracker1.getPrimaryKey());
    primaryKeys.add(newPasswordTracker2.getPrimaryKey());

    Map<Serializable, PasswordTracker> passwordTrackers =
        _persistence.fetchByPrimaryKeys(primaryKeys);

    Assert.assertEquals(2, passwordTrackers.size());
    Assert.assertEquals(
        newPasswordTracker1, passwordTrackers.get(newPasswordTracker1.getPrimaryKey()));
    Assert.assertEquals(
        newPasswordTracker2, passwordTrackers.get(newPasswordTracker2.getPrimaryKey()));
  }
  @Test
  public void testUpdateExisting() throws Exception {
    long pk = RandomTestUtil.nextLong();

    PasswordTracker newPasswordTracker = _persistence.create(pk);

    newPasswordTracker.setMvccVersion(RandomTestUtil.nextLong());

    newPasswordTracker.setCompanyId(RandomTestUtil.nextLong());

    newPasswordTracker.setUserId(RandomTestUtil.nextLong());

    newPasswordTracker.setCreateDate(RandomTestUtil.nextDate());

    newPasswordTracker.setPassword(RandomTestUtil.randomString());

    _passwordTrackers.add(_persistence.update(newPasswordTracker));

    PasswordTracker existingPasswordTracker =
        _persistence.findByPrimaryKey(newPasswordTracker.getPrimaryKey());

    Assert.assertEquals(
        existingPasswordTracker.getMvccVersion(), newPasswordTracker.getMvccVersion());
    Assert.assertEquals(
        existingPasswordTracker.getPasswordTrackerId(), newPasswordTracker.getPasswordTrackerId());
    Assert.assertEquals(existingPasswordTracker.getCompanyId(), newPasswordTracker.getCompanyId());
    Assert.assertEquals(existingPasswordTracker.getUserId(), newPasswordTracker.getUserId());
    Assert.assertEquals(
        Time.getShortTimestamp(existingPasswordTracker.getCreateDate()),
        Time.getShortTimestamp(newPasswordTracker.getCreateDate()));
    Assert.assertEquals(existingPasswordTracker.getPassword(), newPasswordTracker.getPassword());
  }
Пример #20
0
  /**
   * Returns an ordered range of all the password trackers where userId = &#63;.
   *
   * <p>Useful when paginating results. Returns a maximum of <code>end - start</code> instances.
   * <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result
   * set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start
   * </code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}
   * will return the full result set. If <code>orderByComparator</code> is specified, then the query
   * will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and
   * pagination is required (<code>start</code> and <code>end</code> are not {@link
   * com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default
   * ORDER BY logic from {@link com.liferay.portal.model.impl.PasswordTrackerModelImpl}. If both
   * <code>orderByComparator</code> and pagination are absent, for performance reasons, the query
   * will not have an ORDER BY clause and the returned result set will be sorted on by the primary
   * key in an ascending order.
   *
   * @param userId the user ID
   * @param start the lower bound of the range of password trackers
   * @param end the upper bound of the range of password trackers (not inclusive)
   * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
   * @return the ordered range of matching password trackers
   * @throws SystemException if a system exception occurred
   */
  @Override
  public List<PasswordTracker> findByUserId(
      long userId, int start, int end, OrderByComparator orderByComparator) throws SystemException {
    boolean pagination = true;
    FinderPath finderPath = null;
    Object[] finderArgs = null;

    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) && (orderByComparator == null)) {
      pagination = false;
      finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_USERID;
      finderArgs = new Object[] {userId};
    } else {
      finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_USERID;
      finderArgs = new Object[] {userId, start, end, orderByComparator};
    }

    List<PasswordTracker> list =
        (List<PasswordTracker>) FinderCacheUtil.getResult(finderPath, finderArgs, this);

    if ((list != null) && !list.isEmpty()) {
      for (PasswordTracker passwordTracker : list) {
        if ((userId != passwordTracker.getUserId())) {
          list = null;

          break;
        }
      }
    }

    if (list == null) {
      StringBundler query = null;

      if (orderByComparator != null) {
        query = new StringBundler(3 + (orderByComparator.getOrderByFields().length * 3));
      } else {
        query = new StringBundler(3);
      }

      query.append(_SQL_SELECT_PASSWORDTRACKER_WHERE);

      query.append(_FINDER_COLUMN_USERID_USERID_2);

      if (orderByComparator != null) {
        appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS, orderByComparator);
      } else if (pagination) {
        query.append(PasswordTrackerModelImpl.ORDER_BY_JPQL);
      }

      String sql = query.toString();

      Session session = null;

      try {
        session = openSession();

        Query q = session.createQuery(sql);

        QueryPos qPos = QueryPos.getInstance(q);

        qPos.add(userId);

        if (!pagination) {
          list = (List<PasswordTracker>) QueryUtil.list(q, getDialect(), start, end, false);

          Collections.sort(list);

          list = new UnmodifiableList<PasswordTracker>(list);
        } else {
          list = (List<PasswordTracker>) QueryUtil.list(q, getDialect(), start, end);
        }

        cacheResult(list);

        FinderCacheUtil.putResult(finderPath, finderArgs, list);
      } catch (Exception e) {
        FinderCacheUtil.removeResult(finderPath, finderArgs);

        throw processException(e);
      } finally {
        closeSession(session);
      }
    }

    return list;
  }