001 /** 002 * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 013 */ 014 015 package com.liferay.portlet.blogs.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.blogs.model.BlogsStatsUser; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the blogs stats user service. This utility wraps {@link BlogsStatsUserPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see BlogsStatsUserPersistence 037 * @see BlogsStatsUserPersistenceImpl 038 * @generated 039 */ 040 public class BlogsStatsUserUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(BlogsStatsUser blogsStatsUser) { 058 getPersistence().clearCache(blogsStatsUser); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<BlogsStatsUser> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<BlogsStatsUser> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<BlogsStatsUser> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 099 */ 100 public static BlogsStatsUser remove(BlogsStatsUser blogsStatsUser) 101 throws SystemException { 102 return getPersistence().remove(blogsStatsUser); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 107 */ 108 public static BlogsStatsUser update(BlogsStatsUser blogsStatsUser, 109 boolean merge) throws SystemException { 110 return getPersistence().update(blogsStatsUser, merge); 111 } 112 113 /** 114 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 115 */ 116 public static BlogsStatsUser update(BlogsStatsUser blogsStatsUser, 117 boolean merge, ServiceContext serviceContext) throws SystemException { 118 return getPersistence().update(blogsStatsUser, merge, serviceContext); 119 } 120 121 /** 122 * Caches the blogs stats user in the entity cache if it is enabled. 123 * 124 * @param blogsStatsUser the blogs stats user to cache 125 */ 126 public static void cacheResult( 127 com.liferay.portlet.blogs.model.BlogsStatsUser blogsStatsUser) { 128 getPersistence().cacheResult(blogsStatsUser); 129 } 130 131 /** 132 * Caches the blogs stats users in the entity cache if it is enabled. 133 * 134 * @param blogsStatsUsers the blogs stats users to cache 135 */ 136 public static void cacheResult( 137 java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> blogsStatsUsers) { 138 getPersistence().cacheResult(blogsStatsUsers); 139 } 140 141 /** 142 * Creates a new blogs stats user with the primary key. Does not add the blogs stats user to the database. 143 * 144 * @param statsUserId the primary key for the new blogs stats user 145 * @return the new blogs stats user 146 */ 147 public static com.liferay.portlet.blogs.model.BlogsStatsUser create( 148 long statsUserId) { 149 return getPersistence().create(statsUserId); 150 } 151 152 /** 153 * Removes the blogs stats user with the primary key from the database. Also notifies the appropriate model listeners. 154 * 155 * @param statsUserId the primary key of the blogs stats user to remove 156 * @return the blogs stats user that was removed 157 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 158 * @throws SystemException if a system exception occurred 159 */ 160 public static com.liferay.portlet.blogs.model.BlogsStatsUser remove( 161 long statsUserId) 162 throws com.liferay.portal.kernel.exception.SystemException, 163 com.liferay.portlet.blogs.NoSuchStatsUserException { 164 return getPersistence().remove(statsUserId); 165 } 166 167 public static com.liferay.portlet.blogs.model.BlogsStatsUser updateImpl( 168 com.liferay.portlet.blogs.model.BlogsStatsUser blogsStatsUser, 169 boolean merge) 170 throws com.liferay.portal.kernel.exception.SystemException { 171 return getPersistence().updateImpl(blogsStatsUser, merge); 172 } 173 174 /** 175 * Finds the blogs stats user with the primary key or throws a {@link com.liferay.portlet.blogs.NoSuchStatsUserException} if it could not be found. 176 * 177 * @param statsUserId the primary key of the blogs stats user to find 178 * @return the blogs stats user 179 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 180 * @throws SystemException if a system exception occurred 181 */ 182 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByPrimaryKey( 183 long statsUserId) 184 throws com.liferay.portal.kernel.exception.SystemException, 185 com.liferay.portlet.blogs.NoSuchStatsUserException { 186 return getPersistence().findByPrimaryKey(statsUserId); 187 } 188 189 /** 190 * Finds the blogs stats user with the primary key or returns <code>null</code> if it could not be found. 191 * 192 * @param statsUserId the primary key of the blogs stats user to find 193 * @return the blogs stats user, or <code>null</code> if a blogs stats user with the primary key could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portlet.blogs.model.BlogsStatsUser fetchByPrimaryKey( 197 long statsUserId) 198 throws com.liferay.portal.kernel.exception.SystemException { 199 return getPersistence().fetchByPrimaryKey(statsUserId); 200 } 201 202 /** 203 * Finds all the blogs stats users where groupId = ?. 204 * 205 * @param groupId the group ID to search with 206 * @return the matching blogs stats users 207 * @throws SystemException if a system exception occurred 208 */ 209 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByGroupId( 210 long groupId) 211 throws com.liferay.portal.kernel.exception.SystemException { 212 return getPersistence().findByGroupId(groupId); 213 } 214 215 /** 216 * Finds a range of all the blogs stats users where groupId = ?. 217 * 218 * <p> 219 * 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. 220 * </p> 221 * 222 * @param groupId the group ID to search with 223 * @param start the lower bound of the range of blogs stats users to return 224 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 225 * @return the range of matching blogs stats users 226 * @throws SystemException if a system exception occurred 227 */ 228 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByGroupId( 229 long groupId, int start, int end) 230 throws com.liferay.portal.kernel.exception.SystemException { 231 return getPersistence().findByGroupId(groupId, start, end); 232 } 233 234 /** 235 * Finds an ordered range of all the blogs stats users where groupId = ?. 236 * 237 * <p> 238 * 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. 239 * </p> 240 * 241 * @param groupId the group ID to search with 242 * @param start the lower bound of the range of blogs stats users to return 243 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 244 * @param orderByComparator the comparator to order the results by 245 * @return the ordered range of matching blogs stats users 246 * @throws SystemException if a system exception occurred 247 */ 248 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByGroupId( 249 long groupId, int start, int end, 250 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 251 throws com.liferay.portal.kernel.exception.SystemException { 252 return getPersistence() 253 .findByGroupId(groupId, start, end, orderByComparator); 254 } 255 256 /** 257 * Finds the first blogs stats user in the ordered set where groupId = ?. 258 * 259 * <p> 260 * 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. 261 * </p> 262 * 263 * @param groupId the group ID to search with 264 * @param orderByComparator the comparator to order the set by 265 * @return the first matching blogs stats user 266 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 267 * @throws SystemException if a system exception occurred 268 */ 269 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByGroupId_First( 270 long groupId, 271 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 272 throws com.liferay.portal.kernel.exception.SystemException, 273 com.liferay.portlet.blogs.NoSuchStatsUserException { 274 return getPersistence().findByGroupId_First(groupId, orderByComparator); 275 } 276 277 /** 278 * Finds the last blogs stats user in the ordered set where groupId = ?. 279 * 280 * <p> 281 * 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. 282 * </p> 283 * 284 * @param groupId the group ID to search with 285 * @param orderByComparator the comparator to order the set by 286 * @return the last matching blogs stats user 287 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 288 * @throws SystemException if a system exception occurred 289 */ 290 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByGroupId_Last( 291 long groupId, 292 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 293 throws com.liferay.portal.kernel.exception.SystemException, 294 com.liferay.portlet.blogs.NoSuchStatsUserException { 295 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 296 } 297 298 /** 299 * Finds the blogs stats users before and after the current blogs stats user in the ordered set where groupId = ?. 300 * 301 * <p> 302 * 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. 303 * </p> 304 * 305 * @param statsUserId the primary key of the current blogs stats user 306 * @param groupId the group ID to search with 307 * @param orderByComparator the comparator to order the set by 308 * @return the previous, current, and next blogs stats user 309 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 310 * @throws SystemException if a system exception occurred 311 */ 312 public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByGroupId_PrevAndNext( 313 long statsUserId, long groupId, 314 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 315 throws com.liferay.portal.kernel.exception.SystemException, 316 com.liferay.portlet.blogs.NoSuchStatsUserException { 317 return getPersistence() 318 .findByGroupId_PrevAndNext(statsUserId, groupId, 319 orderByComparator); 320 } 321 322 /** 323 * Finds all the blogs stats users where userId = ?. 324 * 325 * @param userId the user ID to search with 326 * @return the matching blogs stats users 327 * @throws SystemException if a system exception occurred 328 */ 329 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByUserId( 330 long userId) throws com.liferay.portal.kernel.exception.SystemException { 331 return getPersistence().findByUserId(userId); 332 } 333 334 /** 335 * Finds a range of all the blogs stats users where userId = ?. 336 * 337 * <p> 338 * 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. 339 * </p> 340 * 341 * @param userId the user ID to search with 342 * @param start the lower bound of the range of blogs stats users to return 343 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 344 * @return the range of matching blogs stats users 345 * @throws SystemException if a system exception occurred 346 */ 347 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByUserId( 348 long userId, int start, int end) 349 throws com.liferay.portal.kernel.exception.SystemException { 350 return getPersistence().findByUserId(userId, start, end); 351 } 352 353 /** 354 * Finds an ordered range of all the blogs stats users where userId = ?. 355 * 356 * <p> 357 * 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. 358 * </p> 359 * 360 * @param userId the user ID to search with 361 * @param start the lower bound of the range of blogs stats users to return 362 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 363 * @param orderByComparator the comparator to order the results by 364 * @return the ordered range of matching blogs stats users 365 * @throws SystemException if a system exception occurred 366 */ 367 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByUserId( 368 long userId, int start, int end, 369 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 370 throws com.liferay.portal.kernel.exception.SystemException { 371 return getPersistence() 372 .findByUserId(userId, start, end, orderByComparator); 373 } 374 375 /** 376 * Finds the first blogs stats user in the ordered set where userId = ?. 377 * 378 * <p> 379 * 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. 380 * </p> 381 * 382 * @param userId the user ID to search with 383 * @param orderByComparator the comparator to order the set by 384 * @return the first matching blogs stats user 385 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 386 * @throws SystemException if a system exception occurred 387 */ 388 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByUserId_First( 389 long userId, 390 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 391 throws com.liferay.portal.kernel.exception.SystemException, 392 com.liferay.portlet.blogs.NoSuchStatsUserException { 393 return getPersistence().findByUserId_First(userId, orderByComparator); 394 } 395 396 /** 397 * Finds the last blogs stats user in the ordered set where userId = ?. 398 * 399 * <p> 400 * 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. 401 * </p> 402 * 403 * @param userId the user ID to search with 404 * @param orderByComparator the comparator to order the set by 405 * @return the last matching blogs stats user 406 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 407 * @throws SystemException if a system exception occurred 408 */ 409 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByUserId_Last( 410 long userId, 411 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 412 throws com.liferay.portal.kernel.exception.SystemException, 413 com.liferay.portlet.blogs.NoSuchStatsUserException { 414 return getPersistence().findByUserId_Last(userId, orderByComparator); 415 } 416 417 /** 418 * Finds the blogs stats users before and after the current blogs stats user in the ordered set where userId = ?. 419 * 420 * <p> 421 * 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. 422 * </p> 423 * 424 * @param statsUserId the primary key of the current blogs stats user 425 * @param userId the user ID to search with 426 * @param orderByComparator the comparator to order the set by 427 * @return the previous, current, and next blogs stats user 428 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 429 * @throws SystemException if a system exception occurred 430 */ 431 public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByUserId_PrevAndNext( 432 long statsUserId, long userId, 433 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 434 throws com.liferay.portal.kernel.exception.SystemException, 435 com.liferay.portlet.blogs.NoSuchStatsUserException { 436 return getPersistence() 437 .findByUserId_PrevAndNext(statsUserId, userId, 438 orderByComparator); 439 } 440 441 /** 442 * Finds the blogs stats user where groupId = ? and userId = ? or throws a {@link com.liferay.portlet.blogs.NoSuchStatsUserException} if it could not be found. 443 * 444 * @param groupId the group ID to search with 445 * @param userId the user ID to search with 446 * @return the matching blogs stats user 447 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 448 * @throws SystemException if a system exception occurred 449 */ 450 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByG_U( 451 long groupId, long userId) 452 throws com.liferay.portal.kernel.exception.SystemException, 453 com.liferay.portlet.blogs.NoSuchStatsUserException { 454 return getPersistence().findByG_U(groupId, userId); 455 } 456 457 /** 458 * Finds the blogs stats user where groupId = ? and userId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 459 * 460 * @param groupId the group ID to search with 461 * @param userId the user ID to search with 462 * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 463 * @throws SystemException if a system exception occurred 464 */ 465 public static com.liferay.portlet.blogs.model.BlogsStatsUser fetchByG_U( 466 long groupId, long userId) 467 throws com.liferay.portal.kernel.exception.SystemException { 468 return getPersistence().fetchByG_U(groupId, userId); 469 } 470 471 /** 472 * Finds the blogs stats user where groupId = ? and userId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 473 * 474 * @param groupId the group ID to search with 475 * @param userId the user ID to search with 476 * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 477 * @throws SystemException if a system exception occurred 478 */ 479 public static com.liferay.portlet.blogs.model.BlogsStatsUser fetchByG_U( 480 long groupId, long userId, boolean retrieveFromCache) 481 throws com.liferay.portal.kernel.exception.SystemException { 482 return getPersistence().fetchByG_U(groupId, userId, retrieveFromCache); 483 } 484 485 /** 486 * Finds all the blogs stats users where groupId = ? and entryCount ≠ ?. 487 * 488 * @param groupId the group ID to search with 489 * @param entryCount the entry count to search with 490 * @return the matching blogs stats users 491 * @throws SystemException if a system exception occurred 492 */ 493 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE( 494 long groupId, int entryCount) 495 throws com.liferay.portal.kernel.exception.SystemException { 496 return getPersistence().findByG_NotE(groupId, entryCount); 497 } 498 499 /** 500 * Finds a range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 501 * 502 * <p> 503 * 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. 504 * </p> 505 * 506 * @param groupId the group ID to search with 507 * @param entryCount the entry count to search with 508 * @param start the lower bound of the range of blogs stats users to return 509 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 510 * @return the range of matching blogs stats users 511 * @throws SystemException if a system exception occurred 512 */ 513 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE( 514 long groupId, int entryCount, int start, int end) 515 throws com.liferay.portal.kernel.exception.SystemException { 516 return getPersistence().findByG_NotE(groupId, entryCount, start, end); 517 } 518 519 /** 520 * Finds an ordered range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 521 * 522 * <p> 523 * 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. 524 * </p> 525 * 526 * @param groupId the group ID to search with 527 * @param entryCount the entry count to search with 528 * @param start the lower bound of the range of blogs stats users to return 529 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 530 * @param orderByComparator the comparator to order the results by 531 * @return the ordered range of matching blogs stats users 532 * @throws SystemException if a system exception occurred 533 */ 534 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE( 535 long groupId, int entryCount, int start, int end, 536 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 537 throws com.liferay.portal.kernel.exception.SystemException { 538 return getPersistence() 539 .findByG_NotE(groupId, entryCount, start, end, 540 orderByComparator); 541 } 542 543 /** 544 * Finds the first blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 545 * 546 * <p> 547 * 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. 548 * </p> 549 * 550 * @param groupId the group ID to search with 551 * @param entryCount the entry count to search with 552 * @param orderByComparator the comparator to order the set by 553 * @return the first matching blogs stats user 554 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 555 * @throws SystemException if a system exception occurred 556 */ 557 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByG_NotE_First( 558 long groupId, int entryCount, 559 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 560 throws com.liferay.portal.kernel.exception.SystemException, 561 com.liferay.portlet.blogs.NoSuchStatsUserException { 562 return getPersistence() 563 .findByG_NotE_First(groupId, entryCount, orderByComparator); 564 } 565 566 /** 567 * Finds the last blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 568 * 569 * <p> 570 * 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. 571 * </p> 572 * 573 * @param groupId the group ID to search with 574 * @param entryCount the entry count to search with 575 * @param orderByComparator the comparator to order the set by 576 * @return the last matching blogs stats user 577 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 578 * @throws SystemException if a system exception occurred 579 */ 580 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByG_NotE_Last( 581 long groupId, int entryCount, 582 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 583 throws com.liferay.portal.kernel.exception.SystemException, 584 com.liferay.portlet.blogs.NoSuchStatsUserException { 585 return getPersistence() 586 .findByG_NotE_Last(groupId, entryCount, orderByComparator); 587 } 588 589 /** 590 * Finds the blogs stats users before and after the current blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 591 * 592 * <p> 593 * 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. 594 * </p> 595 * 596 * @param statsUserId the primary key of the current blogs stats user 597 * @param groupId the group ID to search with 598 * @param entryCount the entry count to search with 599 * @param orderByComparator the comparator to order the set by 600 * @return the previous, current, and next blogs stats user 601 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 602 * @throws SystemException if a system exception occurred 603 */ 604 public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByG_NotE_PrevAndNext( 605 long statsUserId, long groupId, int entryCount, 606 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 607 throws com.liferay.portal.kernel.exception.SystemException, 608 com.liferay.portlet.blogs.NoSuchStatsUserException { 609 return getPersistence() 610 .findByG_NotE_PrevAndNext(statsUserId, groupId, entryCount, 611 orderByComparator); 612 } 613 614 /** 615 * Finds all the blogs stats users where companyId = ? and entryCount ≠ ?. 616 * 617 * @param companyId the company ID to search with 618 * @param entryCount the entry count to search with 619 * @return the matching blogs stats users 620 * @throws SystemException if a system exception occurred 621 */ 622 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE( 623 long companyId, int entryCount) 624 throws com.liferay.portal.kernel.exception.SystemException { 625 return getPersistence().findByC_NotE(companyId, entryCount); 626 } 627 628 /** 629 * Finds a range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 630 * 631 * <p> 632 * 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. 633 * </p> 634 * 635 * @param companyId the company ID to search with 636 * @param entryCount the entry count to search with 637 * @param start the lower bound of the range of blogs stats users to return 638 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 639 * @return the range of matching blogs stats users 640 * @throws SystemException if a system exception occurred 641 */ 642 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE( 643 long companyId, int entryCount, int start, int end) 644 throws com.liferay.portal.kernel.exception.SystemException { 645 return getPersistence().findByC_NotE(companyId, entryCount, start, end); 646 } 647 648 /** 649 * Finds an ordered range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 650 * 651 * <p> 652 * 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. 653 * </p> 654 * 655 * @param companyId the company ID to search with 656 * @param entryCount the entry count to search with 657 * @param start the lower bound of the range of blogs stats users to return 658 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 659 * @param orderByComparator the comparator to order the results by 660 * @return the ordered range of matching blogs stats users 661 * @throws SystemException if a system exception occurred 662 */ 663 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE( 664 long companyId, int entryCount, int start, int end, 665 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 666 throws com.liferay.portal.kernel.exception.SystemException { 667 return getPersistence() 668 .findByC_NotE(companyId, entryCount, start, end, 669 orderByComparator); 670 } 671 672 /** 673 * Finds the first blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 674 * 675 * <p> 676 * 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. 677 * </p> 678 * 679 * @param companyId the company ID to search with 680 * @param entryCount the entry count to search with 681 * @param orderByComparator the comparator to order the set by 682 * @return the first matching blogs stats user 683 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 684 * @throws SystemException if a system exception occurred 685 */ 686 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByC_NotE_First( 687 long companyId, int entryCount, 688 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 689 throws com.liferay.portal.kernel.exception.SystemException, 690 com.liferay.portlet.blogs.NoSuchStatsUserException { 691 return getPersistence() 692 .findByC_NotE_First(companyId, entryCount, orderByComparator); 693 } 694 695 /** 696 * Finds the last blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 697 * 698 * <p> 699 * 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. 700 * </p> 701 * 702 * @param companyId the company ID to search with 703 * @param entryCount the entry count to search with 704 * @param orderByComparator the comparator to order the set by 705 * @return the last matching blogs stats user 706 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 707 * @throws SystemException if a system exception occurred 708 */ 709 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByC_NotE_Last( 710 long companyId, int entryCount, 711 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 712 throws com.liferay.portal.kernel.exception.SystemException, 713 com.liferay.portlet.blogs.NoSuchStatsUserException { 714 return getPersistence() 715 .findByC_NotE_Last(companyId, entryCount, orderByComparator); 716 } 717 718 /** 719 * Finds the blogs stats users before and after the current blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 720 * 721 * <p> 722 * 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. 723 * </p> 724 * 725 * @param statsUserId the primary key of the current blogs stats user 726 * @param companyId the company ID to search with 727 * @param entryCount the entry count to search with 728 * @param orderByComparator the comparator to order the set by 729 * @return the previous, current, and next blogs stats user 730 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 731 * @throws SystemException if a system exception occurred 732 */ 733 public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByC_NotE_PrevAndNext( 734 long statsUserId, long companyId, int entryCount, 735 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 736 throws com.liferay.portal.kernel.exception.SystemException, 737 com.liferay.portlet.blogs.NoSuchStatsUserException { 738 return getPersistence() 739 .findByC_NotE_PrevAndNext(statsUserId, companyId, 740 entryCount, orderByComparator); 741 } 742 743 /** 744 * Finds all the blogs stats users where userId = ? and lastPostDate = ?. 745 * 746 * @param userId the user ID to search with 747 * @param lastPostDate the last post date to search with 748 * @return the matching blogs stats users 749 * @throws SystemException if a system exception occurred 750 */ 751 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L( 752 long userId, java.util.Date lastPostDate) 753 throws com.liferay.portal.kernel.exception.SystemException { 754 return getPersistence().findByU_L(userId, lastPostDate); 755 } 756 757 /** 758 * Finds a range of all the blogs stats users where userId = ? and lastPostDate = ?. 759 * 760 * <p> 761 * 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. 762 * </p> 763 * 764 * @param userId the user ID to search with 765 * @param lastPostDate the last post date to search with 766 * @param start the lower bound of the range of blogs stats users to return 767 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 768 * @return the range of matching blogs stats users 769 * @throws SystemException if a system exception occurred 770 */ 771 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L( 772 long userId, java.util.Date lastPostDate, int start, int end) 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence().findByU_L(userId, lastPostDate, start, end); 775 } 776 777 /** 778 * Finds an ordered range of all the blogs stats users where userId = ? and lastPostDate = ?. 779 * 780 * <p> 781 * 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. 782 * </p> 783 * 784 * @param userId the user ID to search with 785 * @param lastPostDate the last post date to search with 786 * @param start the lower bound of the range of blogs stats users to return 787 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 788 * @param orderByComparator the comparator to order the results by 789 * @return the ordered range of matching blogs stats users 790 * @throws SystemException if a system exception occurred 791 */ 792 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L( 793 long userId, java.util.Date lastPostDate, int start, int end, 794 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 795 throws com.liferay.portal.kernel.exception.SystemException { 796 return getPersistence() 797 .findByU_L(userId, lastPostDate, start, end, 798 orderByComparator); 799 } 800 801 /** 802 * Finds the first blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 803 * 804 * <p> 805 * 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. 806 * </p> 807 * 808 * @param userId the user ID to search with 809 * @param lastPostDate the last post date to search with 810 * @param orderByComparator the comparator to order the set by 811 * @return the first matching blogs stats user 812 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 813 * @throws SystemException if a system exception occurred 814 */ 815 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByU_L_First( 816 long userId, java.util.Date lastPostDate, 817 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 818 throws com.liferay.portal.kernel.exception.SystemException, 819 com.liferay.portlet.blogs.NoSuchStatsUserException { 820 return getPersistence() 821 .findByU_L_First(userId, lastPostDate, orderByComparator); 822 } 823 824 /** 825 * Finds the last blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 826 * 827 * <p> 828 * 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. 829 * </p> 830 * 831 * @param userId the user ID to search with 832 * @param lastPostDate the last post date to search with 833 * @param orderByComparator the comparator to order the set by 834 * @return the last matching blogs stats user 835 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 836 * @throws SystemException if a system exception occurred 837 */ 838 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByU_L_Last( 839 long userId, java.util.Date lastPostDate, 840 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 841 throws com.liferay.portal.kernel.exception.SystemException, 842 com.liferay.portlet.blogs.NoSuchStatsUserException { 843 return getPersistence() 844 .findByU_L_Last(userId, lastPostDate, orderByComparator); 845 } 846 847 /** 848 * Finds the blogs stats users before and after the current blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 849 * 850 * <p> 851 * 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. 852 * </p> 853 * 854 * @param statsUserId the primary key of the current blogs stats user 855 * @param userId the user ID to search with 856 * @param lastPostDate the last post date to search with 857 * @param orderByComparator the comparator to order the set by 858 * @return the previous, current, and next blogs stats user 859 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 860 * @throws SystemException if a system exception occurred 861 */ 862 public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByU_L_PrevAndNext( 863 long statsUserId, long userId, java.util.Date lastPostDate, 864 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 865 throws com.liferay.portal.kernel.exception.SystemException, 866 com.liferay.portlet.blogs.NoSuchStatsUserException { 867 return getPersistence() 868 .findByU_L_PrevAndNext(statsUserId, userId, lastPostDate, 869 orderByComparator); 870 } 871 872 /** 873 * Finds all the blogs stats users. 874 * 875 * @return the blogs stats users 876 * @throws SystemException if a system exception occurred 877 */ 878 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll() 879 throws com.liferay.portal.kernel.exception.SystemException { 880 return getPersistence().findAll(); 881 } 882 883 /** 884 * Finds a range of all the blogs stats users. 885 * 886 * <p> 887 * 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. 888 * </p> 889 * 890 * @param start the lower bound of the range of blogs stats users to return 891 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 892 * @return the range of blogs stats users 893 * @throws SystemException if a system exception occurred 894 */ 895 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll( 896 int start, int end) 897 throws com.liferay.portal.kernel.exception.SystemException { 898 return getPersistence().findAll(start, end); 899 } 900 901 /** 902 * Finds an ordered range of all the blogs stats users. 903 * 904 * <p> 905 * 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. 906 * </p> 907 * 908 * @param start the lower bound of the range of blogs stats users to return 909 * @param end the upper bound of the range of blogs stats users to return (not inclusive) 910 * @param orderByComparator the comparator to order the results by 911 * @return the ordered range of blogs stats users 912 * @throws SystemException if a system exception occurred 913 */ 914 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll( 915 int start, int end, 916 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 917 throws com.liferay.portal.kernel.exception.SystemException { 918 return getPersistence().findAll(start, end, orderByComparator); 919 } 920 921 /** 922 * Removes all the blogs stats users where groupId = ? from the database. 923 * 924 * @param groupId the group ID to search with 925 * @throws SystemException if a system exception occurred 926 */ 927 public static void removeByGroupId(long groupId) 928 throws com.liferay.portal.kernel.exception.SystemException { 929 getPersistence().removeByGroupId(groupId); 930 } 931 932 /** 933 * Removes all the blogs stats users where userId = ? from the database. 934 * 935 * @param userId the user ID to search with 936 * @throws SystemException if a system exception occurred 937 */ 938 public static void removeByUserId(long userId) 939 throws com.liferay.portal.kernel.exception.SystemException { 940 getPersistence().removeByUserId(userId); 941 } 942 943 /** 944 * Removes the blogs stats user where groupId = ? and userId = ? from the database. 945 * 946 * @param groupId the group ID to search with 947 * @param userId the user ID to search with 948 * @throws SystemException if a system exception occurred 949 */ 950 public static void removeByG_U(long groupId, long userId) 951 throws com.liferay.portal.kernel.exception.SystemException, 952 com.liferay.portlet.blogs.NoSuchStatsUserException { 953 getPersistence().removeByG_U(groupId, userId); 954 } 955 956 /** 957 * Removes all the blogs stats users where groupId = ? and entryCount ≠ ? from the database. 958 * 959 * @param groupId the group ID to search with 960 * @param entryCount the entry count to search with 961 * @throws SystemException if a system exception occurred 962 */ 963 public static void removeByG_NotE(long groupId, int entryCount) 964 throws com.liferay.portal.kernel.exception.SystemException { 965 getPersistence().removeByG_NotE(groupId, entryCount); 966 } 967 968 /** 969 * Removes all the blogs stats users where companyId = ? and entryCount ≠ ? from the database. 970 * 971 * @param companyId the company ID to search with 972 * @param entryCount the entry count to search with 973 * @throws SystemException if a system exception occurred 974 */ 975 public static void removeByC_NotE(long companyId, int entryCount) 976 throws com.liferay.portal.kernel.exception.SystemException { 977 getPersistence().removeByC_NotE(companyId, entryCount); 978 } 979 980 /** 981 * Removes all the blogs stats users where userId = ? and lastPostDate = ? from the database. 982 * 983 * @param userId the user ID to search with 984 * @param lastPostDate the last post date to search with 985 * @throws SystemException if a system exception occurred 986 */ 987 public static void removeByU_L(long userId, java.util.Date lastPostDate) 988 throws com.liferay.portal.kernel.exception.SystemException { 989 getPersistence().removeByU_L(userId, lastPostDate); 990 } 991 992 /** 993 * Removes all the blogs stats users from the database. 994 * 995 * @throws SystemException if a system exception occurred 996 */ 997 public static void removeAll() 998 throws com.liferay.portal.kernel.exception.SystemException { 999 getPersistence().removeAll(); 1000 } 1001 1002 /** 1003 * Counts all the blogs stats users where groupId = ?. 1004 * 1005 * @param groupId the group ID to search with 1006 * @return the number of matching blogs stats users 1007 * @throws SystemException if a system exception occurred 1008 */ 1009 public static int countByGroupId(long groupId) 1010 throws com.liferay.portal.kernel.exception.SystemException { 1011 return getPersistence().countByGroupId(groupId); 1012 } 1013 1014 /** 1015 * Counts all the blogs stats users where userId = ?. 1016 * 1017 * @param userId the user ID to search with 1018 * @return the number of matching blogs stats users 1019 * @throws SystemException if a system exception occurred 1020 */ 1021 public static int countByUserId(long userId) 1022 throws com.liferay.portal.kernel.exception.SystemException { 1023 return getPersistence().countByUserId(userId); 1024 } 1025 1026 /** 1027 * Counts all the blogs stats users where groupId = ? and userId = ?. 1028 * 1029 * @param groupId the group ID to search with 1030 * @param userId the user ID to search with 1031 * @return the number of matching blogs stats users 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static int countByG_U(long groupId, long userId) 1035 throws com.liferay.portal.kernel.exception.SystemException { 1036 return getPersistence().countByG_U(groupId, userId); 1037 } 1038 1039 /** 1040 * Counts all the blogs stats users where groupId = ? and entryCount ≠ ?. 1041 * 1042 * @param groupId the group ID to search with 1043 * @param entryCount the entry count to search with 1044 * @return the number of matching blogs stats users 1045 * @throws SystemException if a system exception occurred 1046 */ 1047 public static int countByG_NotE(long groupId, int entryCount) 1048 throws com.liferay.portal.kernel.exception.SystemException { 1049 return getPersistence().countByG_NotE(groupId, entryCount); 1050 } 1051 1052 /** 1053 * Counts all the blogs stats users where companyId = ? and entryCount ≠ ?. 1054 * 1055 * @param companyId the company ID to search with 1056 * @param entryCount the entry count to search with 1057 * @return the number of matching blogs stats users 1058 * @throws SystemException if a system exception occurred 1059 */ 1060 public static int countByC_NotE(long companyId, int entryCount) 1061 throws com.liferay.portal.kernel.exception.SystemException { 1062 return getPersistence().countByC_NotE(companyId, entryCount); 1063 } 1064 1065 /** 1066 * Counts all the blogs stats users where userId = ? and lastPostDate = ?. 1067 * 1068 * @param userId the user ID to search with 1069 * @param lastPostDate the last post date to search with 1070 * @return the number of matching blogs stats users 1071 * @throws SystemException if a system exception occurred 1072 */ 1073 public static int countByU_L(long userId, java.util.Date lastPostDate) 1074 throws com.liferay.portal.kernel.exception.SystemException { 1075 return getPersistence().countByU_L(userId, lastPostDate); 1076 } 1077 1078 /** 1079 * Counts all the blogs stats users. 1080 * 1081 * @return the number of blogs stats users 1082 * @throws SystemException if a system exception occurred 1083 */ 1084 public static int countAll() 1085 throws com.liferay.portal.kernel.exception.SystemException { 1086 return getPersistence().countAll(); 1087 } 1088 1089 public static BlogsStatsUserPersistence getPersistence() { 1090 if (_persistence == null) { 1091 _persistence = (BlogsStatsUserPersistence)PortalBeanLocatorUtil.locate(BlogsStatsUserPersistence.class.getName()); 1092 1093 ReferenceRegistry.registerReference(BlogsStatsUserUtil.class, 1094 "_persistence"); 1095 } 1096 1097 return _persistence; 1098 } 1099 1100 public void setPersistence(BlogsStatsUserPersistence persistence) { 1101 _persistence = persistence; 1102 1103 ReferenceRegistry.registerReference(BlogsStatsUserUtil.class, 1104 "_persistence"); 1105 } 1106 1107 private static BlogsStatsUserPersistence _persistence; 1108 }