001 /** 002 * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 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 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 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 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 * Returns 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 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 * Returns 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 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 * Returns all the blogs stats users where groupId = ?. 204 * 205 * @param groupId the group ID 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 * Returns 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 223 * @param start the lower bound of the range of blogs stats users 224 * @param end the upper bound of the range of blogs stats users (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 * Returns 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 242 * @param start the lower bound of the range of blogs stats users 243 * @param end the upper bound of the range of blogs stats users (not inclusive) 244 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * Returns 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 264 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 285 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns all the blogs stats users where userId = ?. 324 * 325 * @param userId the user ID 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 * Returns 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 342 * @param start the lower bound of the range of blogs stats users 343 * @param end the upper bound of the range of blogs stats users (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 * Returns 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 361 * @param start the lower bound of the range of blogs stats users 362 * @param end the upper bound of the range of blogs stats users (not inclusive) 363 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * Returns 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 383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 404 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 445 * @param userId the user ID 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 * Returns 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 461 * @param userId the user ID 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 * Returns 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 475 * @param userId the user ID 476 * @param retrieveFromCache whether to use the finder cache 477 * @return the matching blogs stats user, or <code>null</code> if a matching blogs stats user could not be found 478 * @throws SystemException if a system exception occurred 479 */ 480 public static com.liferay.portlet.blogs.model.BlogsStatsUser fetchByG_U( 481 long groupId, long userId, boolean retrieveFromCache) 482 throws com.liferay.portal.kernel.exception.SystemException { 483 return getPersistence().fetchByG_U(groupId, userId, retrieveFromCache); 484 } 485 486 /** 487 * Returns all the blogs stats users where groupId = ? and entryCount ≠ ?. 488 * 489 * @param groupId the group ID 490 * @param entryCount the entry count 491 * @return the matching blogs stats users 492 * @throws SystemException if a system exception occurred 493 */ 494 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE( 495 long groupId, int entryCount) 496 throws com.liferay.portal.kernel.exception.SystemException { 497 return getPersistence().findByG_NotE(groupId, entryCount); 498 } 499 500 /** 501 * Returns a range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 502 * 503 * <p> 504 * 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. 505 * </p> 506 * 507 * @param groupId the group ID 508 * @param entryCount the entry count 509 * @param start the lower bound of the range of blogs stats users 510 * @param end the upper bound of the range of blogs stats users (not inclusive) 511 * @return the range of matching blogs stats users 512 * @throws SystemException if a system exception occurred 513 */ 514 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE( 515 long groupId, int entryCount, int start, int end) 516 throws com.liferay.portal.kernel.exception.SystemException { 517 return getPersistence().findByG_NotE(groupId, entryCount, start, end); 518 } 519 520 /** 521 * Returns an ordered range of all the blogs stats users where groupId = ? and entryCount ≠ ?. 522 * 523 * <p> 524 * 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. 525 * </p> 526 * 527 * @param groupId the group ID 528 * @param entryCount the entry count 529 * @param start the lower bound of the range of blogs stats users 530 * @param end the upper bound of the range of blogs stats users (not inclusive) 531 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 532 * @return the ordered range of matching blogs stats users 533 * @throws SystemException if a system exception occurred 534 */ 535 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByG_NotE( 536 long groupId, int entryCount, int start, int end, 537 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 538 throws com.liferay.portal.kernel.exception.SystemException { 539 return getPersistence() 540 .findByG_NotE(groupId, entryCount, start, end, 541 orderByComparator); 542 } 543 544 /** 545 * Returns the first blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 546 * 547 * <p> 548 * 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. 549 * </p> 550 * 551 * @param groupId the group ID 552 * @param entryCount the entry count 553 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 554 * @return the first matching blogs stats user 555 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 556 * @throws SystemException if a system exception occurred 557 */ 558 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByG_NotE_First( 559 long groupId, int entryCount, 560 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 561 throws com.liferay.portal.kernel.exception.SystemException, 562 com.liferay.portlet.blogs.NoSuchStatsUserException { 563 return getPersistence() 564 .findByG_NotE_First(groupId, entryCount, orderByComparator); 565 } 566 567 /** 568 * Returns the last blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 569 * 570 * <p> 571 * 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. 572 * </p> 573 * 574 * @param groupId the group ID 575 * @param entryCount the entry count 576 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 577 * @return the last matching blogs stats user 578 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 579 * @throws SystemException if a system exception occurred 580 */ 581 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByG_NotE_Last( 582 long groupId, int entryCount, 583 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 584 throws com.liferay.portal.kernel.exception.SystemException, 585 com.liferay.portlet.blogs.NoSuchStatsUserException { 586 return getPersistence() 587 .findByG_NotE_Last(groupId, entryCount, orderByComparator); 588 } 589 590 /** 591 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where groupId = ? and entryCount ≠ ?. 592 * 593 * <p> 594 * 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. 595 * </p> 596 * 597 * @param statsUserId the primary key of the current blogs stats user 598 * @param groupId the group ID 599 * @param entryCount the entry count 600 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 601 * @return the previous, current, and next blogs stats user 602 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 603 * @throws SystemException if a system exception occurred 604 */ 605 public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByG_NotE_PrevAndNext( 606 long statsUserId, long groupId, int entryCount, 607 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 608 throws com.liferay.portal.kernel.exception.SystemException, 609 com.liferay.portlet.blogs.NoSuchStatsUserException { 610 return getPersistence() 611 .findByG_NotE_PrevAndNext(statsUserId, groupId, entryCount, 612 orderByComparator); 613 } 614 615 /** 616 * Returns all the blogs stats users where companyId = ? and entryCount ≠ ?. 617 * 618 * @param companyId the company ID 619 * @param entryCount the entry count 620 * @return the matching blogs stats users 621 * @throws SystemException if a system exception occurred 622 */ 623 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE( 624 long companyId, int entryCount) 625 throws com.liferay.portal.kernel.exception.SystemException { 626 return getPersistence().findByC_NotE(companyId, entryCount); 627 } 628 629 /** 630 * Returns a range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 631 * 632 * <p> 633 * 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. 634 * </p> 635 * 636 * @param companyId the company ID 637 * @param entryCount the entry count 638 * @param start the lower bound of the range of blogs stats users 639 * @param end the upper bound of the range of blogs stats users (not inclusive) 640 * @return the range of matching blogs stats users 641 * @throws SystemException if a system exception occurred 642 */ 643 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE( 644 long companyId, int entryCount, int start, int end) 645 throws com.liferay.portal.kernel.exception.SystemException { 646 return getPersistence().findByC_NotE(companyId, entryCount, start, end); 647 } 648 649 /** 650 * Returns an ordered range of all the blogs stats users where companyId = ? and entryCount ≠ ?. 651 * 652 * <p> 653 * 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. 654 * </p> 655 * 656 * @param companyId the company ID 657 * @param entryCount the entry count 658 * @param start the lower bound of the range of blogs stats users 659 * @param end the upper bound of the range of blogs stats users (not inclusive) 660 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 661 * @return the ordered range of matching blogs stats users 662 * @throws SystemException if a system exception occurred 663 */ 664 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByC_NotE( 665 long companyId, int entryCount, int start, int end, 666 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 667 throws com.liferay.portal.kernel.exception.SystemException { 668 return getPersistence() 669 .findByC_NotE(companyId, entryCount, start, end, 670 orderByComparator); 671 } 672 673 /** 674 * Returns the first blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 675 * 676 * <p> 677 * 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. 678 * </p> 679 * 680 * @param companyId the company ID 681 * @param entryCount the entry count 682 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 683 * @return the first matching blogs stats user 684 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 685 * @throws SystemException if a system exception occurred 686 */ 687 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByC_NotE_First( 688 long companyId, int entryCount, 689 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 690 throws com.liferay.portal.kernel.exception.SystemException, 691 com.liferay.portlet.blogs.NoSuchStatsUserException { 692 return getPersistence() 693 .findByC_NotE_First(companyId, entryCount, orderByComparator); 694 } 695 696 /** 697 * Returns the last blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 698 * 699 * <p> 700 * 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. 701 * </p> 702 * 703 * @param companyId the company ID 704 * @param entryCount the entry count 705 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 706 * @return the last matching blogs stats user 707 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 708 * @throws SystemException if a system exception occurred 709 */ 710 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByC_NotE_Last( 711 long companyId, int entryCount, 712 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 713 throws com.liferay.portal.kernel.exception.SystemException, 714 com.liferay.portlet.blogs.NoSuchStatsUserException { 715 return getPersistence() 716 .findByC_NotE_Last(companyId, entryCount, orderByComparator); 717 } 718 719 /** 720 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where companyId = ? and entryCount ≠ ?. 721 * 722 * <p> 723 * 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. 724 * </p> 725 * 726 * @param statsUserId the primary key of the current blogs stats user 727 * @param companyId the company ID 728 * @param entryCount the entry count 729 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 730 * @return the previous, current, and next blogs stats user 731 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 732 * @throws SystemException if a system exception occurred 733 */ 734 public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByC_NotE_PrevAndNext( 735 long statsUserId, long companyId, int entryCount, 736 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 737 throws com.liferay.portal.kernel.exception.SystemException, 738 com.liferay.portlet.blogs.NoSuchStatsUserException { 739 return getPersistence() 740 .findByC_NotE_PrevAndNext(statsUserId, companyId, 741 entryCount, orderByComparator); 742 } 743 744 /** 745 * Returns all the blogs stats users where userId = ? and lastPostDate = ?. 746 * 747 * @param userId the user ID 748 * @param lastPostDate the last post date 749 * @return the matching blogs stats users 750 * @throws SystemException if a system exception occurred 751 */ 752 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L( 753 long userId, java.util.Date lastPostDate) 754 throws com.liferay.portal.kernel.exception.SystemException { 755 return getPersistence().findByU_L(userId, lastPostDate); 756 } 757 758 /** 759 * Returns a range of all the blogs stats users where userId = ? and lastPostDate = ?. 760 * 761 * <p> 762 * 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. 763 * </p> 764 * 765 * @param userId the user ID 766 * @param lastPostDate the last post date 767 * @param start the lower bound of the range of blogs stats users 768 * @param end the upper bound of the range of blogs stats users (not inclusive) 769 * @return the range of matching blogs stats users 770 * @throws SystemException if a system exception occurred 771 */ 772 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L( 773 long userId, java.util.Date lastPostDate, int start, int end) 774 throws com.liferay.portal.kernel.exception.SystemException { 775 return getPersistence().findByU_L(userId, lastPostDate, start, end); 776 } 777 778 /** 779 * Returns an ordered range of all the blogs stats users where userId = ? and lastPostDate = ?. 780 * 781 * <p> 782 * 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. 783 * </p> 784 * 785 * @param userId the user ID 786 * @param lastPostDate the last post date 787 * @param start the lower bound of the range of blogs stats users 788 * @param end the upper bound of the range of blogs stats users (not inclusive) 789 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 790 * @return the ordered range of matching blogs stats users 791 * @throws SystemException if a system exception occurred 792 */ 793 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findByU_L( 794 long userId, java.util.Date lastPostDate, int start, int end, 795 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 796 throws com.liferay.portal.kernel.exception.SystemException { 797 return getPersistence() 798 .findByU_L(userId, lastPostDate, start, end, 799 orderByComparator); 800 } 801 802 /** 803 * Returns the first blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 804 * 805 * <p> 806 * 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. 807 * </p> 808 * 809 * @param userId the user ID 810 * @param lastPostDate the last post date 811 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 812 * @return the first matching blogs stats user 813 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 814 * @throws SystemException if a system exception occurred 815 */ 816 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByU_L_First( 817 long userId, java.util.Date lastPostDate, 818 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 819 throws com.liferay.portal.kernel.exception.SystemException, 820 com.liferay.portlet.blogs.NoSuchStatsUserException { 821 return getPersistence() 822 .findByU_L_First(userId, lastPostDate, orderByComparator); 823 } 824 825 /** 826 * Returns the last blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 827 * 828 * <p> 829 * 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. 830 * </p> 831 * 832 * @param userId the user ID 833 * @param lastPostDate the last post date 834 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 835 * @return the last matching blogs stats user 836 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a matching blogs stats user could not be found 837 * @throws SystemException if a system exception occurred 838 */ 839 public static com.liferay.portlet.blogs.model.BlogsStatsUser findByU_L_Last( 840 long userId, java.util.Date lastPostDate, 841 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 842 throws com.liferay.portal.kernel.exception.SystemException, 843 com.liferay.portlet.blogs.NoSuchStatsUserException { 844 return getPersistence() 845 .findByU_L_Last(userId, lastPostDate, orderByComparator); 846 } 847 848 /** 849 * Returns the blogs stats users before and after the current blogs stats user in the ordered set where userId = ? and lastPostDate = ?. 850 * 851 * <p> 852 * 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. 853 * </p> 854 * 855 * @param statsUserId the primary key of the current blogs stats user 856 * @param userId the user ID 857 * @param lastPostDate the last post date 858 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 859 * @return the previous, current, and next blogs stats user 860 * @throws com.liferay.portlet.blogs.NoSuchStatsUserException if a blogs stats user with the primary key could not be found 861 * @throws SystemException if a system exception occurred 862 */ 863 public static com.liferay.portlet.blogs.model.BlogsStatsUser[] findByU_L_PrevAndNext( 864 long statsUserId, long userId, java.util.Date lastPostDate, 865 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 866 throws com.liferay.portal.kernel.exception.SystemException, 867 com.liferay.portlet.blogs.NoSuchStatsUserException { 868 return getPersistence() 869 .findByU_L_PrevAndNext(statsUserId, userId, lastPostDate, 870 orderByComparator); 871 } 872 873 /** 874 * Returns all the blogs stats users. 875 * 876 * @return the blogs stats users 877 * @throws SystemException if a system exception occurred 878 */ 879 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll() 880 throws com.liferay.portal.kernel.exception.SystemException { 881 return getPersistence().findAll(); 882 } 883 884 /** 885 * Returns a range of all the blogs stats users. 886 * 887 * <p> 888 * 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. 889 * </p> 890 * 891 * @param start the lower bound of the range of blogs stats users 892 * @param end the upper bound of the range of blogs stats users (not inclusive) 893 * @return the range of blogs stats users 894 * @throws SystemException if a system exception occurred 895 */ 896 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll( 897 int start, int end) 898 throws com.liferay.portal.kernel.exception.SystemException { 899 return getPersistence().findAll(start, end); 900 } 901 902 /** 903 * Returns an ordered range of all the blogs stats users. 904 * 905 * <p> 906 * 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. 907 * </p> 908 * 909 * @param start the lower bound of the range of blogs stats users 910 * @param end the upper bound of the range of blogs stats users (not inclusive) 911 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 912 * @return the ordered range of blogs stats users 913 * @throws SystemException if a system exception occurred 914 */ 915 public static java.util.List<com.liferay.portlet.blogs.model.BlogsStatsUser> findAll( 916 int start, int end, 917 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 918 throws com.liferay.portal.kernel.exception.SystemException { 919 return getPersistence().findAll(start, end, orderByComparator); 920 } 921 922 /** 923 * Removes all the blogs stats users where groupId = ? from the database. 924 * 925 * @param groupId the group ID 926 * @throws SystemException if a system exception occurred 927 */ 928 public static void removeByGroupId(long groupId) 929 throws com.liferay.portal.kernel.exception.SystemException { 930 getPersistence().removeByGroupId(groupId); 931 } 932 933 /** 934 * Removes all the blogs stats users where userId = ? from the database. 935 * 936 * @param userId the user ID 937 * @throws SystemException if a system exception occurred 938 */ 939 public static void removeByUserId(long userId) 940 throws com.liferay.portal.kernel.exception.SystemException { 941 getPersistence().removeByUserId(userId); 942 } 943 944 /** 945 * Removes the blogs stats user where groupId = ? and userId = ? from the database. 946 * 947 * @param groupId the group ID 948 * @param userId the user ID 949 * @throws SystemException if a system exception occurred 950 */ 951 public static void removeByG_U(long groupId, long userId) 952 throws com.liferay.portal.kernel.exception.SystemException, 953 com.liferay.portlet.blogs.NoSuchStatsUserException { 954 getPersistence().removeByG_U(groupId, userId); 955 } 956 957 /** 958 * Removes all the blogs stats users where groupId = ? and entryCount ≠ ? from the database. 959 * 960 * @param groupId the group ID 961 * @param entryCount the entry count 962 * @throws SystemException if a system exception occurred 963 */ 964 public static void removeByG_NotE(long groupId, int entryCount) 965 throws com.liferay.portal.kernel.exception.SystemException { 966 getPersistence().removeByG_NotE(groupId, entryCount); 967 } 968 969 /** 970 * Removes all the blogs stats users where companyId = ? and entryCount ≠ ? from the database. 971 * 972 * @param companyId the company ID 973 * @param entryCount the entry count 974 * @throws SystemException if a system exception occurred 975 */ 976 public static void removeByC_NotE(long companyId, int entryCount) 977 throws com.liferay.portal.kernel.exception.SystemException { 978 getPersistence().removeByC_NotE(companyId, entryCount); 979 } 980 981 /** 982 * Removes all the blogs stats users where userId = ? and lastPostDate = ? from the database. 983 * 984 * @param userId the user ID 985 * @param lastPostDate the last post date 986 * @throws SystemException if a system exception occurred 987 */ 988 public static void removeByU_L(long userId, java.util.Date lastPostDate) 989 throws com.liferay.portal.kernel.exception.SystemException { 990 getPersistence().removeByU_L(userId, lastPostDate); 991 } 992 993 /** 994 * Removes all the blogs stats users from the database. 995 * 996 * @throws SystemException if a system exception occurred 997 */ 998 public static void removeAll() 999 throws com.liferay.portal.kernel.exception.SystemException { 1000 getPersistence().removeAll(); 1001 } 1002 1003 /** 1004 * Returns the number of blogs stats users where groupId = ?. 1005 * 1006 * @param groupId the group ID 1007 * @return the number of matching blogs stats users 1008 * @throws SystemException if a system exception occurred 1009 */ 1010 public static int countByGroupId(long groupId) 1011 throws com.liferay.portal.kernel.exception.SystemException { 1012 return getPersistence().countByGroupId(groupId); 1013 } 1014 1015 /** 1016 * Returns the number of blogs stats users where userId = ?. 1017 * 1018 * @param userId the user ID 1019 * @return the number of matching blogs stats users 1020 * @throws SystemException if a system exception occurred 1021 */ 1022 public static int countByUserId(long userId) 1023 throws com.liferay.portal.kernel.exception.SystemException { 1024 return getPersistence().countByUserId(userId); 1025 } 1026 1027 /** 1028 * Returns the number of blogs stats users where groupId = ? and userId = ?. 1029 * 1030 * @param groupId the group ID 1031 * @param userId the user ID 1032 * @return the number of matching blogs stats users 1033 * @throws SystemException if a system exception occurred 1034 */ 1035 public static int countByG_U(long groupId, long userId) 1036 throws com.liferay.portal.kernel.exception.SystemException { 1037 return getPersistence().countByG_U(groupId, userId); 1038 } 1039 1040 /** 1041 * Returns the number of blogs stats users where groupId = ? and entryCount ≠ ?. 1042 * 1043 * @param groupId the group ID 1044 * @param entryCount the entry count 1045 * @return the number of matching blogs stats users 1046 * @throws SystemException if a system exception occurred 1047 */ 1048 public static int countByG_NotE(long groupId, int entryCount) 1049 throws com.liferay.portal.kernel.exception.SystemException { 1050 return getPersistence().countByG_NotE(groupId, entryCount); 1051 } 1052 1053 /** 1054 * Returns the number of blogs stats users where companyId = ? and entryCount ≠ ?. 1055 * 1056 * @param companyId the company ID 1057 * @param entryCount the entry count 1058 * @return the number of matching blogs stats users 1059 * @throws SystemException if a system exception occurred 1060 */ 1061 public static int countByC_NotE(long companyId, int entryCount) 1062 throws com.liferay.portal.kernel.exception.SystemException { 1063 return getPersistence().countByC_NotE(companyId, entryCount); 1064 } 1065 1066 /** 1067 * Returns the number of blogs stats users where userId = ? and lastPostDate = ?. 1068 * 1069 * @param userId the user ID 1070 * @param lastPostDate the last post date 1071 * @return the number of matching blogs stats users 1072 * @throws SystemException if a system exception occurred 1073 */ 1074 public static int countByU_L(long userId, java.util.Date lastPostDate) 1075 throws com.liferay.portal.kernel.exception.SystemException { 1076 return getPersistence().countByU_L(userId, lastPostDate); 1077 } 1078 1079 /** 1080 * Returns the number of blogs stats users. 1081 * 1082 * @return the number of blogs stats users 1083 * @throws SystemException if a system exception occurred 1084 */ 1085 public static int countAll() 1086 throws com.liferay.portal.kernel.exception.SystemException { 1087 return getPersistence().countAll(); 1088 } 1089 1090 public static BlogsStatsUserPersistence getPersistence() { 1091 if (_persistence == null) { 1092 _persistence = (BlogsStatsUserPersistence)PortalBeanLocatorUtil.locate(BlogsStatsUserPersistence.class.getName()); 1093 1094 ReferenceRegistry.registerReference(BlogsStatsUserUtil.class, 1095 "_persistence"); 1096 } 1097 1098 return _persistence; 1099 } 1100 1101 public void setPersistence(BlogsStatsUserPersistence persistence) { 1102 _persistence = persistence; 1103 1104 ReferenceRegistry.registerReference(BlogsStatsUserUtil.class, 1105 "_persistence"); 1106 } 1107 1108 private static BlogsStatsUserPersistence _persistence; 1109 }