001 /** 002 * Copyright (c) 2000-present 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.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.UserNotificationEvent; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the user notification event service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserNotificationEventPersistenceImpl} 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 UserNotificationEventPersistence 037 * @see com.liferay.portal.service.persistence.impl.UserNotificationEventPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class UserNotificationEventUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(UserNotificationEvent userNotificationEvent) { 059 getPersistence().clearCache(userNotificationEvent); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<UserNotificationEvent> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 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<UserNotificationEvent> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<UserNotificationEvent> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<UserNotificationEvent> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static UserNotificationEvent update( 100 UserNotificationEvent userNotificationEvent) { 101 return getPersistence().update(userNotificationEvent); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static UserNotificationEvent update( 108 UserNotificationEvent userNotificationEvent, 109 ServiceContext serviceContext) { 110 return getPersistence().update(userNotificationEvent, serviceContext); 111 } 112 113 /** 114 * Returns all the user notification events where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching user notification events 118 */ 119 public static List<UserNotificationEvent> findByUuid(java.lang.String uuid) { 120 return getPersistence().findByUuid(uuid); 121 } 122 123 /** 124 * Returns a range of all the user notification events where uuid = ?. 125 * 126 * <p> 127 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 128 * </p> 129 * 130 * @param uuid the uuid 131 * @param start the lower bound of the range of user notification events 132 * @param end the upper bound of the range of user notification events (not inclusive) 133 * @return the range of matching user notification events 134 */ 135 public static List<UserNotificationEvent> findByUuid( 136 java.lang.String uuid, int start, int end) { 137 return getPersistence().findByUuid(uuid, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the user notification events where uuid = ?. 142 * 143 * <p> 144 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 145 * </p> 146 * 147 * @param uuid the uuid 148 * @param start the lower bound of the range of user notification events 149 * @param end the upper bound of the range of user notification events (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching user notification events 152 */ 153 public static List<UserNotificationEvent> findByUuid( 154 java.lang.String uuid, int start, int end, 155 OrderByComparator<UserNotificationEvent> orderByComparator) { 156 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 157 } 158 159 /** 160 * Returns an ordered range of all the user notification events where uuid = ?. 161 * 162 * <p> 163 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 164 * </p> 165 * 166 * @param uuid the uuid 167 * @param start the lower bound of the range of user notification events 168 * @param end the upper bound of the range of user notification events (not inclusive) 169 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 170 * @param retrieveFromCache whether to retrieve from the finder cache 171 * @return the ordered range of matching user notification events 172 */ 173 public static List<UserNotificationEvent> findByUuid( 174 java.lang.String uuid, int start, int end, 175 OrderByComparator<UserNotificationEvent> orderByComparator, 176 boolean retrieveFromCache) { 177 return getPersistence() 178 .findByUuid(uuid, start, end, orderByComparator, 179 retrieveFromCache); 180 } 181 182 /** 183 * Returns the first user notification event in the ordered set where uuid = ?. 184 * 185 * @param uuid the uuid 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the first matching user notification event 188 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 189 */ 190 public static UserNotificationEvent findByUuid_First( 191 java.lang.String uuid, 192 OrderByComparator<UserNotificationEvent> orderByComparator) 193 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 194 return getPersistence().findByUuid_First(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the first user notification event in the ordered set where uuid = ?. 199 * 200 * @param uuid the uuid 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 203 */ 204 public static UserNotificationEvent fetchByUuid_First( 205 java.lang.String uuid, 206 OrderByComparator<UserNotificationEvent> orderByComparator) { 207 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 208 } 209 210 /** 211 * Returns the last user notification event in the ordered set where uuid = ?. 212 * 213 * @param uuid the uuid 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the last matching user notification event 216 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 217 */ 218 public static UserNotificationEvent findByUuid_Last(java.lang.String uuid, 219 OrderByComparator<UserNotificationEvent> orderByComparator) 220 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 221 return getPersistence().findByUuid_Last(uuid, orderByComparator); 222 } 223 224 /** 225 * Returns the last user notification event in the ordered set where uuid = ?. 226 * 227 * @param uuid the uuid 228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 229 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 230 */ 231 public static UserNotificationEvent fetchByUuid_Last( 232 java.lang.String uuid, 233 OrderByComparator<UserNotificationEvent> orderByComparator) { 234 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 235 } 236 237 /** 238 * Returns the user notification events before and after the current user notification event in the ordered set where uuid = ?. 239 * 240 * @param userNotificationEventId the primary key of the current user notification event 241 * @param uuid the uuid 242 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 243 * @return the previous, current, and next user notification event 244 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 245 */ 246 public static UserNotificationEvent[] findByUuid_PrevAndNext( 247 long userNotificationEventId, java.lang.String uuid, 248 OrderByComparator<UserNotificationEvent> orderByComparator) 249 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 250 return getPersistence() 251 .findByUuid_PrevAndNext(userNotificationEventId, uuid, 252 orderByComparator); 253 } 254 255 /** 256 * Removes all the user notification events where uuid = ? from the database. 257 * 258 * @param uuid the uuid 259 */ 260 public static void removeByUuid(java.lang.String uuid) { 261 getPersistence().removeByUuid(uuid); 262 } 263 264 /** 265 * Returns the number of user notification events where uuid = ?. 266 * 267 * @param uuid the uuid 268 * @return the number of matching user notification events 269 */ 270 public static int countByUuid(java.lang.String uuid) { 271 return getPersistence().countByUuid(uuid); 272 } 273 274 /** 275 * Returns all the user notification events where uuid = ? and companyId = ?. 276 * 277 * @param uuid the uuid 278 * @param companyId the company ID 279 * @return the matching user notification events 280 */ 281 public static List<UserNotificationEvent> findByUuid_C( 282 java.lang.String uuid, long companyId) { 283 return getPersistence().findByUuid_C(uuid, companyId); 284 } 285 286 /** 287 * Returns a range of all the user notification events where uuid = ? and companyId = ?. 288 * 289 * <p> 290 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 291 * </p> 292 * 293 * @param uuid the uuid 294 * @param companyId the company ID 295 * @param start the lower bound of the range of user notification events 296 * @param end the upper bound of the range of user notification events (not inclusive) 297 * @return the range of matching user notification events 298 */ 299 public static List<UserNotificationEvent> findByUuid_C( 300 java.lang.String uuid, long companyId, int start, int end) { 301 return getPersistence().findByUuid_C(uuid, companyId, start, end); 302 } 303 304 /** 305 * Returns an ordered range of all the user notification events where uuid = ? and companyId = ?. 306 * 307 * <p> 308 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 309 * </p> 310 * 311 * @param uuid the uuid 312 * @param companyId the company ID 313 * @param start the lower bound of the range of user notification events 314 * @param end the upper bound of the range of user notification events (not inclusive) 315 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 316 * @return the ordered range of matching user notification events 317 */ 318 public static List<UserNotificationEvent> findByUuid_C( 319 java.lang.String uuid, long companyId, int start, int end, 320 OrderByComparator<UserNotificationEvent> orderByComparator) { 321 return getPersistence() 322 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 323 } 324 325 /** 326 * Returns an ordered range of all the user notification events where uuid = ? and companyId = ?. 327 * 328 * <p> 329 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 330 * </p> 331 * 332 * @param uuid the uuid 333 * @param companyId the company ID 334 * @param start the lower bound of the range of user notification events 335 * @param end the upper bound of the range of user notification events (not inclusive) 336 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 337 * @param retrieveFromCache whether to retrieve from the finder cache 338 * @return the ordered range of matching user notification events 339 */ 340 public static List<UserNotificationEvent> findByUuid_C( 341 java.lang.String uuid, long companyId, int start, int end, 342 OrderByComparator<UserNotificationEvent> orderByComparator, 343 boolean retrieveFromCache) { 344 return getPersistence() 345 .findByUuid_C(uuid, companyId, start, end, 346 orderByComparator, retrieveFromCache); 347 } 348 349 /** 350 * Returns the first user notification event in the ordered set where uuid = ? and companyId = ?. 351 * 352 * @param uuid the uuid 353 * @param companyId the company ID 354 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 355 * @return the first matching user notification event 356 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 357 */ 358 public static UserNotificationEvent findByUuid_C_First( 359 java.lang.String uuid, long companyId, 360 OrderByComparator<UserNotificationEvent> orderByComparator) 361 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 362 return getPersistence() 363 .findByUuid_C_First(uuid, companyId, orderByComparator); 364 } 365 366 /** 367 * Returns the first user notification event in the ordered set where uuid = ? and companyId = ?. 368 * 369 * @param uuid the uuid 370 * @param companyId the company ID 371 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 372 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 373 */ 374 public static UserNotificationEvent fetchByUuid_C_First( 375 java.lang.String uuid, long companyId, 376 OrderByComparator<UserNotificationEvent> orderByComparator) { 377 return getPersistence() 378 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 379 } 380 381 /** 382 * Returns the last user notification event in the ordered set where uuid = ? and companyId = ?. 383 * 384 * @param uuid the uuid 385 * @param companyId the company ID 386 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 387 * @return the last matching user notification event 388 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 389 */ 390 public static UserNotificationEvent findByUuid_C_Last( 391 java.lang.String uuid, long companyId, 392 OrderByComparator<UserNotificationEvent> orderByComparator) 393 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 394 return getPersistence() 395 .findByUuid_C_Last(uuid, companyId, orderByComparator); 396 } 397 398 /** 399 * Returns the last user notification event in the ordered set where uuid = ? and companyId = ?. 400 * 401 * @param uuid the uuid 402 * @param companyId the company ID 403 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 404 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 405 */ 406 public static UserNotificationEvent fetchByUuid_C_Last( 407 java.lang.String uuid, long companyId, 408 OrderByComparator<UserNotificationEvent> orderByComparator) { 409 return getPersistence() 410 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 411 } 412 413 /** 414 * Returns the user notification events before and after the current user notification event in the ordered set where uuid = ? and companyId = ?. 415 * 416 * @param userNotificationEventId the primary key of the current user notification event 417 * @param uuid the uuid 418 * @param companyId the company ID 419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 420 * @return the previous, current, and next user notification event 421 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 422 */ 423 public static UserNotificationEvent[] findByUuid_C_PrevAndNext( 424 long userNotificationEventId, java.lang.String uuid, long companyId, 425 OrderByComparator<UserNotificationEvent> orderByComparator) 426 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 427 return getPersistence() 428 .findByUuid_C_PrevAndNext(userNotificationEventId, uuid, 429 companyId, orderByComparator); 430 } 431 432 /** 433 * Removes all the user notification events where uuid = ? and companyId = ? from the database. 434 * 435 * @param uuid the uuid 436 * @param companyId the company ID 437 */ 438 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 439 getPersistence().removeByUuid_C(uuid, companyId); 440 } 441 442 /** 443 * Returns the number of user notification events where uuid = ? and companyId = ?. 444 * 445 * @param uuid the uuid 446 * @param companyId the company ID 447 * @return the number of matching user notification events 448 */ 449 public static int countByUuid_C(java.lang.String uuid, long companyId) { 450 return getPersistence().countByUuid_C(uuid, companyId); 451 } 452 453 /** 454 * Returns all the user notification events where userId = ?. 455 * 456 * @param userId the user ID 457 * @return the matching user notification events 458 */ 459 public static List<UserNotificationEvent> findByUserId(long userId) { 460 return getPersistence().findByUserId(userId); 461 } 462 463 /** 464 * Returns a range of all the user notification events where userId = ?. 465 * 466 * <p> 467 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 468 * </p> 469 * 470 * @param userId the user ID 471 * @param start the lower bound of the range of user notification events 472 * @param end the upper bound of the range of user notification events (not inclusive) 473 * @return the range of matching user notification events 474 */ 475 public static List<UserNotificationEvent> findByUserId(long userId, 476 int start, int end) { 477 return getPersistence().findByUserId(userId, start, end); 478 } 479 480 /** 481 * Returns an ordered range of all the user notification events where userId = ?. 482 * 483 * <p> 484 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 485 * </p> 486 * 487 * @param userId the user ID 488 * @param start the lower bound of the range of user notification events 489 * @param end the upper bound of the range of user notification events (not inclusive) 490 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 491 * @return the ordered range of matching user notification events 492 */ 493 public static List<UserNotificationEvent> findByUserId(long userId, 494 int start, int end, 495 OrderByComparator<UserNotificationEvent> orderByComparator) { 496 return getPersistence() 497 .findByUserId(userId, start, end, orderByComparator); 498 } 499 500 /** 501 * Returns an ordered range of all the user notification events where userId = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 505 * </p> 506 * 507 * @param userId the user ID 508 * @param start the lower bound of the range of user notification events 509 * @param end the upper bound of the range of user notification events (not inclusive) 510 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 511 * @param retrieveFromCache whether to retrieve from the finder cache 512 * @return the ordered range of matching user notification events 513 */ 514 public static List<UserNotificationEvent> findByUserId(long userId, 515 int start, int end, 516 OrderByComparator<UserNotificationEvent> orderByComparator, 517 boolean retrieveFromCache) { 518 return getPersistence() 519 .findByUserId(userId, start, end, orderByComparator, 520 retrieveFromCache); 521 } 522 523 /** 524 * Returns the first user notification event in the ordered set where userId = ?. 525 * 526 * @param userId the user ID 527 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 528 * @return the first matching user notification event 529 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 530 */ 531 public static UserNotificationEvent findByUserId_First(long userId, 532 OrderByComparator<UserNotificationEvent> orderByComparator) 533 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 534 return getPersistence().findByUserId_First(userId, orderByComparator); 535 } 536 537 /** 538 * Returns the first user notification event in the ordered set where userId = ?. 539 * 540 * @param userId the user ID 541 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 542 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 543 */ 544 public static UserNotificationEvent fetchByUserId_First(long userId, 545 OrderByComparator<UserNotificationEvent> orderByComparator) { 546 return getPersistence().fetchByUserId_First(userId, orderByComparator); 547 } 548 549 /** 550 * Returns the last user notification event in the ordered set where userId = ?. 551 * 552 * @param userId the user ID 553 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 554 * @return the last matching user notification event 555 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 556 */ 557 public static UserNotificationEvent findByUserId_Last(long userId, 558 OrderByComparator<UserNotificationEvent> orderByComparator) 559 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 560 return getPersistence().findByUserId_Last(userId, orderByComparator); 561 } 562 563 /** 564 * Returns the last user notification event in the ordered set where userId = ?. 565 * 566 * @param userId the user ID 567 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 568 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 569 */ 570 public static UserNotificationEvent fetchByUserId_Last(long userId, 571 OrderByComparator<UserNotificationEvent> orderByComparator) { 572 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 573 } 574 575 /** 576 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ?. 577 * 578 * @param userNotificationEventId the primary key of the current user notification event 579 * @param userId the user ID 580 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 581 * @return the previous, current, and next user notification event 582 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 583 */ 584 public static UserNotificationEvent[] findByUserId_PrevAndNext( 585 long userNotificationEventId, long userId, 586 OrderByComparator<UserNotificationEvent> orderByComparator) 587 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 588 return getPersistence() 589 .findByUserId_PrevAndNext(userNotificationEventId, userId, 590 orderByComparator); 591 } 592 593 /** 594 * Removes all the user notification events where userId = ? from the database. 595 * 596 * @param userId the user ID 597 */ 598 public static void removeByUserId(long userId) { 599 getPersistence().removeByUserId(userId); 600 } 601 602 /** 603 * Returns the number of user notification events where userId = ?. 604 * 605 * @param userId the user ID 606 * @return the number of matching user notification events 607 */ 608 public static int countByUserId(long userId) { 609 return getPersistence().countByUserId(userId); 610 } 611 612 /** 613 * Returns all the user notification events where type = ?. 614 * 615 * @param type the type 616 * @return the matching user notification events 617 */ 618 public static List<UserNotificationEvent> findByType(java.lang.String type) { 619 return getPersistence().findByType(type); 620 } 621 622 /** 623 * Returns a range of all the user notification events where type = ?. 624 * 625 * <p> 626 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 627 * </p> 628 * 629 * @param type the type 630 * @param start the lower bound of the range of user notification events 631 * @param end the upper bound of the range of user notification events (not inclusive) 632 * @return the range of matching user notification events 633 */ 634 public static List<UserNotificationEvent> findByType( 635 java.lang.String type, int start, int end) { 636 return getPersistence().findByType(type, start, end); 637 } 638 639 /** 640 * Returns an ordered range of all the user notification events where type = ?. 641 * 642 * <p> 643 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 644 * </p> 645 * 646 * @param type the type 647 * @param start the lower bound of the range of user notification events 648 * @param end the upper bound of the range of user notification events (not inclusive) 649 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 650 * @return the ordered range of matching user notification events 651 */ 652 public static List<UserNotificationEvent> findByType( 653 java.lang.String type, int start, int end, 654 OrderByComparator<UserNotificationEvent> orderByComparator) { 655 return getPersistence().findByType(type, start, end, orderByComparator); 656 } 657 658 /** 659 * Returns an ordered range of all the user notification events where type = ?. 660 * 661 * <p> 662 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 663 * </p> 664 * 665 * @param type the type 666 * @param start the lower bound of the range of user notification events 667 * @param end the upper bound of the range of user notification events (not inclusive) 668 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 669 * @param retrieveFromCache whether to retrieve from the finder cache 670 * @return the ordered range of matching user notification events 671 */ 672 public static List<UserNotificationEvent> findByType( 673 java.lang.String type, int start, int end, 674 OrderByComparator<UserNotificationEvent> orderByComparator, 675 boolean retrieveFromCache) { 676 return getPersistence() 677 .findByType(type, start, end, orderByComparator, 678 retrieveFromCache); 679 } 680 681 /** 682 * Returns the first user notification event in the ordered set where type = ?. 683 * 684 * @param type the type 685 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 686 * @return the first matching user notification event 687 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 688 */ 689 public static UserNotificationEvent findByType_First( 690 java.lang.String type, 691 OrderByComparator<UserNotificationEvent> orderByComparator) 692 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 693 return getPersistence().findByType_First(type, orderByComparator); 694 } 695 696 /** 697 * Returns the first user notification event in the ordered set where type = ?. 698 * 699 * @param type the type 700 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 701 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 702 */ 703 public static UserNotificationEvent fetchByType_First( 704 java.lang.String type, 705 OrderByComparator<UserNotificationEvent> orderByComparator) { 706 return getPersistence().fetchByType_First(type, orderByComparator); 707 } 708 709 /** 710 * Returns the last user notification event in the ordered set where type = ?. 711 * 712 * @param type the type 713 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 714 * @return the last matching user notification event 715 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 716 */ 717 public static UserNotificationEvent findByType_Last(java.lang.String type, 718 OrderByComparator<UserNotificationEvent> orderByComparator) 719 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 720 return getPersistence().findByType_Last(type, orderByComparator); 721 } 722 723 /** 724 * Returns the last user notification event in the ordered set where type = ?. 725 * 726 * @param type the type 727 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 728 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 729 */ 730 public static UserNotificationEvent fetchByType_Last( 731 java.lang.String type, 732 OrderByComparator<UserNotificationEvent> orderByComparator) { 733 return getPersistence().fetchByType_Last(type, orderByComparator); 734 } 735 736 /** 737 * Returns the user notification events before and after the current user notification event in the ordered set where type = ?. 738 * 739 * @param userNotificationEventId the primary key of the current user notification event 740 * @param type the type 741 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 742 * @return the previous, current, and next user notification event 743 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 744 */ 745 public static UserNotificationEvent[] findByType_PrevAndNext( 746 long userNotificationEventId, java.lang.String type, 747 OrderByComparator<UserNotificationEvent> orderByComparator) 748 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 749 return getPersistence() 750 .findByType_PrevAndNext(userNotificationEventId, type, 751 orderByComparator); 752 } 753 754 /** 755 * Removes all the user notification events where type = ? from the database. 756 * 757 * @param type the type 758 */ 759 public static void removeByType(java.lang.String type) { 760 getPersistence().removeByType(type); 761 } 762 763 /** 764 * Returns the number of user notification events where type = ?. 765 * 766 * @param type the type 767 * @return the number of matching user notification events 768 */ 769 public static int countByType(java.lang.String type) { 770 return getPersistence().countByType(type); 771 } 772 773 /** 774 * Returns all the user notification events where userId = ? and deliveryType = ?. 775 * 776 * @param userId the user ID 777 * @param deliveryType the delivery type 778 * @return the matching user notification events 779 */ 780 public static List<UserNotificationEvent> findByU_DT(long userId, 781 int deliveryType) { 782 return getPersistence().findByU_DT(userId, deliveryType); 783 } 784 785 /** 786 * Returns a range of all the user notification events where userId = ? and deliveryType = ?. 787 * 788 * <p> 789 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 790 * </p> 791 * 792 * @param userId the user ID 793 * @param deliveryType the delivery type 794 * @param start the lower bound of the range of user notification events 795 * @param end the upper bound of the range of user notification events (not inclusive) 796 * @return the range of matching user notification events 797 */ 798 public static List<UserNotificationEvent> findByU_DT(long userId, 799 int deliveryType, int start, int end) { 800 return getPersistence().findByU_DT(userId, deliveryType, start, end); 801 } 802 803 /** 804 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ?. 805 * 806 * <p> 807 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 808 * </p> 809 * 810 * @param userId the user ID 811 * @param deliveryType the delivery type 812 * @param start the lower bound of the range of user notification events 813 * @param end the upper bound of the range of user notification events (not inclusive) 814 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 815 * @return the ordered range of matching user notification events 816 */ 817 public static List<UserNotificationEvent> findByU_DT(long userId, 818 int deliveryType, int start, int end, 819 OrderByComparator<UserNotificationEvent> orderByComparator) { 820 return getPersistence() 821 .findByU_DT(userId, deliveryType, start, end, 822 orderByComparator); 823 } 824 825 /** 826 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 830 * </p> 831 * 832 * @param userId the user ID 833 * @param deliveryType the delivery type 834 * @param start the lower bound of the range of user notification events 835 * @param end the upper bound of the range of user notification events (not inclusive) 836 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 837 * @param retrieveFromCache whether to retrieve from the finder cache 838 * @return the ordered range of matching user notification events 839 */ 840 public static List<UserNotificationEvent> findByU_DT(long userId, 841 int deliveryType, int start, int end, 842 OrderByComparator<UserNotificationEvent> orderByComparator, 843 boolean retrieveFromCache) { 844 return getPersistence() 845 .findByU_DT(userId, deliveryType, start, end, 846 orderByComparator, retrieveFromCache); 847 } 848 849 /** 850 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ?. 851 * 852 * @param userId the user ID 853 * @param deliveryType the delivery type 854 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 855 * @return the first matching user notification event 856 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 857 */ 858 public static UserNotificationEvent findByU_DT_First(long userId, 859 int deliveryType, 860 OrderByComparator<UserNotificationEvent> orderByComparator) 861 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 862 return getPersistence() 863 .findByU_DT_First(userId, deliveryType, orderByComparator); 864 } 865 866 /** 867 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ?. 868 * 869 * @param userId the user ID 870 * @param deliveryType the delivery type 871 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 872 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 873 */ 874 public static UserNotificationEvent fetchByU_DT_First(long userId, 875 int deliveryType, 876 OrderByComparator<UserNotificationEvent> orderByComparator) { 877 return getPersistence() 878 .fetchByU_DT_First(userId, deliveryType, orderByComparator); 879 } 880 881 /** 882 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ?. 883 * 884 * @param userId the user ID 885 * @param deliveryType the delivery type 886 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 887 * @return the last matching user notification event 888 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 889 */ 890 public static UserNotificationEvent findByU_DT_Last(long userId, 891 int deliveryType, 892 OrderByComparator<UserNotificationEvent> orderByComparator) 893 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 894 return getPersistence() 895 .findByU_DT_Last(userId, deliveryType, orderByComparator); 896 } 897 898 /** 899 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ?. 900 * 901 * @param userId the user ID 902 * @param deliveryType the delivery type 903 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 904 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 905 */ 906 public static UserNotificationEvent fetchByU_DT_Last(long userId, 907 int deliveryType, 908 OrderByComparator<UserNotificationEvent> orderByComparator) { 909 return getPersistence() 910 .fetchByU_DT_Last(userId, deliveryType, orderByComparator); 911 } 912 913 /** 914 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ?. 915 * 916 * @param userNotificationEventId the primary key of the current user notification event 917 * @param userId the user ID 918 * @param deliveryType the delivery type 919 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 920 * @return the previous, current, and next user notification event 921 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 922 */ 923 public static UserNotificationEvent[] findByU_DT_PrevAndNext( 924 long userNotificationEventId, long userId, int deliveryType, 925 OrderByComparator<UserNotificationEvent> orderByComparator) 926 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 927 return getPersistence() 928 .findByU_DT_PrevAndNext(userNotificationEventId, userId, 929 deliveryType, orderByComparator); 930 } 931 932 /** 933 * Removes all the user notification events where userId = ? and deliveryType = ? from the database. 934 * 935 * @param userId the user ID 936 * @param deliveryType the delivery type 937 */ 938 public static void removeByU_DT(long userId, int deliveryType) { 939 getPersistence().removeByU_DT(userId, deliveryType); 940 } 941 942 /** 943 * Returns the number of user notification events where userId = ? and deliveryType = ?. 944 * 945 * @param userId the user ID 946 * @param deliveryType the delivery type 947 * @return the number of matching user notification events 948 */ 949 public static int countByU_DT(long userId, int deliveryType) { 950 return getPersistence().countByU_DT(userId, deliveryType); 951 } 952 953 /** 954 * Returns all the user notification events where userId = ? and delivered = ?. 955 * 956 * @param userId the user ID 957 * @param delivered the delivered 958 * @return the matching user notification events 959 */ 960 public static List<UserNotificationEvent> findByU_D(long userId, 961 boolean delivered) { 962 return getPersistence().findByU_D(userId, delivered); 963 } 964 965 /** 966 * Returns a range of all the user notification events where userId = ? and delivered = ?. 967 * 968 * <p> 969 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 970 * </p> 971 * 972 * @param userId the user ID 973 * @param delivered the delivered 974 * @param start the lower bound of the range of user notification events 975 * @param end the upper bound of the range of user notification events (not inclusive) 976 * @return the range of matching user notification events 977 */ 978 public static List<UserNotificationEvent> findByU_D(long userId, 979 boolean delivered, int start, int end) { 980 return getPersistence().findByU_D(userId, delivered, start, end); 981 } 982 983 /** 984 * Returns an ordered range of all the user notification events where userId = ? and delivered = ?. 985 * 986 * <p> 987 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 988 * </p> 989 * 990 * @param userId the user ID 991 * @param delivered the delivered 992 * @param start the lower bound of the range of user notification events 993 * @param end the upper bound of the range of user notification events (not inclusive) 994 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 995 * @return the ordered range of matching user notification events 996 */ 997 public static List<UserNotificationEvent> findByU_D(long userId, 998 boolean delivered, int start, int end, 999 OrderByComparator<UserNotificationEvent> orderByComparator) { 1000 return getPersistence() 1001 .findByU_D(userId, delivered, start, end, orderByComparator); 1002 } 1003 1004 /** 1005 * Returns an ordered range of all the user notification events where userId = ? and delivered = ?. 1006 * 1007 * <p> 1008 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1009 * </p> 1010 * 1011 * @param userId the user ID 1012 * @param delivered the delivered 1013 * @param start the lower bound of the range of user notification events 1014 * @param end the upper bound of the range of user notification events (not inclusive) 1015 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1016 * @param retrieveFromCache whether to retrieve from the finder cache 1017 * @return the ordered range of matching user notification events 1018 */ 1019 public static List<UserNotificationEvent> findByU_D(long userId, 1020 boolean delivered, int start, int end, 1021 OrderByComparator<UserNotificationEvent> orderByComparator, 1022 boolean retrieveFromCache) { 1023 return getPersistence() 1024 .findByU_D(userId, delivered, start, end, orderByComparator, 1025 retrieveFromCache); 1026 } 1027 1028 /** 1029 * Returns the first user notification event in the ordered set where userId = ? and delivered = ?. 1030 * 1031 * @param userId the user ID 1032 * @param delivered the delivered 1033 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1034 * @return the first matching user notification event 1035 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1036 */ 1037 public static UserNotificationEvent findByU_D_First(long userId, 1038 boolean delivered, 1039 OrderByComparator<UserNotificationEvent> orderByComparator) 1040 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1041 return getPersistence() 1042 .findByU_D_First(userId, delivered, orderByComparator); 1043 } 1044 1045 /** 1046 * Returns the first user notification event in the ordered set where userId = ? and delivered = ?. 1047 * 1048 * @param userId the user ID 1049 * @param delivered the delivered 1050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1051 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1052 */ 1053 public static UserNotificationEvent fetchByU_D_First(long userId, 1054 boolean delivered, 1055 OrderByComparator<UserNotificationEvent> orderByComparator) { 1056 return getPersistence() 1057 .fetchByU_D_First(userId, delivered, orderByComparator); 1058 } 1059 1060 /** 1061 * Returns the last user notification event in the ordered set where userId = ? and delivered = ?. 1062 * 1063 * @param userId the user ID 1064 * @param delivered the delivered 1065 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1066 * @return the last matching user notification event 1067 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1068 */ 1069 public static UserNotificationEvent findByU_D_Last(long userId, 1070 boolean delivered, 1071 OrderByComparator<UserNotificationEvent> orderByComparator) 1072 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1073 return getPersistence() 1074 .findByU_D_Last(userId, delivered, orderByComparator); 1075 } 1076 1077 /** 1078 * Returns the last user notification event in the ordered set where userId = ? and delivered = ?. 1079 * 1080 * @param userId the user ID 1081 * @param delivered the delivered 1082 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1083 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1084 */ 1085 public static UserNotificationEvent fetchByU_D_Last(long userId, 1086 boolean delivered, 1087 OrderByComparator<UserNotificationEvent> orderByComparator) { 1088 return getPersistence() 1089 .fetchByU_D_Last(userId, delivered, orderByComparator); 1090 } 1091 1092 /** 1093 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and delivered = ?. 1094 * 1095 * @param userNotificationEventId the primary key of the current user notification event 1096 * @param userId the user ID 1097 * @param delivered the delivered 1098 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1099 * @return the previous, current, and next user notification event 1100 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1101 */ 1102 public static UserNotificationEvent[] findByU_D_PrevAndNext( 1103 long userNotificationEventId, long userId, boolean delivered, 1104 OrderByComparator<UserNotificationEvent> orderByComparator) 1105 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1106 return getPersistence() 1107 .findByU_D_PrevAndNext(userNotificationEventId, userId, 1108 delivered, orderByComparator); 1109 } 1110 1111 /** 1112 * Removes all the user notification events where userId = ? and delivered = ? from the database. 1113 * 1114 * @param userId the user ID 1115 * @param delivered the delivered 1116 */ 1117 public static void removeByU_D(long userId, boolean delivered) { 1118 getPersistence().removeByU_D(userId, delivered); 1119 } 1120 1121 /** 1122 * Returns the number of user notification events where userId = ? and delivered = ?. 1123 * 1124 * @param userId the user ID 1125 * @param delivered the delivered 1126 * @return the number of matching user notification events 1127 */ 1128 public static int countByU_D(long userId, boolean delivered) { 1129 return getPersistence().countByU_D(userId, delivered); 1130 } 1131 1132 /** 1133 * Returns all the user notification events where userId = ? and archived = ?. 1134 * 1135 * @param userId the user ID 1136 * @param archived the archived 1137 * @return the matching user notification events 1138 */ 1139 public static List<UserNotificationEvent> findByU_A(long userId, 1140 boolean archived) { 1141 return getPersistence().findByU_A(userId, archived); 1142 } 1143 1144 /** 1145 * Returns a range of all the user notification events where userId = ? and archived = ?. 1146 * 1147 * <p> 1148 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1149 * </p> 1150 * 1151 * @param userId the user ID 1152 * @param archived the archived 1153 * @param start the lower bound of the range of user notification events 1154 * @param end the upper bound of the range of user notification events (not inclusive) 1155 * @return the range of matching user notification events 1156 */ 1157 public static List<UserNotificationEvent> findByU_A(long userId, 1158 boolean archived, int start, int end) { 1159 return getPersistence().findByU_A(userId, archived, start, end); 1160 } 1161 1162 /** 1163 * Returns an ordered range of all the user notification events where userId = ? and archived = ?. 1164 * 1165 * <p> 1166 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1167 * </p> 1168 * 1169 * @param userId the user ID 1170 * @param archived the archived 1171 * @param start the lower bound of the range of user notification events 1172 * @param end the upper bound of the range of user notification events (not inclusive) 1173 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1174 * @return the ordered range of matching user notification events 1175 */ 1176 public static List<UserNotificationEvent> findByU_A(long userId, 1177 boolean archived, int start, int end, 1178 OrderByComparator<UserNotificationEvent> orderByComparator) { 1179 return getPersistence() 1180 .findByU_A(userId, archived, start, end, orderByComparator); 1181 } 1182 1183 /** 1184 * Returns an ordered range of all the user notification events where userId = ? and archived = ?. 1185 * 1186 * <p> 1187 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1188 * </p> 1189 * 1190 * @param userId the user ID 1191 * @param archived the archived 1192 * @param start the lower bound of the range of user notification events 1193 * @param end the upper bound of the range of user notification events (not inclusive) 1194 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1195 * @param retrieveFromCache whether to retrieve from the finder cache 1196 * @return the ordered range of matching user notification events 1197 */ 1198 public static List<UserNotificationEvent> findByU_A(long userId, 1199 boolean archived, int start, int end, 1200 OrderByComparator<UserNotificationEvent> orderByComparator, 1201 boolean retrieveFromCache) { 1202 return getPersistence() 1203 .findByU_A(userId, archived, start, end, orderByComparator, 1204 retrieveFromCache); 1205 } 1206 1207 /** 1208 * Returns the first user notification event in the ordered set where userId = ? and archived = ?. 1209 * 1210 * @param userId the user ID 1211 * @param archived the archived 1212 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1213 * @return the first matching user notification event 1214 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1215 */ 1216 public static UserNotificationEvent findByU_A_First(long userId, 1217 boolean archived, 1218 OrderByComparator<UserNotificationEvent> orderByComparator) 1219 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1220 return getPersistence() 1221 .findByU_A_First(userId, archived, orderByComparator); 1222 } 1223 1224 /** 1225 * Returns the first user notification event in the ordered set where userId = ? and archived = ?. 1226 * 1227 * @param userId the user ID 1228 * @param archived the archived 1229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1230 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1231 */ 1232 public static UserNotificationEvent fetchByU_A_First(long userId, 1233 boolean archived, 1234 OrderByComparator<UserNotificationEvent> orderByComparator) { 1235 return getPersistence() 1236 .fetchByU_A_First(userId, archived, orderByComparator); 1237 } 1238 1239 /** 1240 * Returns the last user notification event in the ordered set where userId = ? and archived = ?. 1241 * 1242 * @param userId the user ID 1243 * @param archived the archived 1244 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1245 * @return the last matching user notification event 1246 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1247 */ 1248 public static UserNotificationEvent findByU_A_Last(long userId, 1249 boolean archived, 1250 OrderByComparator<UserNotificationEvent> orderByComparator) 1251 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1252 return getPersistence() 1253 .findByU_A_Last(userId, archived, orderByComparator); 1254 } 1255 1256 /** 1257 * Returns the last user notification event in the ordered set where userId = ? and archived = ?. 1258 * 1259 * @param userId the user ID 1260 * @param archived the archived 1261 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1262 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1263 */ 1264 public static UserNotificationEvent fetchByU_A_Last(long userId, 1265 boolean archived, 1266 OrderByComparator<UserNotificationEvent> orderByComparator) { 1267 return getPersistence() 1268 .fetchByU_A_Last(userId, archived, orderByComparator); 1269 } 1270 1271 /** 1272 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and archived = ?. 1273 * 1274 * @param userNotificationEventId the primary key of the current user notification event 1275 * @param userId the user ID 1276 * @param archived the archived 1277 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1278 * @return the previous, current, and next user notification event 1279 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1280 */ 1281 public static UserNotificationEvent[] findByU_A_PrevAndNext( 1282 long userNotificationEventId, long userId, boolean archived, 1283 OrderByComparator<UserNotificationEvent> orderByComparator) 1284 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1285 return getPersistence() 1286 .findByU_A_PrevAndNext(userNotificationEventId, userId, 1287 archived, orderByComparator); 1288 } 1289 1290 /** 1291 * Removes all the user notification events where userId = ? and archived = ? from the database. 1292 * 1293 * @param userId the user ID 1294 * @param archived the archived 1295 */ 1296 public static void removeByU_A(long userId, boolean archived) { 1297 getPersistence().removeByU_A(userId, archived); 1298 } 1299 1300 /** 1301 * Returns the number of user notification events where userId = ? and archived = ?. 1302 * 1303 * @param userId the user ID 1304 * @param archived the archived 1305 * @return the number of matching user notification events 1306 */ 1307 public static int countByU_A(long userId, boolean archived) { 1308 return getPersistence().countByU_A(userId, archived); 1309 } 1310 1311 /** 1312 * Returns all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1313 * 1314 * @param userId the user ID 1315 * @param deliveryType the delivery type 1316 * @param delivered the delivered 1317 * @return the matching user notification events 1318 */ 1319 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1320 int deliveryType, boolean delivered) { 1321 return getPersistence().findByU_DT_D(userId, deliveryType, delivered); 1322 } 1323 1324 /** 1325 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1326 * 1327 * <p> 1328 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1329 * </p> 1330 * 1331 * @param userId the user ID 1332 * @param deliveryType the delivery type 1333 * @param delivered the delivered 1334 * @param start the lower bound of the range of user notification events 1335 * @param end the upper bound of the range of user notification events (not inclusive) 1336 * @return the range of matching user notification events 1337 */ 1338 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1339 int deliveryType, boolean delivered, int start, int end) { 1340 return getPersistence() 1341 .findByU_DT_D(userId, deliveryType, delivered, start, end); 1342 } 1343 1344 /** 1345 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1346 * 1347 * <p> 1348 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1349 * </p> 1350 * 1351 * @param userId the user ID 1352 * @param deliveryType the delivery type 1353 * @param delivered the delivered 1354 * @param start the lower bound of the range of user notification events 1355 * @param end the upper bound of the range of user notification events (not inclusive) 1356 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1357 * @return the ordered range of matching user notification events 1358 */ 1359 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1360 int deliveryType, boolean delivered, int start, int end, 1361 OrderByComparator<UserNotificationEvent> orderByComparator) { 1362 return getPersistence() 1363 .findByU_DT_D(userId, deliveryType, delivered, start, end, 1364 orderByComparator); 1365 } 1366 1367 /** 1368 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1369 * 1370 * <p> 1371 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1372 * </p> 1373 * 1374 * @param userId the user ID 1375 * @param deliveryType the delivery type 1376 * @param delivered the delivered 1377 * @param start the lower bound of the range of user notification events 1378 * @param end the upper bound of the range of user notification events (not inclusive) 1379 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1380 * @param retrieveFromCache whether to retrieve from the finder cache 1381 * @return the ordered range of matching user notification events 1382 */ 1383 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1384 int deliveryType, boolean delivered, int start, int end, 1385 OrderByComparator<UserNotificationEvent> orderByComparator, 1386 boolean retrieveFromCache) { 1387 return getPersistence() 1388 .findByU_DT_D(userId, deliveryType, delivered, start, end, 1389 orderByComparator, retrieveFromCache); 1390 } 1391 1392 /** 1393 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1394 * 1395 * @param userId the user ID 1396 * @param deliveryType the delivery type 1397 * @param delivered the delivered 1398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1399 * @return the first matching user notification event 1400 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1401 */ 1402 public static UserNotificationEvent findByU_DT_D_First(long userId, 1403 int deliveryType, boolean delivered, 1404 OrderByComparator<UserNotificationEvent> orderByComparator) 1405 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1406 return getPersistence() 1407 .findByU_DT_D_First(userId, deliveryType, delivered, 1408 orderByComparator); 1409 } 1410 1411 /** 1412 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1413 * 1414 * @param userId the user ID 1415 * @param deliveryType the delivery type 1416 * @param delivered the delivered 1417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1418 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1419 */ 1420 public static UserNotificationEvent fetchByU_DT_D_First(long userId, 1421 int deliveryType, boolean delivered, 1422 OrderByComparator<UserNotificationEvent> orderByComparator) { 1423 return getPersistence() 1424 .fetchByU_DT_D_First(userId, deliveryType, delivered, 1425 orderByComparator); 1426 } 1427 1428 /** 1429 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1430 * 1431 * @param userId the user ID 1432 * @param deliveryType the delivery type 1433 * @param delivered the delivered 1434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1435 * @return the last matching user notification event 1436 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1437 */ 1438 public static UserNotificationEvent findByU_DT_D_Last(long userId, 1439 int deliveryType, boolean delivered, 1440 OrderByComparator<UserNotificationEvent> orderByComparator) 1441 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1442 return getPersistence() 1443 .findByU_DT_D_Last(userId, deliveryType, delivered, 1444 orderByComparator); 1445 } 1446 1447 /** 1448 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1449 * 1450 * @param userId the user ID 1451 * @param deliveryType the delivery type 1452 * @param delivered the delivered 1453 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1454 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1455 */ 1456 public static UserNotificationEvent fetchByU_DT_D_Last(long userId, 1457 int deliveryType, boolean delivered, 1458 OrderByComparator<UserNotificationEvent> orderByComparator) { 1459 return getPersistence() 1460 .fetchByU_DT_D_Last(userId, deliveryType, delivered, 1461 orderByComparator); 1462 } 1463 1464 /** 1465 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1466 * 1467 * @param userNotificationEventId the primary key of the current user notification event 1468 * @param userId the user ID 1469 * @param deliveryType the delivery type 1470 * @param delivered the delivered 1471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1472 * @return the previous, current, and next user notification event 1473 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1474 */ 1475 public static UserNotificationEvent[] findByU_DT_D_PrevAndNext( 1476 long userNotificationEventId, long userId, int deliveryType, 1477 boolean delivered, 1478 OrderByComparator<UserNotificationEvent> orderByComparator) 1479 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1480 return getPersistence() 1481 .findByU_DT_D_PrevAndNext(userNotificationEventId, userId, 1482 deliveryType, delivered, orderByComparator); 1483 } 1484 1485 /** 1486 * Removes all the user notification events where userId = ? and deliveryType = ? and delivered = ? from the database. 1487 * 1488 * @param userId the user ID 1489 * @param deliveryType the delivery type 1490 * @param delivered the delivered 1491 */ 1492 public static void removeByU_DT_D(long userId, int deliveryType, 1493 boolean delivered) { 1494 getPersistence().removeByU_DT_D(userId, deliveryType, delivered); 1495 } 1496 1497 /** 1498 * Returns the number of user notification events where userId = ? and deliveryType = ? and delivered = ?. 1499 * 1500 * @param userId the user ID 1501 * @param deliveryType the delivery type 1502 * @param delivered the delivered 1503 * @return the number of matching user notification events 1504 */ 1505 public static int countByU_DT_D(long userId, int deliveryType, 1506 boolean delivered) { 1507 return getPersistence().countByU_DT_D(userId, deliveryType, delivered); 1508 } 1509 1510 /** 1511 * Returns all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1512 * 1513 * @param userId the user ID 1514 * @param deliveryType the delivery type 1515 * @param archived the archived 1516 * @return the matching user notification events 1517 */ 1518 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1519 int deliveryType, boolean archived) { 1520 return getPersistence().findByU_DT_A(userId, deliveryType, archived); 1521 } 1522 1523 /** 1524 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1525 * 1526 * <p> 1527 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1528 * </p> 1529 * 1530 * @param userId the user ID 1531 * @param deliveryType the delivery type 1532 * @param archived the archived 1533 * @param start the lower bound of the range of user notification events 1534 * @param end the upper bound of the range of user notification events (not inclusive) 1535 * @return the range of matching user notification events 1536 */ 1537 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1538 int deliveryType, boolean archived, int start, int end) { 1539 return getPersistence() 1540 .findByU_DT_A(userId, deliveryType, archived, start, end); 1541 } 1542 1543 /** 1544 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1545 * 1546 * <p> 1547 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1548 * </p> 1549 * 1550 * @param userId the user ID 1551 * @param deliveryType the delivery type 1552 * @param archived the archived 1553 * @param start the lower bound of the range of user notification events 1554 * @param end the upper bound of the range of user notification events (not inclusive) 1555 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1556 * @return the ordered range of matching user notification events 1557 */ 1558 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1559 int deliveryType, boolean archived, int start, int end, 1560 OrderByComparator<UserNotificationEvent> orderByComparator) { 1561 return getPersistence() 1562 .findByU_DT_A(userId, deliveryType, archived, start, end, 1563 orderByComparator); 1564 } 1565 1566 /** 1567 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1568 * 1569 * <p> 1570 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1571 * </p> 1572 * 1573 * @param userId the user ID 1574 * @param deliveryType the delivery type 1575 * @param archived the archived 1576 * @param start the lower bound of the range of user notification events 1577 * @param end the upper bound of the range of user notification events (not inclusive) 1578 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1579 * @param retrieveFromCache whether to retrieve from the finder cache 1580 * @return the ordered range of matching user notification events 1581 */ 1582 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1583 int deliveryType, boolean archived, int start, int end, 1584 OrderByComparator<UserNotificationEvent> orderByComparator, 1585 boolean retrieveFromCache) { 1586 return getPersistence() 1587 .findByU_DT_A(userId, deliveryType, archived, start, end, 1588 orderByComparator, retrieveFromCache); 1589 } 1590 1591 /** 1592 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1593 * 1594 * @param userId the user ID 1595 * @param deliveryType the delivery type 1596 * @param archived the archived 1597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1598 * @return the first matching user notification event 1599 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1600 */ 1601 public static UserNotificationEvent findByU_DT_A_First(long userId, 1602 int deliveryType, boolean archived, 1603 OrderByComparator<UserNotificationEvent> orderByComparator) 1604 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1605 return getPersistence() 1606 .findByU_DT_A_First(userId, deliveryType, archived, 1607 orderByComparator); 1608 } 1609 1610 /** 1611 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1612 * 1613 * @param userId the user ID 1614 * @param deliveryType the delivery type 1615 * @param archived the archived 1616 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1617 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1618 */ 1619 public static UserNotificationEvent fetchByU_DT_A_First(long userId, 1620 int deliveryType, boolean archived, 1621 OrderByComparator<UserNotificationEvent> orderByComparator) { 1622 return getPersistence() 1623 .fetchByU_DT_A_First(userId, deliveryType, archived, 1624 orderByComparator); 1625 } 1626 1627 /** 1628 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1629 * 1630 * @param userId the user ID 1631 * @param deliveryType the delivery type 1632 * @param archived the archived 1633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1634 * @return the last matching user notification event 1635 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1636 */ 1637 public static UserNotificationEvent findByU_DT_A_Last(long userId, 1638 int deliveryType, boolean archived, 1639 OrderByComparator<UserNotificationEvent> orderByComparator) 1640 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1641 return getPersistence() 1642 .findByU_DT_A_Last(userId, deliveryType, archived, 1643 orderByComparator); 1644 } 1645 1646 /** 1647 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1648 * 1649 * @param userId the user ID 1650 * @param deliveryType the delivery type 1651 * @param archived the archived 1652 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1653 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1654 */ 1655 public static UserNotificationEvent fetchByU_DT_A_Last(long userId, 1656 int deliveryType, boolean archived, 1657 OrderByComparator<UserNotificationEvent> orderByComparator) { 1658 return getPersistence() 1659 .fetchByU_DT_A_Last(userId, deliveryType, archived, 1660 orderByComparator); 1661 } 1662 1663 /** 1664 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1665 * 1666 * @param userNotificationEventId the primary key of the current user notification event 1667 * @param userId the user ID 1668 * @param deliveryType the delivery type 1669 * @param archived the archived 1670 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1671 * @return the previous, current, and next user notification event 1672 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1673 */ 1674 public static UserNotificationEvent[] findByU_DT_A_PrevAndNext( 1675 long userNotificationEventId, long userId, int deliveryType, 1676 boolean archived, 1677 OrderByComparator<UserNotificationEvent> orderByComparator) 1678 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1679 return getPersistence() 1680 .findByU_DT_A_PrevAndNext(userNotificationEventId, userId, 1681 deliveryType, archived, orderByComparator); 1682 } 1683 1684 /** 1685 * Removes all the user notification events where userId = ? and deliveryType = ? and archived = ? from the database. 1686 * 1687 * @param userId the user ID 1688 * @param deliveryType the delivery type 1689 * @param archived the archived 1690 */ 1691 public static void removeByU_DT_A(long userId, int deliveryType, 1692 boolean archived) { 1693 getPersistence().removeByU_DT_A(userId, deliveryType, archived); 1694 } 1695 1696 /** 1697 * Returns the number of user notification events where userId = ? and deliveryType = ? and archived = ?. 1698 * 1699 * @param userId the user ID 1700 * @param deliveryType the delivery type 1701 * @param archived the archived 1702 * @return the number of matching user notification events 1703 */ 1704 public static int countByU_DT_A(long userId, int deliveryType, 1705 boolean archived) { 1706 return getPersistence().countByU_DT_A(userId, deliveryType, archived); 1707 } 1708 1709 /** 1710 * Returns all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1711 * 1712 * @param userId the user ID 1713 * @param delivered the delivered 1714 * @param actionRequired the action required 1715 * @return the matching user notification events 1716 */ 1717 public static List<UserNotificationEvent> findByU_D_A(long userId, 1718 boolean delivered, boolean actionRequired) { 1719 return getPersistence().findByU_D_A(userId, delivered, actionRequired); 1720 } 1721 1722 /** 1723 * Returns a range of all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1724 * 1725 * <p> 1726 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1727 * </p> 1728 * 1729 * @param userId the user ID 1730 * @param delivered the delivered 1731 * @param actionRequired the action required 1732 * @param start the lower bound of the range of user notification events 1733 * @param end the upper bound of the range of user notification events (not inclusive) 1734 * @return the range of matching user notification events 1735 */ 1736 public static List<UserNotificationEvent> findByU_D_A(long userId, 1737 boolean delivered, boolean actionRequired, int start, int end) { 1738 return getPersistence() 1739 .findByU_D_A(userId, delivered, actionRequired, start, end); 1740 } 1741 1742 /** 1743 * Returns an ordered range of all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1744 * 1745 * <p> 1746 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1747 * </p> 1748 * 1749 * @param userId the user ID 1750 * @param delivered the delivered 1751 * @param actionRequired the action required 1752 * @param start the lower bound of the range of user notification events 1753 * @param end the upper bound of the range of user notification events (not inclusive) 1754 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1755 * @return the ordered range of matching user notification events 1756 */ 1757 public static List<UserNotificationEvent> findByU_D_A(long userId, 1758 boolean delivered, boolean actionRequired, int start, int end, 1759 OrderByComparator<UserNotificationEvent> orderByComparator) { 1760 return getPersistence() 1761 .findByU_D_A(userId, delivered, actionRequired, start, end, 1762 orderByComparator); 1763 } 1764 1765 /** 1766 * Returns an ordered range of all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1767 * 1768 * <p> 1769 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1770 * </p> 1771 * 1772 * @param userId the user ID 1773 * @param delivered the delivered 1774 * @param actionRequired the action required 1775 * @param start the lower bound of the range of user notification events 1776 * @param end the upper bound of the range of user notification events (not inclusive) 1777 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1778 * @param retrieveFromCache whether to retrieve from the finder cache 1779 * @return the ordered range of matching user notification events 1780 */ 1781 public static List<UserNotificationEvent> findByU_D_A(long userId, 1782 boolean delivered, boolean actionRequired, int start, int end, 1783 OrderByComparator<UserNotificationEvent> orderByComparator, 1784 boolean retrieveFromCache) { 1785 return getPersistence() 1786 .findByU_D_A(userId, delivered, actionRequired, start, end, 1787 orderByComparator, retrieveFromCache); 1788 } 1789 1790 /** 1791 * Returns the first user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1792 * 1793 * @param userId the user ID 1794 * @param delivered the delivered 1795 * @param actionRequired the action required 1796 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1797 * @return the first matching user notification event 1798 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1799 */ 1800 public static UserNotificationEvent findByU_D_A_First(long userId, 1801 boolean delivered, boolean actionRequired, 1802 OrderByComparator<UserNotificationEvent> orderByComparator) 1803 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1804 return getPersistence() 1805 .findByU_D_A_First(userId, delivered, actionRequired, 1806 orderByComparator); 1807 } 1808 1809 /** 1810 * Returns the first user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1811 * 1812 * @param userId the user ID 1813 * @param delivered the delivered 1814 * @param actionRequired the action required 1815 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1816 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1817 */ 1818 public static UserNotificationEvent fetchByU_D_A_First(long userId, 1819 boolean delivered, boolean actionRequired, 1820 OrderByComparator<UserNotificationEvent> orderByComparator) { 1821 return getPersistence() 1822 .fetchByU_D_A_First(userId, delivered, actionRequired, 1823 orderByComparator); 1824 } 1825 1826 /** 1827 * Returns the last user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1828 * 1829 * @param userId the user ID 1830 * @param delivered the delivered 1831 * @param actionRequired the action required 1832 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1833 * @return the last matching user notification event 1834 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1835 */ 1836 public static UserNotificationEvent findByU_D_A_Last(long userId, 1837 boolean delivered, boolean actionRequired, 1838 OrderByComparator<UserNotificationEvent> orderByComparator) 1839 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1840 return getPersistence() 1841 .findByU_D_A_Last(userId, delivered, actionRequired, 1842 orderByComparator); 1843 } 1844 1845 /** 1846 * Returns the last user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1847 * 1848 * @param userId the user ID 1849 * @param delivered the delivered 1850 * @param actionRequired the action required 1851 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1852 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1853 */ 1854 public static UserNotificationEvent fetchByU_D_A_Last(long userId, 1855 boolean delivered, boolean actionRequired, 1856 OrderByComparator<UserNotificationEvent> orderByComparator) { 1857 return getPersistence() 1858 .fetchByU_D_A_Last(userId, delivered, actionRequired, 1859 orderByComparator); 1860 } 1861 1862 /** 1863 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1864 * 1865 * @param userNotificationEventId the primary key of the current user notification event 1866 * @param userId the user ID 1867 * @param delivered the delivered 1868 * @param actionRequired the action required 1869 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1870 * @return the previous, current, and next user notification event 1871 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1872 */ 1873 public static UserNotificationEvent[] findByU_D_A_PrevAndNext( 1874 long userNotificationEventId, long userId, boolean delivered, 1875 boolean actionRequired, 1876 OrderByComparator<UserNotificationEvent> orderByComparator) 1877 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 1878 return getPersistence() 1879 .findByU_D_A_PrevAndNext(userNotificationEventId, userId, 1880 delivered, actionRequired, orderByComparator); 1881 } 1882 1883 /** 1884 * Removes all the user notification events where userId = ? and delivered = ? and actionRequired = ? from the database. 1885 * 1886 * @param userId the user ID 1887 * @param delivered the delivered 1888 * @param actionRequired the action required 1889 */ 1890 public static void removeByU_D_A(long userId, boolean delivered, 1891 boolean actionRequired) { 1892 getPersistence().removeByU_D_A(userId, delivered, actionRequired); 1893 } 1894 1895 /** 1896 * Returns the number of user notification events where userId = ? and delivered = ? and actionRequired = ?. 1897 * 1898 * @param userId the user ID 1899 * @param delivered the delivered 1900 * @param actionRequired the action required 1901 * @return the number of matching user notification events 1902 */ 1903 public static int countByU_D_A(long userId, boolean delivered, 1904 boolean actionRequired) { 1905 return getPersistence().countByU_D_A(userId, delivered, actionRequired); 1906 } 1907 1908 /** 1909 * Returns all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1910 * 1911 * @param userId the user ID 1912 * @param actionRequired the action required 1913 * @param archived the archived 1914 * @return the matching user notification events 1915 */ 1916 public static List<UserNotificationEvent> findByU_A_A(long userId, 1917 boolean actionRequired, boolean archived) { 1918 return getPersistence().findByU_A_A(userId, actionRequired, archived); 1919 } 1920 1921 /** 1922 * Returns a range of all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1923 * 1924 * <p> 1925 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1926 * </p> 1927 * 1928 * @param userId the user ID 1929 * @param actionRequired the action required 1930 * @param archived the archived 1931 * @param start the lower bound of the range of user notification events 1932 * @param end the upper bound of the range of user notification events (not inclusive) 1933 * @return the range of matching user notification events 1934 */ 1935 public static List<UserNotificationEvent> findByU_A_A(long userId, 1936 boolean actionRequired, boolean archived, int start, int end) { 1937 return getPersistence() 1938 .findByU_A_A(userId, actionRequired, archived, start, end); 1939 } 1940 1941 /** 1942 * Returns an ordered range of all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1943 * 1944 * <p> 1945 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1946 * </p> 1947 * 1948 * @param userId the user ID 1949 * @param actionRequired the action required 1950 * @param archived the archived 1951 * @param start the lower bound of the range of user notification events 1952 * @param end the upper bound of the range of user notification events (not inclusive) 1953 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1954 * @return the ordered range of matching user notification events 1955 */ 1956 public static List<UserNotificationEvent> findByU_A_A(long userId, 1957 boolean actionRequired, boolean archived, int start, int end, 1958 OrderByComparator<UserNotificationEvent> orderByComparator) { 1959 return getPersistence() 1960 .findByU_A_A(userId, actionRequired, archived, start, end, 1961 orderByComparator); 1962 } 1963 1964 /** 1965 * Returns an ordered range of all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1966 * 1967 * <p> 1968 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1969 * </p> 1970 * 1971 * @param userId the user ID 1972 * @param actionRequired the action required 1973 * @param archived the archived 1974 * @param start the lower bound of the range of user notification events 1975 * @param end the upper bound of the range of user notification events (not inclusive) 1976 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1977 * @param retrieveFromCache whether to retrieve from the finder cache 1978 * @return the ordered range of matching user notification events 1979 */ 1980 public static List<UserNotificationEvent> findByU_A_A(long userId, 1981 boolean actionRequired, boolean archived, int start, int end, 1982 OrderByComparator<UserNotificationEvent> orderByComparator, 1983 boolean retrieveFromCache) { 1984 return getPersistence() 1985 .findByU_A_A(userId, actionRequired, archived, start, end, 1986 orderByComparator, retrieveFromCache); 1987 } 1988 1989 /** 1990 * Returns the first user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1991 * 1992 * @param userId the user ID 1993 * @param actionRequired the action required 1994 * @param archived the archived 1995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1996 * @return the first matching user notification event 1997 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1998 */ 1999 public static UserNotificationEvent findByU_A_A_First(long userId, 2000 boolean actionRequired, boolean archived, 2001 OrderByComparator<UserNotificationEvent> orderByComparator) 2002 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2003 return getPersistence() 2004 .findByU_A_A_First(userId, actionRequired, archived, 2005 orderByComparator); 2006 } 2007 2008 /** 2009 * Returns the first user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 2010 * 2011 * @param userId the user ID 2012 * @param actionRequired the action required 2013 * @param archived the archived 2014 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2015 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 2016 */ 2017 public static UserNotificationEvent fetchByU_A_A_First(long userId, 2018 boolean actionRequired, boolean archived, 2019 OrderByComparator<UserNotificationEvent> orderByComparator) { 2020 return getPersistence() 2021 .fetchByU_A_A_First(userId, actionRequired, archived, 2022 orderByComparator); 2023 } 2024 2025 /** 2026 * Returns the last user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 2027 * 2028 * @param userId the user ID 2029 * @param actionRequired the action required 2030 * @param archived the archived 2031 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2032 * @return the last matching user notification event 2033 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2034 */ 2035 public static UserNotificationEvent findByU_A_A_Last(long userId, 2036 boolean actionRequired, boolean archived, 2037 OrderByComparator<UserNotificationEvent> orderByComparator) 2038 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2039 return getPersistence() 2040 .findByU_A_A_Last(userId, actionRequired, archived, 2041 orderByComparator); 2042 } 2043 2044 /** 2045 * Returns the last user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 2046 * 2047 * @param userId the user ID 2048 * @param actionRequired the action required 2049 * @param archived the archived 2050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2051 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 2052 */ 2053 public static UserNotificationEvent fetchByU_A_A_Last(long userId, 2054 boolean actionRequired, boolean archived, 2055 OrderByComparator<UserNotificationEvent> orderByComparator) { 2056 return getPersistence() 2057 .fetchByU_A_A_Last(userId, actionRequired, archived, 2058 orderByComparator); 2059 } 2060 2061 /** 2062 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 2063 * 2064 * @param userNotificationEventId the primary key of the current user notification event 2065 * @param userId the user ID 2066 * @param actionRequired the action required 2067 * @param archived the archived 2068 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2069 * @return the previous, current, and next user notification event 2070 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2071 */ 2072 public static UserNotificationEvent[] findByU_A_A_PrevAndNext( 2073 long userNotificationEventId, long userId, boolean actionRequired, 2074 boolean archived, 2075 OrderByComparator<UserNotificationEvent> orderByComparator) 2076 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2077 return getPersistence() 2078 .findByU_A_A_PrevAndNext(userNotificationEventId, userId, 2079 actionRequired, archived, orderByComparator); 2080 } 2081 2082 /** 2083 * Removes all the user notification events where userId = ? and actionRequired = ? and archived = ? from the database. 2084 * 2085 * @param userId the user ID 2086 * @param actionRequired the action required 2087 * @param archived the archived 2088 */ 2089 public static void removeByU_A_A(long userId, boolean actionRequired, 2090 boolean archived) { 2091 getPersistence().removeByU_A_A(userId, actionRequired, archived); 2092 } 2093 2094 /** 2095 * Returns the number of user notification events where userId = ? and actionRequired = ? and archived = ?. 2096 * 2097 * @param userId the user ID 2098 * @param actionRequired the action required 2099 * @param archived the archived 2100 * @return the number of matching user notification events 2101 */ 2102 public static int countByU_A_A(long userId, boolean actionRequired, 2103 boolean archived) { 2104 return getPersistence().countByU_A_A(userId, actionRequired, archived); 2105 } 2106 2107 /** 2108 * Returns all the user notification events where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2109 * 2110 * @param userId the user ID 2111 * @param type the type 2112 * @param deliveryType the delivery type 2113 * @param delivered the delivered 2114 * @return the matching user notification events 2115 */ 2116 public static List<UserNotificationEvent> findByU_T_DT_D(long userId, 2117 java.lang.String type, int deliveryType, boolean delivered) { 2118 return getPersistence() 2119 .findByU_T_DT_D(userId, type, deliveryType, delivered); 2120 } 2121 2122 /** 2123 * Returns a range of all the user notification events where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2124 * 2125 * <p> 2126 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2127 * </p> 2128 * 2129 * @param userId the user ID 2130 * @param type the type 2131 * @param deliveryType the delivery type 2132 * @param delivered the delivered 2133 * @param start the lower bound of the range of user notification events 2134 * @param end the upper bound of the range of user notification events (not inclusive) 2135 * @return the range of matching user notification events 2136 */ 2137 public static List<UserNotificationEvent> findByU_T_DT_D(long userId, 2138 java.lang.String type, int deliveryType, boolean delivered, int start, 2139 int end) { 2140 return getPersistence() 2141 .findByU_T_DT_D(userId, type, deliveryType, delivered, 2142 start, end); 2143 } 2144 2145 /** 2146 * Returns an ordered range of all the user notification events where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2147 * 2148 * <p> 2149 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2150 * </p> 2151 * 2152 * @param userId the user ID 2153 * @param type the type 2154 * @param deliveryType the delivery type 2155 * @param delivered the delivered 2156 * @param start the lower bound of the range of user notification events 2157 * @param end the upper bound of the range of user notification events (not inclusive) 2158 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2159 * @return the ordered range of matching user notification events 2160 */ 2161 public static List<UserNotificationEvent> findByU_T_DT_D(long userId, 2162 java.lang.String type, int deliveryType, boolean delivered, int start, 2163 int end, OrderByComparator<UserNotificationEvent> orderByComparator) { 2164 return getPersistence() 2165 .findByU_T_DT_D(userId, type, deliveryType, delivered, 2166 start, end, orderByComparator); 2167 } 2168 2169 /** 2170 * Returns an ordered range of all the user notification events where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2171 * 2172 * <p> 2173 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2174 * </p> 2175 * 2176 * @param userId the user ID 2177 * @param type the type 2178 * @param deliveryType the delivery type 2179 * @param delivered the delivered 2180 * @param start the lower bound of the range of user notification events 2181 * @param end the upper bound of the range of user notification events (not inclusive) 2182 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2183 * @param retrieveFromCache whether to retrieve from the finder cache 2184 * @return the ordered range of matching user notification events 2185 */ 2186 public static List<UserNotificationEvent> findByU_T_DT_D(long userId, 2187 java.lang.String type, int deliveryType, boolean delivered, int start, 2188 int end, OrderByComparator<UserNotificationEvent> orderByComparator, 2189 boolean retrieveFromCache) { 2190 return getPersistence() 2191 .findByU_T_DT_D(userId, type, deliveryType, delivered, 2192 start, end, orderByComparator, retrieveFromCache); 2193 } 2194 2195 /** 2196 * Returns the first user notification event in the ordered set where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2197 * 2198 * @param userId the user ID 2199 * @param type the type 2200 * @param deliveryType the delivery type 2201 * @param delivered the delivered 2202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2203 * @return the first matching user notification event 2204 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2205 */ 2206 public static UserNotificationEvent findByU_T_DT_D_First(long userId, 2207 java.lang.String type, int deliveryType, boolean delivered, 2208 OrderByComparator<UserNotificationEvent> orderByComparator) 2209 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2210 return getPersistence() 2211 .findByU_T_DT_D_First(userId, type, deliveryType, delivered, 2212 orderByComparator); 2213 } 2214 2215 /** 2216 * Returns the first user notification event in the ordered set where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2217 * 2218 * @param userId the user ID 2219 * @param type the type 2220 * @param deliveryType the delivery type 2221 * @param delivered the delivered 2222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2223 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 2224 */ 2225 public static UserNotificationEvent fetchByU_T_DT_D_First(long userId, 2226 java.lang.String type, int deliveryType, boolean delivered, 2227 OrderByComparator<UserNotificationEvent> orderByComparator) { 2228 return getPersistence() 2229 .fetchByU_T_DT_D_First(userId, type, deliveryType, 2230 delivered, orderByComparator); 2231 } 2232 2233 /** 2234 * Returns the last user notification event in the ordered set where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2235 * 2236 * @param userId the user ID 2237 * @param type the type 2238 * @param deliveryType the delivery type 2239 * @param delivered the delivered 2240 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2241 * @return the last matching user notification event 2242 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2243 */ 2244 public static UserNotificationEvent findByU_T_DT_D_Last(long userId, 2245 java.lang.String type, int deliveryType, boolean delivered, 2246 OrderByComparator<UserNotificationEvent> orderByComparator) 2247 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2248 return getPersistence() 2249 .findByU_T_DT_D_Last(userId, type, deliveryType, delivered, 2250 orderByComparator); 2251 } 2252 2253 /** 2254 * Returns the last user notification event in the ordered set where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2255 * 2256 * @param userId the user ID 2257 * @param type the type 2258 * @param deliveryType the delivery type 2259 * @param delivered the delivered 2260 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2261 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 2262 */ 2263 public static UserNotificationEvent fetchByU_T_DT_D_Last(long userId, 2264 java.lang.String type, int deliveryType, boolean delivered, 2265 OrderByComparator<UserNotificationEvent> orderByComparator) { 2266 return getPersistence() 2267 .fetchByU_T_DT_D_Last(userId, type, deliveryType, delivered, 2268 orderByComparator); 2269 } 2270 2271 /** 2272 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2273 * 2274 * @param userNotificationEventId the primary key of the current user notification event 2275 * @param userId the user ID 2276 * @param type the type 2277 * @param deliveryType the delivery type 2278 * @param delivered the delivered 2279 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2280 * @return the previous, current, and next user notification event 2281 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2282 */ 2283 public static UserNotificationEvent[] findByU_T_DT_D_PrevAndNext( 2284 long userNotificationEventId, long userId, java.lang.String type, 2285 int deliveryType, boolean delivered, 2286 OrderByComparator<UserNotificationEvent> orderByComparator) 2287 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2288 return getPersistence() 2289 .findByU_T_DT_D_PrevAndNext(userNotificationEventId, userId, 2290 type, deliveryType, delivered, orderByComparator); 2291 } 2292 2293 /** 2294 * Removes all the user notification events where userId = ? and type = ? and deliveryType = ? and delivered = ? from the database. 2295 * 2296 * @param userId the user ID 2297 * @param type the type 2298 * @param deliveryType the delivery type 2299 * @param delivered the delivered 2300 */ 2301 public static void removeByU_T_DT_D(long userId, java.lang.String type, 2302 int deliveryType, boolean delivered) { 2303 getPersistence().removeByU_T_DT_D(userId, type, deliveryType, delivered); 2304 } 2305 2306 /** 2307 * Returns the number of user notification events where userId = ? and type = ? and deliveryType = ? and delivered = ?. 2308 * 2309 * @param userId the user ID 2310 * @param type the type 2311 * @param deliveryType the delivery type 2312 * @param delivered the delivered 2313 * @return the number of matching user notification events 2314 */ 2315 public static int countByU_T_DT_D(long userId, java.lang.String type, 2316 int deliveryType, boolean delivered) { 2317 return getPersistence() 2318 .countByU_T_DT_D(userId, type, deliveryType, delivered); 2319 } 2320 2321 /** 2322 * Returns all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2323 * 2324 * @param userId the user ID 2325 * @param deliveryType the delivery type 2326 * @param delivered the delivered 2327 * @param actionRequired the action required 2328 * @return the matching user notification events 2329 */ 2330 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 2331 int deliveryType, boolean delivered, boolean actionRequired) { 2332 return getPersistence() 2333 .findByU_DT_D_A(userId, deliveryType, delivered, 2334 actionRequired); 2335 } 2336 2337 /** 2338 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2339 * 2340 * <p> 2341 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2342 * </p> 2343 * 2344 * @param userId the user ID 2345 * @param deliveryType the delivery type 2346 * @param delivered the delivered 2347 * @param actionRequired the action required 2348 * @param start the lower bound of the range of user notification events 2349 * @param end the upper bound of the range of user notification events (not inclusive) 2350 * @return the range of matching user notification events 2351 */ 2352 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 2353 int deliveryType, boolean delivered, boolean actionRequired, int start, 2354 int end) { 2355 return getPersistence() 2356 .findByU_DT_D_A(userId, deliveryType, delivered, 2357 actionRequired, start, end); 2358 } 2359 2360 /** 2361 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2362 * 2363 * <p> 2364 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2365 * </p> 2366 * 2367 * @param userId the user ID 2368 * @param deliveryType the delivery type 2369 * @param delivered the delivered 2370 * @param actionRequired the action required 2371 * @param start the lower bound of the range of user notification events 2372 * @param end the upper bound of the range of user notification events (not inclusive) 2373 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2374 * @return the ordered range of matching user notification events 2375 */ 2376 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 2377 int deliveryType, boolean delivered, boolean actionRequired, int start, 2378 int end, OrderByComparator<UserNotificationEvent> orderByComparator) { 2379 return getPersistence() 2380 .findByU_DT_D_A(userId, deliveryType, delivered, 2381 actionRequired, start, end, orderByComparator); 2382 } 2383 2384 /** 2385 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2386 * 2387 * <p> 2388 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2389 * </p> 2390 * 2391 * @param userId the user ID 2392 * @param deliveryType the delivery type 2393 * @param delivered the delivered 2394 * @param actionRequired the action required 2395 * @param start the lower bound of the range of user notification events 2396 * @param end the upper bound of the range of user notification events (not inclusive) 2397 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2398 * @param retrieveFromCache whether to retrieve from the finder cache 2399 * @return the ordered range of matching user notification events 2400 */ 2401 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 2402 int deliveryType, boolean delivered, boolean actionRequired, int start, 2403 int end, OrderByComparator<UserNotificationEvent> orderByComparator, 2404 boolean retrieveFromCache) { 2405 return getPersistence() 2406 .findByU_DT_D_A(userId, deliveryType, delivered, 2407 actionRequired, start, end, orderByComparator, retrieveFromCache); 2408 } 2409 2410 /** 2411 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2412 * 2413 * @param userId the user ID 2414 * @param deliveryType the delivery type 2415 * @param delivered the delivered 2416 * @param actionRequired the action required 2417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2418 * @return the first matching user notification event 2419 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2420 */ 2421 public static UserNotificationEvent findByU_DT_D_A_First(long userId, 2422 int deliveryType, boolean delivered, boolean actionRequired, 2423 OrderByComparator<UserNotificationEvent> orderByComparator) 2424 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2425 return getPersistence() 2426 .findByU_DT_D_A_First(userId, deliveryType, delivered, 2427 actionRequired, orderByComparator); 2428 } 2429 2430 /** 2431 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2432 * 2433 * @param userId the user ID 2434 * @param deliveryType the delivery type 2435 * @param delivered the delivered 2436 * @param actionRequired the action required 2437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2438 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 2439 */ 2440 public static UserNotificationEvent fetchByU_DT_D_A_First(long userId, 2441 int deliveryType, boolean delivered, boolean actionRequired, 2442 OrderByComparator<UserNotificationEvent> orderByComparator) { 2443 return getPersistence() 2444 .fetchByU_DT_D_A_First(userId, deliveryType, delivered, 2445 actionRequired, orderByComparator); 2446 } 2447 2448 /** 2449 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2450 * 2451 * @param userId the user ID 2452 * @param deliveryType the delivery type 2453 * @param delivered the delivered 2454 * @param actionRequired the action required 2455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2456 * @return the last matching user notification event 2457 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2458 */ 2459 public static UserNotificationEvent findByU_DT_D_A_Last(long userId, 2460 int deliveryType, boolean delivered, boolean actionRequired, 2461 OrderByComparator<UserNotificationEvent> orderByComparator) 2462 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2463 return getPersistence() 2464 .findByU_DT_D_A_Last(userId, deliveryType, delivered, 2465 actionRequired, orderByComparator); 2466 } 2467 2468 /** 2469 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2470 * 2471 * @param userId the user ID 2472 * @param deliveryType the delivery type 2473 * @param delivered the delivered 2474 * @param actionRequired the action required 2475 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2476 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 2477 */ 2478 public static UserNotificationEvent fetchByU_DT_D_A_Last(long userId, 2479 int deliveryType, boolean delivered, boolean actionRequired, 2480 OrderByComparator<UserNotificationEvent> orderByComparator) { 2481 return getPersistence() 2482 .fetchByU_DT_D_A_Last(userId, deliveryType, delivered, 2483 actionRequired, orderByComparator); 2484 } 2485 2486 /** 2487 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2488 * 2489 * @param userNotificationEventId the primary key of the current user notification event 2490 * @param userId the user ID 2491 * @param deliveryType the delivery type 2492 * @param delivered the delivered 2493 * @param actionRequired the action required 2494 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2495 * @return the previous, current, and next user notification event 2496 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2497 */ 2498 public static UserNotificationEvent[] findByU_DT_D_A_PrevAndNext( 2499 long userNotificationEventId, long userId, int deliveryType, 2500 boolean delivered, boolean actionRequired, 2501 OrderByComparator<UserNotificationEvent> orderByComparator) 2502 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2503 return getPersistence() 2504 .findByU_DT_D_A_PrevAndNext(userNotificationEventId, userId, 2505 deliveryType, delivered, actionRequired, orderByComparator); 2506 } 2507 2508 /** 2509 * Removes all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ? from the database. 2510 * 2511 * @param userId the user ID 2512 * @param deliveryType the delivery type 2513 * @param delivered the delivered 2514 * @param actionRequired the action required 2515 */ 2516 public static void removeByU_DT_D_A(long userId, int deliveryType, 2517 boolean delivered, boolean actionRequired) { 2518 getPersistence() 2519 .removeByU_DT_D_A(userId, deliveryType, delivered, actionRequired); 2520 } 2521 2522 /** 2523 * Returns the number of user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2524 * 2525 * @param userId the user ID 2526 * @param deliveryType the delivery type 2527 * @param delivered the delivered 2528 * @param actionRequired the action required 2529 * @return the number of matching user notification events 2530 */ 2531 public static int countByU_DT_D_A(long userId, int deliveryType, 2532 boolean delivered, boolean actionRequired) { 2533 return getPersistence() 2534 .countByU_DT_D_A(userId, deliveryType, delivered, 2535 actionRequired); 2536 } 2537 2538 /** 2539 * Returns all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2540 * 2541 * @param userId the user ID 2542 * @param deliveryType the delivery type 2543 * @param actionRequired the action required 2544 * @param archived the archived 2545 * @return the matching user notification events 2546 */ 2547 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 2548 int deliveryType, boolean actionRequired, boolean archived) { 2549 return getPersistence() 2550 .findByU_DT_A_A(userId, deliveryType, actionRequired, 2551 archived); 2552 } 2553 2554 /** 2555 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2556 * 2557 * <p> 2558 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2559 * </p> 2560 * 2561 * @param userId the user ID 2562 * @param deliveryType the delivery type 2563 * @param actionRequired the action required 2564 * @param archived the archived 2565 * @param start the lower bound of the range of user notification events 2566 * @param end the upper bound of the range of user notification events (not inclusive) 2567 * @return the range of matching user notification events 2568 */ 2569 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 2570 int deliveryType, boolean actionRequired, boolean archived, int start, 2571 int end) { 2572 return getPersistence() 2573 .findByU_DT_A_A(userId, deliveryType, actionRequired, 2574 archived, start, end); 2575 } 2576 2577 /** 2578 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2579 * 2580 * <p> 2581 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2582 * </p> 2583 * 2584 * @param userId the user ID 2585 * @param deliveryType the delivery type 2586 * @param actionRequired the action required 2587 * @param archived the archived 2588 * @param start the lower bound of the range of user notification events 2589 * @param end the upper bound of the range of user notification events (not inclusive) 2590 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2591 * @return the ordered range of matching user notification events 2592 */ 2593 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 2594 int deliveryType, boolean actionRequired, boolean archived, int start, 2595 int end, OrderByComparator<UserNotificationEvent> orderByComparator) { 2596 return getPersistence() 2597 .findByU_DT_A_A(userId, deliveryType, actionRequired, 2598 archived, start, end, orderByComparator); 2599 } 2600 2601 /** 2602 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2603 * 2604 * <p> 2605 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2606 * </p> 2607 * 2608 * @param userId the user ID 2609 * @param deliveryType the delivery type 2610 * @param actionRequired the action required 2611 * @param archived the archived 2612 * @param start the lower bound of the range of user notification events 2613 * @param end the upper bound of the range of user notification events (not inclusive) 2614 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2615 * @param retrieveFromCache whether to retrieve from the finder cache 2616 * @return the ordered range of matching user notification events 2617 */ 2618 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 2619 int deliveryType, boolean actionRequired, boolean archived, int start, 2620 int end, OrderByComparator<UserNotificationEvent> orderByComparator, 2621 boolean retrieveFromCache) { 2622 return getPersistence() 2623 .findByU_DT_A_A(userId, deliveryType, actionRequired, 2624 archived, start, end, orderByComparator, retrieveFromCache); 2625 } 2626 2627 /** 2628 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2629 * 2630 * @param userId the user ID 2631 * @param deliveryType the delivery type 2632 * @param actionRequired the action required 2633 * @param archived the archived 2634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2635 * @return the first matching user notification event 2636 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2637 */ 2638 public static UserNotificationEvent findByU_DT_A_A_First(long userId, 2639 int deliveryType, boolean actionRequired, boolean archived, 2640 OrderByComparator<UserNotificationEvent> orderByComparator) 2641 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2642 return getPersistence() 2643 .findByU_DT_A_A_First(userId, deliveryType, actionRequired, 2644 archived, orderByComparator); 2645 } 2646 2647 /** 2648 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2649 * 2650 * @param userId the user ID 2651 * @param deliveryType the delivery type 2652 * @param actionRequired the action required 2653 * @param archived the archived 2654 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2655 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 2656 */ 2657 public static UserNotificationEvent fetchByU_DT_A_A_First(long userId, 2658 int deliveryType, boolean actionRequired, boolean archived, 2659 OrderByComparator<UserNotificationEvent> orderByComparator) { 2660 return getPersistence() 2661 .fetchByU_DT_A_A_First(userId, deliveryType, actionRequired, 2662 archived, orderByComparator); 2663 } 2664 2665 /** 2666 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2667 * 2668 * @param userId the user ID 2669 * @param deliveryType the delivery type 2670 * @param actionRequired the action required 2671 * @param archived the archived 2672 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2673 * @return the last matching user notification event 2674 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2675 */ 2676 public static UserNotificationEvent findByU_DT_A_A_Last(long userId, 2677 int deliveryType, boolean actionRequired, boolean archived, 2678 OrderByComparator<UserNotificationEvent> orderByComparator) 2679 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2680 return getPersistence() 2681 .findByU_DT_A_A_Last(userId, deliveryType, actionRequired, 2682 archived, orderByComparator); 2683 } 2684 2685 /** 2686 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2687 * 2688 * @param userId the user ID 2689 * @param deliveryType the delivery type 2690 * @param actionRequired the action required 2691 * @param archived the archived 2692 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2693 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 2694 */ 2695 public static UserNotificationEvent fetchByU_DT_A_A_Last(long userId, 2696 int deliveryType, boolean actionRequired, boolean archived, 2697 OrderByComparator<UserNotificationEvent> orderByComparator) { 2698 return getPersistence() 2699 .fetchByU_DT_A_A_Last(userId, deliveryType, actionRequired, 2700 archived, orderByComparator); 2701 } 2702 2703 /** 2704 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2705 * 2706 * @param userNotificationEventId the primary key of the current user notification event 2707 * @param userId the user ID 2708 * @param deliveryType the delivery type 2709 * @param actionRequired the action required 2710 * @param archived the archived 2711 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2712 * @return the previous, current, and next user notification event 2713 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2714 */ 2715 public static UserNotificationEvent[] findByU_DT_A_A_PrevAndNext( 2716 long userNotificationEventId, long userId, int deliveryType, 2717 boolean actionRequired, boolean archived, 2718 OrderByComparator<UserNotificationEvent> orderByComparator) 2719 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2720 return getPersistence() 2721 .findByU_DT_A_A_PrevAndNext(userNotificationEventId, userId, 2722 deliveryType, actionRequired, archived, orderByComparator); 2723 } 2724 2725 /** 2726 * Removes all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ? from the database. 2727 * 2728 * @param userId the user ID 2729 * @param deliveryType the delivery type 2730 * @param actionRequired the action required 2731 * @param archived the archived 2732 */ 2733 public static void removeByU_DT_A_A(long userId, int deliveryType, 2734 boolean actionRequired, boolean archived) { 2735 getPersistence() 2736 .removeByU_DT_A_A(userId, deliveryType, actionRequired, archived); 2737 } 2738 2739 /** 2740 * Returns the number of user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2741 * 2742 * @param userId the user ID 2743 * @param deliveryType the delivery type 2744 * @param actionRequired the action required 2745 * @param archived the archived 2746 * @return the number of matching user notification events 2747 */ 2748 public static int countByU_DT_A_A(long userId, int deliveryType, 2749 boolean actionRequired, boolean archived) { 2750 return getPersistence() 2751 .countByU_DT_A_A(userId, deliveryType, actionRequired, 2752 archived); 2753 } 2754 2755 /** 2756 * Caches the user notification event in the entity cache if it is enabled. 2757 * 2758 * @param userNotificationEvent the user notification event 2759 */ 2760 public static void cacheResult(UserNotificationEvent userNotificationEvent) { 2761 getPersistence().cacheResult(userNotificationEvent); 2762 } 2763 2764 /** 2765 * Caches the user notification events in the entity cache if it is enabled. 2766 * 2767 * @param userNotificationEvents the user notification events 2768 */ 2769 public static void cacheResult( 2770 List<UserNotificationEvent> userNotificationEvents) { 2771 getPersistence().cacheResult(userNotificationEvents); 2772 } 2773 2774 /** 2775 * Creates a new user notification event with the primary key. Does not add the user notification event to the database. 2776 * 2777 * @param userNotificationEventId the primary key for the new user notification event 2778 * @return the new user notification event 2779 */ 2780 public static UserNotificationEvent create(long userNotificationEventId) { 2781 return getPersistence().create(userNotificationEventId); 2782 } 2783 2784 /** 2785 * Removes the user notification event with the primary key from the database. Also notifies the appropriate model listeners. 2786 * 2787 * @param userNotificationEventId the primary key of the user notification event 2788 * @return the user notification event that was removed 2789 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2790 */ 2791 public static UserNotificationEvent remove(long userNotificationEventId) 2792 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2793 return getPersistence().remove(userNotificationEventId); 2794 } 2795 2796 public static UserNotificationEvent updateImpl( 2797 UserNotificationEvent userNotificationEvent) { 2798 return getPersistence().updateImpl(userNotificationEvent); 2799 } 2800 2801 /** 2802 * Returns the user notification event with the primary key or throws a {@link NoSuchUserNotificationEventException} if it could not be found. 2803 * 2804 * @param userNotificationEventId the primary key of the user notification event 2805 * @return the user notification event 2806 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2807 */ 2808 public static UserNotificationEvent findByPrimaryKey( 2809 long userNotificationEventId) 2810 throws com.liferay.portal.exception.NoSuchUserNotificationEventException { 2811 return getPersistence().findByPrimaryKey(userNotificationEventId); 2812 } 2813 2814 /** 2815 * Returns the user notification event with the primary key or returns <code>null</code> if it could not be found. 2816 * 2817 * @param userNotificationEventId the primary key of the user notification event 2818 * @return the user notification event, or <code>null</code> if a user notification event with the primary key could not be found 2819 */ 2820 public static UserNotificationEvent fetchByPrimaryKey( 2821 long userNotificationEventId) { 2822 return getPersistence().fetchByPrimaryKey(userNotificationEventId); 2823 } 2824 2825 public static java.util.Map<java.io.Serializable, UserNotificationEvent> fetchByPrimaryKeys( 2826 java.util.Set<java.io.Serializable> primaryKeys) { 2827 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2828 } 2829 2830 /** 2831 * Returns all the user notification events. 2832 * 2833 * @return the user notification events 2834 */ 2835 public static List<UserNotificationEvent> findAll() { 2836 return getPersistence().findAll(); 2837 } 2838 2839 /** 2840 * Returns a range of all the user notification events. 2841 * 2842 * <p> 2843 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2844 * </p> 2845 * 2846 * @param start the lower bound of the range of user notification events 2847 * @param end the upper bound of the range of user notification events (not inclusive) 2848 * @return the range of user notification events 2849 */ 2850 public static List<UserNotificationEvent> findAll(int start, int end) { 2851 return getPersistence().findAll(start, end); 2852 } 2853 2854 /** 2855 * Returns an ordered range of all the user notification events. 2856 * 2857 * <p> 2858 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2859 * </p> 2860 * 2861 * @param start the lower bound of the range of user notification events 2862 * @param end the upper bound of the range of user notification events (not inclusive) 2863 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2864 * @return the ordered range of user notification events 2865 */ 2866 public static List<UserNotificationEvent> findAll(int start, int end, 2867 OrderByComparator<UserNotificationEvent> orderByComparator) { 2868 return getPersistence().findAll(start, end, orderByComparator); 2869 } 2870 2871 /** 2872 * Returns an ordered range of all the user notification events. 2873 * 2874 * <p> 2875 * 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2876 * </p> 2877 * 2878 * @param start the lower bound of the range of user notification events 2879 * @param end the upper bound of the range of user notification events (not inclusive) 2880 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2881 * @param retrieveFromCache whether to retrieve from the finder cache 2882 * @return the ordered range of user notification events 2883 */ 2884 public static List<UserNotificationEvent> findAll(int start, int end, 2885 OrderByComparator<UserNotificationEvent> orderByComparator, 2886 boolean retrieveFromCache) { 2887 return getPersistence() 2888 .findAll(start, end, orderByComparator, retrieveFromCache); 2889 } 2890 2891 /** 2892 * Removes all the user notification events from the database. 2893 */ 2894 public static void removeAll() { 2895 getPersistence().removeAll(); 2896 } 2897 2898 /** 2899 * Returns the number of user notification events. 2900 * 2901 * @return the number of user notification events 2902 */ 2903 public static int countAll() { 2904 return getPersistence().countAll(); 2905 } 2906 2907 public static java.util.Set<java.lang.String> getBadColumnNames() { 2908 return getPersistence().getBadColumnNames(); 2909 } 2910 2911 public static UserNotificationEventPersistence getPersistence() { 2912 if (_persistence == null) { 2913 _persistence = (UserNotificationEventPersistence)PortalBeanLocatorUtil.locate(UserNotificationEventPersistence.class.getName()); 2914 2915 ReferenceRegistry.registerReference(UserNotificationEventUtil.class, 2916 "_persistence"); 2917 } 2918 2919 return _persistence; 2920 } 2921 2922 private static UserNotificationEventPersistence _persistence; 2923 }