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.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.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.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.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.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.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.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.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.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 userId = ? and deliveryType = ?. 614 * 615 * @param userId the user ID 616 * @param deliveryType the delivery type 617 * @return the matching user notification events 618 */ 619 public static List<UserNotificationEvent> findByU_DT(long userId, 620 int deliveryType) { 621 return getPersistence().findByU_DT(userId, deliveryType); 622 } 623 624 /** 625 * Returns a range of all the user notification events where userId = ? and deliveryType = ?. 626 * 627 * <p> 628 * 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. 629 * </p> 630 * 631 * @param userId the user ID 632 * @param deliveryType the delivery type 633 * @param start the lower bound of the range of user notification events 634 * @param end the upper bound of the range of user notification events (not inclusive) 635 * @return the range of matching user notification events 636 */ 637 public static List<UserNotificationEvent> findByU_DT(long userId, 638 int deliveryType, int start, int end) { 639 return getPersistence().findByU_DT(userId, deliveryType, start, end); 640 } 641 642 /** 643 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ?. 644 * 645 * <p> 646 * 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. 647 * </p> 648 * 649 * @param userId the user ID 650 * @param deliveryType the delivery type 651 * @param start the lower bound of the range of user notification events 652 * @param end the upper bound of the range of user notification events (not inclusive) 653 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 654 * @return the ordered range of matching user notification events 655 */ 656 public static List<UserNotificationEvent> findByU_DT(long userId, 657 int deliveryType, int start, int end, 658 OrderByComparator<UserNotificationEvent> orderByComparator) { 659 return getPersistence() 660 .findByU_DT(userId, deliveryType, start, end, 661 orderByComparator); 662 } 663 664 /** 665 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ?. 666 * 667 * <p> 668 * 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. 669 * </p> 670 * 671 * @param userId the user ID 672 * @param deliveryType the delivery type 673 * @param start the lower bound of the range of user notification events 674 * @param end the upper bound of the range of user notification events (not inclusive) 675 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 676 * @param retrieveFromCache whether to retrieve from the finder cache 677 * @return the ordered range of matching user notification events 678 */ 679 public static List<UserNotificationEvent> findByU_DT(long userId, 680 int deliveryType, int start, int end, 681 OrderByComparator<UserNotificationEvent> orderByComparator, 682 boolean retrieveFromCache) { 683 return getPersistence() 684 .findByU_DT(userId, deliveryType, start, end, 685 orderByComparator, retrieveFromCache); 686 } 687 688 /** 689 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ?. 690 * 691 * @param userId the user ID 692 * @param deliveryType the delivery type 693 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 694 * @return the first matching user notification event 695 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 696 */ 697 public static UserNotificationEvent findByU_DT_First(long userId, 698 int deliveryType, 699 OrderByComparator<UserNotificationEvent> orderByComparator) 700 throws com.liferay.portal.NoSuchUserNotificationEventException { 701 return getPersistence() 702 .findByU_DT_First(userId, deliveryType, orderByComparator); 703 } 704 705 /** 706 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ?. 707 * 708 * @param userId the user ID 709 * @param deliveryType the delivery type 710 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 711 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 712 */ 713 public static UserNotificationEvent fetchByU_DT_First(long userId, 714 int deliveryType, 715 OrderByComparator<UserNotificationEvent> orderByComparator) { 716 return getPersistence() 717 .fetchByU_DT_First(userId, deliveryType, orderByComparator); 718 } 719 720 /** 721 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ?. 722 * 723 * @param userId the user ID 724 * @param deliveryType the delivery type 725 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 726 * @return the last matching user notification event 727 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 728 */ 729 public static UserNotificationEvent findByU_DT_Last(long userId, 730 int deliveryType, 731 OrderByComparator<UserNotificationEvent> orderByComparator) 732 throws com.liferay.portal.NoSuchUserNotificationEventException { 733 return getPersistence() 734 .findByU_DT_Last(userId, deliveryType, orderByComparator); 735 } 736 737 /** 738 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ?. 739 * 740 * @param userId the user ID 741 * @param deliveryType the delivery type 742 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 743 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 744 */ 745 public static UserNotificationEvent fetchByU_DT_Last(long userId, 746 int deliveryType, 747 OrderByComparator<UserNotificationEvent> orderByComparator) { 748 return getPersistence() 749 .fetchByU_DT_Last(userId, deliveryType, orderByComparator); 750 } 751 752 /** 753 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ?. 754 * 755 * @param userNotificationEventId the primary key of the current user notification event 756 * @param userId the user ID 757 * @param deliveryType the delivery type 758 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 759 * @return the previous, current, and next user notification event 760 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 761 */ 762 public static UserNotificationEvent[] findByU_DT_PrevAndNext( 763 long userNotificationEventId, long userId, int deliveryType, 764 OrderByComparator<UserNotificationEvent> orderByComparator) 765 throws com.liferay.portal.NoSuchUserNotificationEventException { 766 return getPersistence() 767 .findByU_DT_PrevAndNext(userNotificationEventId, userId, 768 deliveryType, orderByComparator); 769 } 770 771 /** 772 * Removes all the user notification events where userId = ? and deliveryType = ? from the database. 773 * 774 * @param userId the user ID 775 * @param deliveryType the delivery type 776 */ 777 public static void removeByU_DT(long userId, int deliveryType) { 778 getPersistence().removeByU_DT(userId, deliveryType); 779 } 780 781 /** 782 * Returns the number of user notification events where userId = ? and deliveryType = ?. 783 * 784 * @param userId the user ID 785 * @param deliveryType the delivery type 786 * @return the number of matching user notification events 787 */ 788 public static int countByU_DT(long userId, int deliveryType) { 789 return getPersistence().countByU_DT(userId, deliveryType); 790 } 791 792 /** 793 * Returns all the user notification events where userId = ? and delivered = ?. 794 * 795 * @param userId the user ID 796 * @param delivered the delivered 797 * @return the matching user notification events 798 */ 799 public static List<UserNotificationEvent> findByU_D(long userId, 800 boolean delivered) { 801 return getPersistence().findByU_D(userId, delivered); 802 } 803 804 /** 805 * Returns a range of all the user notification events where userId = ? and delivered = ?. 806 * 807 * <p> 808 * 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. 809 * </p> 810 * 811 * @param userId the user ID 812 * @param delivered the delivered 813 * @param start the lower bound of the range of user notification events 814 * @param end the upper bound of the range of user notification events (not inclusive) 815 * @return the range of matching user notification events 816 */ 817 public static List<UserNotificationEvent> findByU_D(long userId, 818 boolean delivered, int start, int end) { 819 return getPersistence().findByU_D(userId, delivered, start, end); 820 } 821 822 /** 823 * Returns an ordered range of all the user notification events where userId = ? and delivered = ?. 824 * 825 * <p> 826 * 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. 827 * </p> 828 * 829 * @param userId the user ID 830 * @param delivered the delivered 831 * @param start the lower bound of the range of user notification events 832 * @param end the upper bound of the range of user notification events (not inclusive) 833 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 834 * @return the ordered range of matching user notification events 835 */ 836 public static List<UserNotificationEvent> findByU_D(long userId, 837 boolean delivered, int start, int end, 838 OrderByComparator<UserNotificationEvent> orderByComparator) { 839 return getPersistence() 840 .findByU_D(userId, delivered, start, end, orderByComparator); 841 } 842 843 /** 844 * Returns an ordered range of all the user notification events where userId = ? and delivered = ?. 845 * 846 * <p> 847 * 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. 848 * </p> 849 * 850 * @param userId the user ID 851 * @param delivered the delivered 852 * @param start the lower bound of the range of user notification events 853 * @param end the upper bound of the range of user notification events (not inclusive) 854 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 855 * @param retrieveFromCache whether to retrieve from the finder cache 856 * @return the ordered range of matching user notification events 857 */ 858 public static List<UserNotificationEvent> findByU_D(long userId, 859 boolean delivered, int start, int end, 860 OrderByComparator<UserNotificationEvent> orderByComparator, 861 boolean retrieveFromCache) { 862 return getPersistence() 863 .findByU_D(userId, delivered, start, end, orderByComparator, 864 retrieveFromCache); 865 } 866 867 /** 868 * Returns the first user notification event in the ordered set where userId = ? and delivered = ?. 869 * 870 * @param userId the user ID 871 * @param delivered the delivered 872 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 873 * @return the first matching user notification event 874 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 875 */ 876 public static UserNotificationEvent findByU_D_First(long userId, 877 boolean delivered, 878 OrderByComparator<UserNotificationEvent> orderByComparator) 879 throws com.liferay.portal.NoSuchUserNotificationEventException { 880 return getPersistence() 881 .findByU_D_First(userId, delivered, orderByComparator); 882 } 883 884 /** 885 * Returns the first user notification event in the ordered set where userId = ? and delivered = ?. 886 * 887 * @param userId the user ID 888 * @param delivered the delivered 889 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 890 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 891 */ 892 public static UserNotificationEvent fetchByU_D_First(long userId, 893 boolean delivered, 894 OrderByComparator<UserNotificationEvent> orderByComparator) { 895 return getPersistence() 896 .fetchByU_D_First(userId, delivered, orderByComparator); 897 } 898 899 /** 900 * Returns the last user notification event in the ordered set where userId = ? and delivered = ?. 901 * 902 * @param userId the user ID 903 * @param delivered the delivered 904 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 905 * @return the last matching user notification event 906 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 907 */ 908 public static UserNotificationEvent findByU_D_Last(long userId, 909 boolean delivered, 910 OrderByComparator<UserNotificationEvent> orderByComparator) 911 throws com.liferay.portal.NoSuchUserNotificationEventException { 912 return getPersistence() 913 .findByU_D_Last(userId, delivered, orderByComparator); 914 } 915 916 /** 917 * Returns the last user notification event in the ordered set where userId = ? and delivered = ?. 918 * 919 * @param userId the user ID 920 * @param delivered the delivered 921 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 922 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 923 */ 924 public static UserNotificationEvent fetchByU_D_Last(long userId, 925 boolean delivered, 926 OrderByComparator<UserNotificationEvent> orderByComparator) { 927 return getPersistence() 928 .fetchByU_D_Last(userId, delivered, orderByComparator); 929 } 930 931 /** 932 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and delivered = ?. 933 * 934 * @param userNotificationEventId the primary key of the current user notification event 935 * @param userId the user ID 936 * @param delivered the delivered 937 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 938 * @return the previous, current, and next user notification event 939 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 940 */ 941 public static UserNotificationEvent[] findByU_D_PrevAndNext( 942 long userNotificationEventId, long userId, boolean delivered, 943 OrderByComparator<UserNotificationEvent> orderByComparator) 944 throws com.liferay.portal.NoSuchUserNotificationEventException { 945 return getPersistence() 946 .findByU_D_PrevAndNext(userNotificationEventId, userId, 947 delivered, orderByComparator); 948 } 949 950 /** 951 * Removes all the user notification events where userId = ? and delivered = ? from the database. 952 * 953 * @param userId the user ID 954 * @param delivered the delivered 955 */ 956 public static void removeByU_D(long userId, boolean delivered) { 957 getPersistence().removeByU_D(userId, delivered); 958 } 959 960 /** 961 * Returns the number of user notification events where userId = ? and delivered = ?. 962 * 963 * @param userId the user ID 964 * @param delivered the delivered 965 * @return the number of matching user notification events 966 */ 967 public static int countByU_D(long userId, boolean delivered) { 968 return getPersistence().countByU_D(userId, delivered); 969 } 970 971 /** 972 * Returns all the user notification events where userId = ? and archived = ?. 973 * 974 * @param userId the user ID 975 * @param archived the archived 976 * @return the matching user notification events 977 */ 978 public static List<UserNotificationEvent> findByU_A(long userId, 979 boolean archived) { 980 return getPersistence().findByU_A(userId, archived); 981 } 982 983 /** 984 * Returns a range of all the user notification events where userId = ? and archived = ?. 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 archived the archived 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 * @return the range of matching user notification events 995 */ 996 public static List<UserNotificationEvent> findByU_A(long userId, 997 boolean archived, int start, int end) { 998 return getPersistence().findByU_A(userId, archived, start, end); 999 } 1000 1001 /** 1002 * Returns an ordered range of all the user notification events where userId = ? and archived = ?. 1003 * 1004 * <p> 1005 * 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. 1006 * </p> 1007 * 1008 * @param userId the user ID 1009 * @param archived the archived 1010 * @param start the lower bound of the range of user notification events 1011 * @param end the upper bound of the range of user notification events (not inclusive) 1012 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1013 * @return the ordered range of matching user notification events 1014 */ 1015 public static List<UserNotificationEvent> findByU_A(long userId, 1016 boolean archived, int start, int end, 1017 OrderByComparator<UserNotificationEvent> orderByComparator) { 1018 return getPersistence() 1019 .findByU_A(userId, archived, start, end, orderByComparator); 1020 } 1021 1022 /** 1023 * Returns an ordered range of all the user notification events where userId = ? and archived = ?. 1024 * 1025 * <p> 1026 * 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. 1027 * </p> 1028 * 1029 * @param userId the user ID 1030 * @param archived the archived 1031 * @param start the lower bound of the range of user notification events 1032 * @param end the upper bound of the range of user notification events (not inclusive) 1033 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1034 * @param retrieveFromCache whether to retrieve from the finder cache 1035 * @return the ordered range of matching user notification events 1036 */ 1037 public static List<UserNotificationEvent> findByU_A(long userId, 1038 boolean archived, int start, int end, 1039 OrderByComparator<UserNotificationEvent> orderByComparator, 1040 boolean retrieveFromCache) { 1041 return getPersistence() 1042 .findByU_A(userId, archived, start, end, orderByComparator, 1043 retrieveFromCache); 1044 } 1045 1046 /** 1047 * Returns the first user notification event in the ordered set where userId = ? and archived = ?. 1048 * 1049 * @param userId the user ID 1050 * @param archived the archived 1051 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1052 * @return the first matching user notification event 1053 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1054 */ 1055 public static UserNotificationEvent findByU_A_First(long userId, 1056 boolean archived, 1057 OrderByComparator<UserNotificationEvent> orderByComparator) 1058 throws com.liferay.portal.NoSuchUserNotificationEventException { 1059 return getPersistence() 1060 .findByU_A_First(userId, archived, orderByComparator); 1061 } 1062 1063 /** 1064 * Returns the first user notification event in the ordered set where userId = ? and archived = ?. 1065 * 1066 * @param userId the user ID 1067 * @param archived the archived 1068 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1069 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1070 */ 1071 public static UserNotificationEvent fetchByU_A_First(long userId, 1072 boolean archived, 1073 OrderByComparator<UserNotificationEvent> orderByComparator) { 1074 return getPersistence() 1075 .fetchByU_A_First(userId, archived, orderByComparator); 1076 } 1077 1078 /** 1079 * Returns the last user notification event in the ordered set where userId = ? and archived = ?. 1080 * 1081 * @param userId the user ID 1082 * @param archived the archived 1083 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1084 * @return the last matching user notification event 1085 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1086 */ 1087 public static UserNotificationEvent findByU_A_Last(long userId, 1088 boolean archived, 1089 OrderByComparator<UserNotificationEvent> orderByComparator) 1090 throws com.liferay.portal.NoSuchUserNotificationEventException { 1091 return getPersistence() 1092 .findByU_A_Last(userId, archived, orderByComparator); 1093 } 1094 1095 /** 1096 * Returns the last user notification event in the ordered set where userId = ? and archived = ?. 1097 * 1098 * @param userId the user ID 1099 * @param archived the archived 1100 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1101 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1102 */ 1103 public static UserNotificationEvent fetchByU_A_Last(long userId, 1104 boolean archived, 1105 OrderByComparator<UserNotificationEvent> orderByComparator) { 1106 return getPersistence() 1107 .fetchByU_A_Last(userId, archived, orderByComparator); 1108 } 1109 1110 /** 1111 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and archived = ?. 1112 * 1113 * @param userNotificationEventId the primary key of the current user notification event 1114 * @param userId the user ID 1115 * @param archived the archived 1116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1117 * @return the previous, current, and next user notification event 1118 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1119 */ 1120 public static UserNotificationEvent[] findByU_A_PrevAndNext( 1121 long userNotificationEventId, long userId, boolean archived, 1122 OrderByComparator<UserNotificationEvent> orderByComparator) 1123 throws com.liferay.portal.NoSuchUserNotificationEventException { 1124 return getPersistence() 1125 .findByU_A_PrevAndNext(userNotificationEventId, userId, 1126 archived, orderByComparator); 1127 } 1128 1129 /** 1130 * Removes all the user notification events where userId = ? and archived = ? from the database. 1131 * 1132 * @param userId the user ID 1133 * @param archived the archived 1134 */ 1135 public static void removeByU_A(long userId, boolean archived) { 1136 getPersistence().removeByU_A(userId, archived); 1137 } 1138 1139 /** 1140 * Returns the number of user notification events where userId = ? and archived = ?. 1141 * 1142 * @param userId the user ID 1143 * @param archived the archived 1144 * @return the number of matching user notification events 1145 */ 1146 public static int countByU_A(long userId, boolean archived) { 1147 return getPersistence().countByU_A(userId, archived); 1148 } 1149 1150 /** 1151 * Returns all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1152 * 1153 * @param userId the user ID 1154 * @param deliveryType the delivery type 1155 * @param delivered the delivered 1156 * @return the matching user notification events 1157 */ 1158 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1159 int deliveryType, boolean delivered) { 1160 return getPersistence().findByU_DT_D(userId, deliveryType, delivered); 1161 } 1162 1163 /** 1164 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1165 * 1166 * <p> 1167 * 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. 1168 * </p> 1169 * 1170 * @param userId the user ID 1171 * @param deliveryType the delivery type 1172 * @param delivered the delivered 1173 * @param start the lower bound of the range of user notification events 1174 * @param end the upper bound of the range of user notification events (not inclusive) 1175 * @return the range of matching user notification events 1176 */ 1177 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1178 int deliveryType, boolean delivered, int start, int end) { 1179 return getPersistence() 1180 .findByU_DT_D(userId, deliveryType, delivered, start, end); 1181 } 1182 1183 /** 1184 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 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 deliveryType the delivery type 1192 * @param delivered the delivered 1193 * @param start the lower bound of the range of user notification events 1194 * @param end the upper bound of the range of user notification events (not inclusive) 1195 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1196 * @return the ordered range of matching user notification events 1197 */ 1198 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1199 int deliveryType, boolean delivered, int start, int end, 1200 OrderByComparator<UserNotificationEvent> orderByComparator) { 1201 return getPersistence() 1202 .findByU_DT_D(userId, deliveryType, delivered, start, end, 1203 orderByComparator); 1204 } 1205 1206 /** 1207 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1208 * 1209 * <p> 1210 * 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. 1211 * </p> 1212 * 1213 * @param userId the user ID 1214 * @param deliveryType the delivery type 1215 * @param delivered the delivered 1216 * @param start the lower bound of the range of user notification events 1217 * @param end the upper bound of the range of user notification events (not inclusive) 1218 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1219 * @param retrieveFromCache whether to retrieve from the finder cache 1220 * @return the ordered range of matching user notification events 1221 */ 1222 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1223 int deliveryType, boolean delivered, int start, int end, 1224 OrderByComparator<UserNotificationEvent> orderByComparator, 1225 boolean retrieveFromCache) { 1226 return getPersistence() 1227 .findByU_DT_D(userId, deliveryType, delivered, start, end, 1228 orderByComparator, retrieveFromCache); 1229 } 1230 1231 /** 1232 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1233 * 1234 * @param userId the user ID 1235 * @param deliveryType the delivery type 1236 * @param delivered the delivered 1237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1238 * @return the first matching user notification event 1239 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1240 */ 1241 public static UserNotificationEvent findByU_DT_D_First(long userId, 1242 int deliveryType, boolean delivered, 1243 OrderByComparator<UserNotificationEvent> orderByComparator) 1244 throws com.liferay.portal.NoSuchUserNotificationEventException { 1245 return getPersistence() 1246 .findByU_DT_D_First(userId, deliveryType, delivered, 1247 orderByComparator); 1248 } 1249 1250 /** 1251 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1252 * 1253 * @param userId the user ID 1254 * @param deliveryType the delivery type 1255 * @param delivered the delivered 1256 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1257 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1258 */ 1259 public static UserNotificationEvent fetchByU_DT_D_First(long userId, 1260 int deliveryType, boolean delivered, 1261 OrderByComparator<UserNotificationEvent> orderByComparator) { 1262 return getPersistence() 1263 .fetchByU_DT_D_First(userId, deliveryType, delivered, 1264 orderByComparator); 1265 } 1266 1267 /** 1268 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1269 * 1270 * @param userId the user ID 1271 * @param deliveryType the delivery type 1272 * @param delivered the delivered 1273 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1274 * @return the last matching user notification event 1275 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1276 */ 1277 public static UserNotificationEvent findByU_DT_D_Last(long userId, 1278 int deliveryType, boolean delivered, 1279 OrderByComparator<UserNotificationEvent> orderByComparator) 1280 throws com.liferay.portal.NoSuchUserNotificationEventException { 1281 return getPersistence() 1282 .findByU_DT_D_Last(userId, deliveryType, delivered, 1283 orderByComparator); 1284 } 1285 1286 /** 1287 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1288 * 1289 * @param userId the user ID 1290 * @param deliveryType the delivery type 1291 * @param delivered the delivered 1292 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1293 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1294 */ 1295 public static UserNotificationEvent fetchByU_DT_D_Last(long userId, 1296 int deliveryType, boolean delivered, 1297 OrderByComparator<UserNotificationEvent> orderByComparator) { 1298 return getPersistence() 1299 .fetchByU_DT_D_Last(userId, deliveryType, delivered, 1300 orderByComparator); 1301 } 1302 1303 /** 1304 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1305 * 1306 * @param userNotificationEventId the primary key of the current user notification event 1307 * @param userId the user ID 1308 * @param deliveryType the delivery type 1309 * @param delivered the delivered 1310 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1311 * @return the previous, current, and next user notification event 1312 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1313 */ 1314 public static UserNotificationEvent[] findByU_DT_D_PrevAndNext( 1315 long userNotificationEventId, long userId, int deliveryType, 1316 boolean delivered, 1317 OrderByComparator<UserNotificationEvent> orderByComparator) 1318 throws com.liferay.portal.NoSuchUserNotificationEventException { 1319 return getPersistence() 1320 .findByU_DT_D_PrevAndNext(userNotificationEventId, userId, 1321 deliveryType, delivered, orderByComparator); 1322 } 1323 1324 /** 1325 * Removes all the user notification events where userId = ? and deliveryType = ? and delivered = ? from the database. 1326 * 1327 * @param userId the user ID 1328 * @param deliveryType the delivery type 1329 * @param delivered the delivered 1330 */ 1331 public static void removeByU_DT_D(long userId, int deliveryType, 1332 boolean delivered) { 1333 getPersistence().removeByU_DT_D(userId, deliveryType, delivered); 1334 } 1335 1336 /** 1337 * Returns the number of user notification events where userId = ? and deliveryType = ? and delivered = ?. 1338 * 1339 * @param userId the user ID 1340 * @param deliveryType the delivery type 1341 * @param delivered the delivered 1342 * @return the number of matching user notification events 1343 */ 1344 public static int countByU_DT_D(long userId, int deliveryType, 1345 boolean delivered) { 1346 return getPersistence().countByU_DT_D(userId, deliveryType, delivered); 1347 } 1348 1349 /** 1350 * Returns all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1351 * 1352 * @param userId the user ID 1353 * @param deliveryType the delivery type 1354 * @param archived the archived 1355 * @return the matching user notification events 1356 */ 1357 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1358 int deliveryType, boolean archived) { 1359 return getPersistence().findByU_DT_A(userId, deliveryType, archived); 1360 } 1361 1362 /** 1363 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1364 * 1365 * <p> 1366 * 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. 1367 * </p> 1368 * 1369 * @param userId the user ID 1370 * @param deliveryType the delivery type 1371 * @param archived the archived 1372 * @param start the lower bound of the range of user notification events 1373 * @param end the upper bound of the range of user notification events (not inclusive) 1374 * @return the range of matching user notification events 1375 */ 1376 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1377 int deliveryType, boolean archived, int start, int end) { 1378 return getPersistence() 1379 .findByU_DT_A(userId, deliveryType, archived, start, end); 1380 } 1381 1382 /** 1383 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1384 * 1385 * <p> 1386 * 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. 1387 * </p> 1388 * 1389 * @param userId the user ID 1390 * @param deliveryType the delivery type 1391 * @param archived the archived 1392 * @param start the lower bound of the range of user notification events 1393 * @param end the upper bound of the range of user notification events (not inclusive) 1394 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1395 * @return the ordered range of matching user notification events 1396 */ 1397 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1398 int deliveryType, boolean archived, int start, int end, 1399 OrderByComparator<UserNotificationEvent> orderByComparator) { 1400 return getPersistence() 1401 .findByU_DT_A(userId, deliveryType, archived, start, end, 1402 orderByComparator); 1403 } 1404 1405 /** 1406 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1407 * 1408 * <p> 1409 * 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. 1410 * </p> 1411 * 1412 * @param userId the user ID 1413 * @param deliveryType the delivery type 1414 * @param archived the archived 1415 * @param start the lower bound of the range of user notification events 1416 * @param end the upper bound of the range of user notification events (not inclusive) 1417 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1418 * @param retrieveFromCache whether to retrieve from the finder cache 1419 * @return the ordered range of matching user notification events 1420 */ 1421 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1422 int deliveryType, boolean archived, int start, int end, 1423 OrderByComparator<UserNotificationEvent> orderByComparator, 1424 boolean retrieveFromCache) { 1425 return getPersistence() 1426 .findByU_DT_A(userId, deliveryType, archived, start, end, 1427 orderByComparator, retrieveFromCache); 1428 } 1429 1430 /** 1431 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1432 * 1433 * @param userId the user ID 1434 * @param deliveryType the delivery type 1435 * @param archived the archived 1436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1437 * @return the first matching user notification event 1438 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1439 */ 1440 public static UserNotificationEvent findByU_DT_A_First(long userId, 1441 int deliveryType, boolean archived, 1442 OrderByComparator<UserNotificationEvent> orderByComparator) 1443 throws com.liferay.portal.NoSuchUserNotificationEventException { 1444 return getPersistence() 1445 .findByU_DT_A_First(userId, deliveryType, archived, 1446 orderByComparator); 1447 } 1448 1449 /** 1450 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1451 * 1452 * @param userId the user ID 1453 * @param deliveryType the delivery type 1454 * @param archived the archived 1455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1456 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1457 */ 1458 public static UserNotificationEvent fetchByU_DT_A_First(long userId, 1459 int deliveryType, boolean archived, 1460 OrderByComparator<UserNotificationEvent> orderByComparator) { 1461 return getPersistence() 1462 .fetchByU_DT_A_First(userId, deliveryType, archived, 1463 orderByComparator); 1464 } 1465 1466 /** 1467 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1468 * 1469 * @param userId the user ID 1470 * @param deliveryType the delivery type 1471 * @param archived the archived 1472 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1473 * @return the last matching user notification event 1474 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1475 */ 1476 public static UserNotificationEvent findByU_DT_A_Last(long userId, 1477 int deliveryType, boolean archived, 1478 OrderByComparator<UserNotificationEvent> orderByComparator) 1479 throws com.liferay.portal.NoSuchUserNotificationEventException { 1480 return getPersistence() 1481 .findByU_DT_A_Last(userId, deliveryType, archived, 1482 orderByComparator); 1483 } 1484 1485 /** 1486 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1487 * 1488 * @param userId the user ID 1489 * @param deliveryType the delivery type 1490 * @param archived the archived 1491 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1492 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1493 */ 1494 public static UserNotificationEvent fetchByU_DT_A_Last(long userId, 1495 int deliveryType, boolean archived, 1496 OrderByComparator<UserNotificationEvent> orderByComparator) { 1497 return getPersistence() 1498 .fetchByU_DT_A_Last(userId, deliveryType, archived, 1499 orderByComparator); 1500 } 1501 1502 /** 1503 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1504 * 1505 * @param userNotificationEventId the primary key of the current user notification event 1506 * @param userId the user ID 1507 * @param deliveryType the delivery type 1508 * @param archived the archived 1509 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1510 * @return the previous, current, and next user notification event 1511 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1512 */ 1513 public static UserNotificationEvent[] findByU_DT_A_PrevAndNext( 1514 long userNotificationEventId, long userId, int deliveryType, 1515 boolean archived, 1516 OrderByComparator<UserNotificationEvent> orderByComparator) 1517 throws com.liferay.portal.NoSuchUserNotificationEventException { 1518 return getPersistence() 1519 .findByU_DT_A_PrevAndNext(userNotificationEventId, userId, 1520 deliveryType, archived, orderByComparator); 1521 } 1522 1523 /** 1524 * Removes all the user notification events where userId = ? and deliveryType = ? and archived = ? from the database. 1525 * 1526 * @param userId the user ID 1527 * @param deliveryType the delivery type 1528 * @param archived the archived 1529 */ 1530 public static void removeByU_DT_A(long userId, int deliveryType, 1531 boolean archived) { 1532 getPersistence().removeByU_DT_A(userId, deliveryType, archived); 1533 } 1534 1535 /** 1536 * Returns the number of user notification events where userId = ? and deliveryType = ? and archived = ?. 1537 * 1538 * @param userId the user ID 1539 * @param deliveryType the delivery type 1540 * @param archived the archived 1541 * @return the number of matching user notification events 1542 */ 1543 public static int countByU_DT_A(long userId, int deliveryType, 1544 boolean archived) { 1545 return getPersistence().countByU_DT_A(userId, deliveryType, archived); 1546 } 1547 1548 /** 1549 * Returns all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1550 * 1551 * @param userId the user ID 1552 * @param delivered the delivered 1553 * @param actionRequired the action required 1554 * @return the matching user notification events 1555 */ 1556 public static List<UserNotificationEvent> findByU_D_A(long userId, 1557 boolean delivered, boolean actionRequired) { 1558 return getPersistence().findByU_D_A(userId, delivered, actionRequired); 1559 } 1560 1561 /** 1562 * Returns a range of all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1563 * 1564 * <p> 1565 * 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. 1566 * </p> 1567 * 1568 * @param userId the user ID 1569 * @param delivered the delivered 1570 * @param actionRequired the action required 1571 * @param start the lower bound of the range of user notification events 1572 * @param end the upper bound of the range of user notification events (not inclusive) 1573 * @return the range of matching user notification events 1574 */ 1575 public static List<UserNotificationEvent> findByU_D_A(long userId, 1576 boolean delivered, boolean actionRequired, int start, int end) { 1577 return getPersistence() 1578 .findByU_D_A(userId, delivered, actionRequired, start, end); 1579 } 1580 1581 /** 1582 * Returns an ordered range of all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1583 * 1584 * <p> 1585 * 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. 1586 * </p> 1587 * 1588 * @param userId the user ID 1589 * @param delivered the delivered 1590 * @param actionRequired the action required 1591 * @param start the lower bound of the range of user notification events 1592 * @param end the upper bound of the range of user notification events (not inclusive) 1593 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1594 * @return the ordered range of matching user notification events 1595 */ 1596 public static List<UserNotificationEvent> findByU_D_A(long userId, 1597 boolean delivered, boolean actionRequired, int start, int end, 1598 OrderByComparator<UserNotificationEvent> orderByComparator) { 1599 return getPersistence() 1600 .findByU_D_A(userId, delivered, actionRequired, start, end, 1601 orderByComparator); 1602 } 1603 1604 /** 1605 * Returns an ordered range of all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1606 * 1607 * <p> 1608 * 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. 1609 * </p> 1610 * 1611 * @param userId the user ID 1612 * @param delivered the delivered 1613 * @param actionRequired the action required 1614 * @param start the lower bound of the range of user notification events 1615 * @param end the upper bound of the range of user notification events (not inclusive) 1616 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1617 * @param retrieveFromCache whether to retrieve from the finder cache 1618 * @return the ordered range of matching user notification events 1619 */ 1620 public static List<UserNotificationEvent> findByU_D_A(long userId, 1621 boolean delivered, boolean actionRequired, int start, int end, 1622 OrderByComparator<UserNotificationEvent> orderByComparator, 1623 boolean retrieveFromCache) { 1624 return getPersistence() 1625 .findByU_D_A(userId, delivered, actionRequired, start, end, 1626 orderByComparator, retrieveFromCache); 1627 } 1628 1629 /** 1630 * Returns the first user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1631 * 1632 * @param userId the user ID 1633 * @param delivered the delivered 1634 * @param actionRequired the action required 1635 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1636 * @return the first matching user notification event 1637 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1638 */ 1639 public static UserNotificationEvent findByU_D_A_First(long userId, 1640 boolean delivered, boolean actionRequired, 1641 OrderByComparator<UserNotificationEvent> orderByComparator) 1642 throws com.liferay.portal.NoSuchUserNotificationEventException { 1643 return getPersistence() 1644 .findByU_D_A_First(userId, delivered, actionRequired, 1645 orderByComparator); 1646 } 1647 1648 /** 1649 * Returns the first user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1650 * 1651 * @param userId the user ID 1652 * @param delivered the delivered 1653 * @param actionRequired the action required 1654 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1655 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1656 */ 1657 public static UserNotificationEvent fetchByU_D_A_First(long userId, 1658 boolean delivered, boolean actionRequired, 1659 OrderByComparator<UserNotificationEvent> orderByComparator) { 1660 return getPersistence() 1661 .fetchByU_D_A_First(userId, delivered, actionRequired, 1662 orderByComparator); 1663 } 1664 1665 /** 1666 * Returns the last user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1667 * 1668 * @param userId the user ID 1669 * @param delivered the delivered 1670 * @param actionRequired the action required 1671 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1672 * @return the last matching user notification event 1673 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1674 */ 1675 public static UserNotificationEvent findByU_D_A_Last(long userId, 1676 boolean delivered, boolean actionRequired, 1677 OrderByComparator<UserNotificationEvent> orderByComparator) 1678 throws com.liferay.portal.NoSuchUserNotificationEventException { 1679 return getPersistence() 1680 .findByU_D_A_Last(userId, delivered, actionRequired, 1681 orderByComparator); 1682 } 1683 1684 /** 1685 * Returns the last user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1686 * 1687 * @param userId the user ID 1688 * @param delivered the delivered 1689 * @param actionRequired the action required 1690 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1691 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1692 */ 1693 public static UserNotificationEvent fetchByU_D_A_Last(long userId, 1694 boolean delivered, boolean actionRequired, 1695 OrderByComparator<UserNotificationEvent> orderByComparator) { 1696 return getPersistence() 1697 .fetchByU_D_A_Last(userId, delivered, actionRequired, 1698 orderByComparator); 1699 } 1700 1701 /** 1702 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1703 * 1704 * @param userNotificationEventId the primary key of the current user notification event 1705 * @param userId the user ID 1706 * @param delivered the delivered 1707 * @param actionRequired the action required 1708 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1709 * @return the previous, current, and next user notification event 1710 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1711 */ 1712 public static UserNotificationEvent[] findByU_D_A_PrevAndNext( 1713 long userNotificationEventId, long userId, boolean delivered, 1714 boolean actionRequired, 1715 OrderByComparator<UserNotificationEvent> orderByComparator) 1716 throws com.liferay.portal.NoSuchUserNotificationEventException { 1717 return getPersistence() 1718 .findByU_D_A_PrevAndNext(userNotificationEventId, userId, 1719 delivered, actionRequired, orderByComparator); 1720 } 1721 1722 /** 1723 * Removes all the user notification events where userId = ? and delivered = ? and actionRequired = ? from the database. 1724 * 1725 * @param userId the user ID 1726 * @param delivered the delivered 1727 * @param actionRequired the action required 1728 */ 1729 public static void removeByU_D_A(long userId, boolean delivered, 1730 boolean actionRequired) { 1731 getPersistence().removeByU_D_A(userId, delivered, actionRequired); 1732 } 1733 1734 /** 1735 * Returns the number of user notification events where userId = ? and delivered = ? and actionRequired = ?. 1736 * 1737 * @param userId the user ID 1738 * @param delivered the delivered 1739 * @param actionRequired the action required 1740 * @return the number of matching user notification events 1741 */ 1742 public static int countByU_D_A(long userId, boolean delivered, 1743 boolean actionRequired) { 1744 return getPersistence().countByU_D_A(userId, delivered, actionRequired); 1745 } 1746 1747 /** 1748 * Returns all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1749 * 1750 * @param userId the user ID 1751 * @param actionRequired the action required 1752 * @param archived the archived 1753 * @return the matching user notification events 1754 */ 1755 public static List<UserNotificationEvent> findByU_A_A(long userId, 1756 boolean actionRequired, boolean archived) { 1757 return getPersistence().findByU_A_A(userId, actionRequired, archived); 1758 } 1759 1760 /** 1761 * Returns a range of all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1762 * 1763 * <p> 1764 * 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. 1765 * </p> 1766 * 1767 * @param userId the user ID 1768 * @param actionRequired the action required 1769 * @param archived the archived 1770 * @param start the lower bound of the range of user notification events 1771 * @param end the upper bound of the range of user notification events (not inclusive) 1772 * @return the range of matching user notification events 1773 */ 1774 public static List<UserNotificationEvent> findByU_A_A(long userId, 1775 boolean actionRequired, boolean archived, int start, int end) { 1776 return getPersistence() 1777 .findByU_A_A(userId, actionRequired, archived, start, end); 1778 } 1779 1780 /** 1781 * Returns an ordered range of all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1782 * 1783 * <p> 1784 * 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. 1785 * </p> 1786 * 1787 * @param userId the user ID 1788 * @param actionRequired the action required 1789 * @param archived the archived 1790 * @param start the lower bound of the range of user notification events 1791 * @param end the upper bound of the range of user notification events (not inclusive) 1792 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1793 * @return the ordered range of matching user notification events 1794 */ 1795 public static List<UserNotificationEvent> findByU_A_A(long userId, 1796 boolean actionRequired, boolean archived, int start, int end, 1797 OrderByComparator<UserNotificationEvent> orderByComparator) { 1798 return getPersistence() 1799 .findByU_A_A(userId, actionRequired, archived, start, end, 1800 orderByComparator); 1801 } 1802 1803 /** 1804 * Returns an ordered range of all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1805 * 1806 * <p> 1807 * 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. 1808 * </p> 1809 * 1810 * @param userId the user ID 1811 * @param actionRequired the action required 1812 * @param archived the archived 1813 * @param start the lower bound of the range of user notification events 1814 * @param end the upper bound of the range of user notification events (not inclusive) 1815 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1816 * @param retrieveFromCache whether to retrieve from the finder cache 1817 * @return the ordered range of matching user notification events 1818 */ 1819 public static List<UserNotificationEvent> findByU_A_A(long userId, 1820 boolean actionRequired, boolean archived, int start, int end, 1821 OrderByComparator<UserNotificationEvent> orderByComparator, 1822 boolean retrieveFromCache) { 1823 return getPersistence() 1824 .findByU_A_A(userId, actionRequired, archived, start, end, 1825 orderByComparator, retrieveFromCache); 1826 } 1827 1828 /** 1829 * Returns the first user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1830 * 1831 * @param userId the user ID 1832 * @param actionRequired the action required 1833 * @param archived the archived 1834 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1835 * @return the first matching user notification event 1836 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1837 */ 1838 public static UserNotificationEvent findByU_A_A_First(long userId, 1839 boolean actionRequired, boolean archived, 1840 OrderByComparator<UserNotificationEvent> orderByComparator) 1841 throws com.liferay.portal.NoSuchUserNotificationEventException { 1842 return getPersistence() 1843 .findByU_A_A_First(userId, actionRequired, archived, 1844 orderByComparator); 1845 } 1846 1847 /** 1848 * Returns the first user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1849 * 1850 * @param userId the user ID 1851 * @param actionRequired the action required 1852 * @param archived the archived 1853 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1854 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1855 */ 1856 public static UserNotificationEvent fetchByU_A_A_First(long userId, 1857 boolean actionRequired, boolean archived, 1858 OrderByComparator<UserNotificationEvent> orderByComparator) { 1859 return getPersistence() 1860 .fetchByU_A_A_First(userId, actionRequired, archived, 1861 orderByComparator); 1862 } 1863 1864 /** 1865 * Returns the last user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1866 * 1867 * @param userId the user ID 1868 * @param actionRequired the action required 1869 * @param archived the archived 1870 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1871 * @return the last matching user notification event 1872 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1873 */ 1874 public static UserNotificationEvent findByU_A_A_Last(long userId, 1875 boolean actionRequired, boolean archived, 1876 OrderByComparator<UserNotificationEvent> orderByComparator) 1877 throws com.liferay.portal.NoSuchUserNotificationEventException { 1878 return getPersistence() 1879 .findByU_A_A_Last(userId, actionRequired, archived, 1880 orderByComparator); 1881 } 1882 1883 /** 1884 * Returns the last user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1885 * 1886 * @param userId the user ID 1887 * @param actionRequired the action required 1888 * @param archived the archived 1889 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1890 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1891 */ 1892 public static UserNotificationEvent fetchByU_A_A_Last(long userId, 1893 boolean actionRequired, boolean archived, 1894 OrderByComparator<UserNotificationEvent> orderByComparator) { 1895 return getPersistence() 1896 .fetchByU_A_A_Last(userId, actionRequired, archived, 1897 orderByComparator); 1898 } 1899 1900 /** 1901 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1902 * 1903 * @param userNotificationEventId the primary key of the current user notification event 1904 * @param userId the user ID 1905 * @param actionRequired the action required 1906 * @param archived the archived 1907 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1908 * @return the previous, current, and next user notification event 1909 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1910 */ 1911 public static UserNotificationEvent[] findByU_A_A_PrevAndNext( 1912 long userNotificationEventId, long userId, boolean actionRequired, 1913 boolean archived, 1914 OrderByComparator<UserNotificationEvent> orderByComparator) 1915 throws com.liferay.portal.NoSuchUserNotificationEventException { 1916 return getPersistence() 1917 .findByU_A_A_PrevAndNext(userNotificationEventId, userId, 1918 actionRequired, archived, orderByComparator); 1919 } 1920 1921 /** 1922 * Removes all the user notification events where userId = ? and actionRequired = ? and archived = ? from the database. 1923 * 1924 * @param userId the user ID 1925 * @param actionRequired the action required 1926 * @param archived the archived 1927 */ 1928 public static void removeByU_A_A(long userId, boolean actionRequired, 1929 boolean archived) { 1930 getPersistence().removeByU_A_A(userId, actionRequired, archived); 1931 } 1932 1933 /** 1934 * Returns the number of user notification events where userId = ? and actionRequired = ? and archived = ?. 1935 * 1936 * @param userId the user ID 1937 * @param actionRequired the action required 1938 * @param archived the archived 1939 * @return the number of matching user notification events 1940 */ 1941 public static int countByU_A_A(long userId, boolean actionRequired, 1942 boolean archived) { 1943 return getPersistence().countByU_A_A(userId, actionRequired, archived); 1944 } 1945 1946 /** 1947 * Returns all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1948 * 1949 * @param userId the user ID 1950 * @param deliveryType the delivery type 1951 * @param delivered the delivered 1952 * @param actionRequired the action required 1953 * @return the matching user notification events 1954 */ 1955 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 1956 int deliveryType, boolean delivered, boolean actionRequired) { 1957 return getPersistence() 1958 .findByU_DT_D_A(userId, deliveryType, delivered, 1959 actionRequired); 1960 } 1961 1962 /** 1963 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1964 * 1965 * <p> 1966 * 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. 1967 * </p> 1968 * 1969 * @param userId the user ID 1970 * @param deliveryType the delivery type 1971 * @param delivered the delivered 1972 * @param actionRequired the action required 1973 * @param start the lower bound of the range of user notification events 1974 * @param end the upper bound of the range of user notification events (not inclusive) 1975 * @return the range of matching user notification events 1976 */ 1977 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 1978 int deliveryType, boolean delivered, boolean actionRequired, int start, 1979 int end) { 1980 return getPersistence() 1981 .findByU_DT_D_A(userId, deliveryType, delivered, 1982 actionRequired, start, end); 1983 } 1984 1985 /** 1986 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1987 * 1988 * <p> 1989 * 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. 1990 * </p> 1991 * 1992 * @param userId the user ID 1993 * @param deliveryType the delivery type 1994 * @param delivered the delivered 1995 * @param actionRequired the action required 1996 * @param start the lower bound of the range of user notification events 1997 * @param end the upper bound of the range of user notification events (not inclusive) 1998 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1999 * @return the ordered range of matching user notification events 2000 */ 2001 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 2002 int deliveryType, boolean delivered, boolean actionRequired, int start, 2003 int end, OrderByComparator<UserNotificationEvent> orderByComparator) { 2004 return getPersistence() 2005 .findByU_DT_D_A(userId, deliveryType, delivered, 2006 actionRequired, start, end, orderByComparator); 2007 } 2008 2009 /** 2010 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2011 * 2012 * <p> 2013 * 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. 2014 * </p> 2015 * 2016 * @param userId the user ID 2017 * @param deliveryType the delivery type 2018 * @param delivered the delivered 2019 * @param actionRequired the action required 2020 * @param start the lower bound of the range of user notification events 2021 * @param end the upper bound of the range of user notification events (not inclusive) 2022 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2023 * @param retrieveFromCache whether to retrieve from the finder cache 2024 * @return the ordered range of matching user notification events 2025 */ 2026 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 2027 int deliveryType, boolean delivered, boolean actionRequired, int start, 2028 int end, OrderByComparator<UserNotificationEvent> orderByComparator, 2029 boolean retrieveFromCache) { 2030 return getPersistence() 2031 .findByU_DT_D_A(userId, deliveryType, delivered, 2032 actionRequired, start, end, orderByComparator, retrieveFromCache); 2033 } 2034 2035 /** 2036 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2037 * 2038 * @param userId the user ID 2039 * @param deliveryType the delivery type 2040 * @param delivered the delivered 2041 * @param actionRequired the action required 2042 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2043 * @return the first matching user notification event 2044 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2045 */ 2046 public static UserNotificationEvent findByU_DT_D_A_First(long userId, 2047 int deliveryType, boolean delivered, boolean actionRequired, 2048 OrderByComparator<UserNotificationEvent> orderByComparator) 2049 throws com.liferay.portal.NoSuchUserNotificationEventException { 2050 return getPersistence() 2051 .findByU_DT_D_A_First(userId, deliveryType, delivered, 2052 actionRequired, orderByComparator); 2053 } 2054 2055 /** 2056 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2057 * 2058 * @param userId the user ID 2059 * @param deliveryType the delivery type 2060 * @param delivered the delivered 2061 * @param actionRequired the action required 2062 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2063 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 2064 */ 2065 public static UserNotificationEvent fetchByU_DT_D_A_First(long userId, 2066 int deliveryType, boolean delivered, boolean actionRequired, 2067 OrderByComparator<UserNotificationEvent> orderByComparator) { 2068 return getPersistence() 2069 .fetchByU_DT_D_A_First(userId, deliveryType, delivered, 2070 actionRequired, orderByComparator); 2071 } 2072 2073 /** 2074 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2075 * 2076 * @param userId the user ID 2077 * @param deliveryType the delivery type 2078 * @param delivered the delivered 2079 * @param actionRequired the action required 2080 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2081 * @return the last matching user notification event 2082 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2083 */ 2084 public static UserNotificationEvent findByU_DT_D_A_Last(long userId, 2085 int deliveryType, boolean delivered, boolean actionRequired, 2086 OrderByComparator<UserNotificationEvent> orderByComparator) 2087 throws com.liferay.portal.NoSuchUserNotificationEventException { 2088 return getPersistence() 2089 .findByU_DT_D_A_Last(userId, deliveryType, delivered, 2090 actionRequired, orderByComparator); 2091 } 2092 2093 /** 2094 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2095 * 2096 * @param userId the user ID 2097 * @param deliveryType the delivery type 2098 * @param delivered the delivered 2099 * @param actionRequired the action required 2100 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2101 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 2102 */ 2103 public static UserNotificationEvent fetchByU_DT_D_A_Last(long userId, 2104 int deliveryType, boolean delivered, boolean actionRequired, 2105 OrderByComparator<UserNotificationEvent> orderByComparator) { 2106 return getPersistence() 2107 .fetchByU_DT_D_A_Last(userId, deliveryType, delivered, 2108 actionRequired, orderByComparator); 2109 } 2110 2111 /** 2112 * 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 = ?. 2113 * 2114 * @param userNotificationEventId the primary key of the current user notification event 2115 * @param userId the user ID 2116 * @param deliveryType the delivery type 2117 * @param delivered the delivered 2118 * @param actionRequired the action required 2119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2120 * @return the previous, current, and next user notification event 2121 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2122 */ 2123 public static UserNotificationEvent[] findByU_DT_D_A_PrevAndNext( 2124 long userNotificationEventId, long userId, int deliveryType, 2125 boolean delivered, boolean actionRequired, 2126 OrderByComparator<UserNotificationEvent> orderByComparator) 2127 throws com.liferay.portal.NoSuchUserNotificationEventException { 2128 return getPersistence() 2129 .findByU_DT_D_A_PrevAndNext(userNotificationEventId, userId, 2130 deliveryType, delivered, actionRequired, orderByComparator); 2131 } 2132 2133 /** 2134 * Removes all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ? from the database. 2135 * 2136 * @param userId the user ID 2137 * @param deliveryType the delivery type 2138 * @param delivered the delivered 2139 * @param actionRequired the action required 2140 */ 2141 public static void removeByU_DT_D_A(long userId, int deliveryType, 2142 boolean delivered, boolean actionRequired) { 2143 getPersistence() 2144 .removeByU_DT_D_A(userId, deliveryType, delivered, actionRequired); 2145 } 2146 2147 /** 2148 * Returns the number of user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 2149 * 2150 * @param userId the user ID 2151 * @param deliveryType the delivery type 2152 * @param delivered the delivered 2153 * @param actionRequired the action required 2154 * @return the number of matching user notification events 2155 */ 2156 public static int countByU_DT_D_A(long userId, int deliveryType, 2157 boolean delivered, boolean actionRequired) { 2158 return getPersistence() 2159 .countByU_DT_D_A(userId, deliveryType, delivered, 2160 actionRequired); 2161 } 2162 2163 /** 2164 * Returns all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2165 * 2166 * @param userId the user ID 2167 * @param deliveryType the delivery type 2168 * @param actionRequired the action required 2169 * @param archived the archived 2170 * @return the matching user notification events 2171 */ 2172 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 2173 int deliveryType, boolean actionRequired, boolean archived) { 2174 return getPersistence() 2175 .findByU_DT_A_A(userId, deliveryType, actionRequired, 2176 archived); 2177 } 2178 2179 /** 2180 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2181 * 2182 * <p> 2183 * 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. 2184 * </p> 2185 * 2186 * @param userId the user ID 2187 * @param deliveryType the delivery type 2188 * @param actionRequired the action required 2189 * @param archived the archived 2190 * @param start the lower bound of the range of user notification events 2191 * @param end the upper bound of the range of user notification events (not inclusive) 2192 * @return the range of matching user notification events 2193 */ 2194 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 2195 int deliveryType, boolean actionRequired, boolean archived, int start, 2196 int end) { 2197 return getPersistence() 2198 .findByU_DT_A_A(userId, deliveryType, actionRequired, 2199 archived, start, end); 2200 } 2201 2202 /** 2203 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2204 * 2205 * <p> 2206 * 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. 2207 * </p> 2208 * 2209 * @param userId the user ID 2210 * @param deliveryType the delivery type 2211 * @param actionRequired the action required 2212 * @param archived the archived 2213 * @param start the lower bound of the range of user notification events 2214 * @param end the upper bound of the range of user notification events (not inclusive) 2215 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2216 * @return the ordered range of matching user notification events 2217 */ 2218 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 2219 int deliveryType, boolean actionRequired, boolean archived, int start, 2220 int end, OrderByComparator<UserNotificationEvent> orderByComparator) { 2221 return getPersistence() 2222 .findByU_DT_A_A(userId, deliveryType, actionRequired, 2223 archived, start, end, orderByComparator); 2224 } 2225 2226 /** 2227 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2228 * 2229 * <p> 2230 * 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. 2231 * </p> 2232 * 2233 * @param userId the user ID 2234 * @param deliveryType the delivery type 2235 * @param actionRequired the action required 2236 * @param archived the archived 2237 * @param start the lower bound of the range of user notification events 2238 * @param end the upper bound of the range of user notification events (not inclusive) 2239 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2240 * @param retrieveFromCache whether to retrieve from the finder cache 2241 * @return the ordered range of matching user notification events 2242 */ 2243 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 2244 int deliveryType, boolean actionRequired, boolean archived, int start, 2245 int end, OrderByComparator<UserNotificationEvent> orderByComparator, 2246 boolean retrieveFromCache) { 2247 return getPersistence() 2248 .findByU_DT_A_A(userId, deliveryType, actionRequired, 2249 archived, start, end, orderByComparator, retrieveFromCache); 2250 } 2251 2252 /** 2253 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2254 * 2255 * @param userId the user ID 2256 * @param deliveryType the delivery type 2257 * @param actionRequired the action required 2258 * @param archived the archived 2259 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2260 * @return the first matching user notification event 2261 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2262 */ 2263 public static UserNotificationEvent findByU_DT_A_A_First(long userId, 2264 int deliveryType, boolean actionRequired, boolean archived, 2265 OrderByComparator<UserNotificationEvent> orderByComparator) 2266 throws com.liferay.portal.NoSuchUserNotificationEventException { 2267 return getPersistence() 2268 .findByU_DT_A_A_First(userId, deliveryType, actionRequired, 2269 archived, orderByComparator); 2270 } 2271 2272 /** 2273 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2274 * 2275 * @param userId the user ID 2276 * @param deliveryType the delivery type 2277 * @param actionRequired the action required 2278 * @param archived the archived 2279 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2280 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 2281 */ 2282 public static UserNotificationEvent fetchByU_DT_A_A_First(long userId, 2283 int deliveryType, boolean actionRequired, boolean archived, 2284 OrderByComparator<UserNotificationEvent> orderByComparator) { 2285 return getPersistence() 2286 .fetchByU_DT_A_A_First(userId, deliveryType, actionRequired, 2287 archived, orderByComparator); 2288 } 2289 2290 /** 2291 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2292 * 2293 * @param userId the user ID 2294 * @param deliveryType the delivery type 2295 * @param actionRequired the action required 2296 * @param archived the archived 2297 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2298 * @return the last matching user notification event 2299 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2300 */ 2301 public static UserNotificationEvent findByU_DT_A_A_Last(long userId, 2302 int deliveryType, boolean actionRequired, boolean archived, 2303 OrderByComparator<UserNotificationEvent> orderByComparator) 2304 throws com.liferay.portal.NoSuchUserNotificationEventException { 2305 return getPersistence() 2306 .findByU_DT_A_A_Last(userId, deliveryType, actionRequired, 2307 archived, orderByComparator); 2308 } 2309 2310 /** 2311 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2312 * 2313 * @param userId the user ID 2314 * @param deliveryType the delivery type 2315 * @param actionRequired the action required 2316 * @param archived the archived 2317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2318 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 2319 */ 2320 public static UserNotificationEvent fetchByU_DT_A_A_Last(long userId, 2321 int deliveryType, boolean actionRequired, boolean archived, 2322 OrderByComparator<UserNotificationEvent> orderByComparator) { 2323 return getPersistence() 2324 .fetchByU_DT_A_A_Last(userId, deliveryType, actionRequired, 2325 archived, orderByComparator); 2326 } 2327 2328 /** 2329 * 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 = ?. 2330 * 2331 * @param userNotificationEventId the primary key of the current user notification event 2332 * @param userId the user ID 2333 * @param deliveryType the delivery type 2334 * @param actionRequired the action required 2335 * @param archived the archived 2336 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2337 * @return the previous, current, and next user notification event 2338 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2339 */ 2340 public static UserNotificationEvent[] findByU_DT_A_A_PrevAndNext( 2341 long userNotificationEventId, long userId, int deliveryType, 2342 boolean actionRequired, boolean archived, 2343 OrderByComparator<UserNotificationEvent> orderByComparator) 2344 throws com.liferay.portal.NoSuchUserNotificationEventException { 2345 return getPersistence() 2346 .findByU_DT_A_A_PrevAndNext(userNotificationEventId, userId, 2347 deliveryType, actionRequired, archived, orderByComparator); 2348 } 2349 2350 /** 2351 * Removes all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ? from the database. 2352 * 2353 * @param userId the user ID 2354 * @param deliveryType the delivery type 2355 * @param actionRequired the action required 2356 * @param archived the archived 2357 */ 2358 public static void removeByU_DT_A_A(long userId, int deliveryType, 2359 boolean actionRequired, boolean archived) { 2360 getPersistence() 2361 .removeByU_DT_A_A(userId, deliveryType, actionRequired, archived); 2362 } 2363 2364 /** 2365 * Returns the number of user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2366 * 2367 * @param userId the user ID 2368 * @param deliveryType the delivery type 2369 * @param actionRequired the action required 2370 * @param archived the archived 2371 * @return the number of matching user notification events 2372 */ 2373 public static int countByU_DT_A_A(long userId, int deliveryType, 2374 boolean actionRequired, boolean archived) { 2375 return getPersistence() 2376 .countByU_DT_A_A(userId, deliveryType, actionRequired, 2377 archived); 2378 } 2379 2380 /** 2381 * Caches the user notification event in the entity cache if it is enabled. 2382 * 2383 * @param userNotificationEvent the user notification event 2384 */ 2385 public static void cacheResult(UserNotificationEvent userNotificationEvent) { 2386 getPersistence().cacheResult(userNotificationEvent); 2387 } 2388 2389 /** 2390 * Caches the user notification events in the entity cache if it is enabled. 2391 * 2392 * @param userNotificationEvents the user notification events 2393 */ 2394 public static void cacheResult( 2395 List<UserNotificationEvent> userNotificationEvents) { 2396 getPersistence().cacheResult(userNotificationEvents); 2397 } 2398 2399 /** 2400 * Creates a new user notification event with the primary key. Does not add the user notification event to the database. 2401 * 2402 * @param userNotificationEventId the primary key for the new user notification event 2403 * @return the new user notification event 2404 */ 2405 public static UserNotificationEvent create(long userNotificationEventId) { 2406 return getPersistence().create(userNotificationEventId); 2407 } 2408 2409 /** 2410 * Removes the user notification event with the primary key from the database. Also notifies the appropriate model listeners. 2411 * 2412 * @param userNotificationEventId the primary key of the user notification event 2413 * @return the user notification event that was removed 2414 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2415 */ 2416 public static UserNotificationEvent remove(long userNotificationEventId) 2417 throws com.liferay.portal.NoSuchUserNotificationEventException { 2418 return getPersistence().remove(userNotificationEventId); 2419 } 2420 2421 public static UserNotificationEvent updateImpl( 2422 UserNotificationEvent userNotificationEvent) { 2423 return getPersistence().updateImpl(userNotificationEvent); 2424 } 2425 2426 /** 2427 * Returns the user notification event with the primary key or throws a {@link NoSuchUserNotificationEventException} if it could not be found. 2428 * 2429 * @param userNotificationEventId the primary key of the user notification event 2430 * @return the user notification event 2431 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2432 */ 2433 public static UserNotificationEvent findByPrimaryKey( 2434 long userNotificationEventId) 2435 throws com.liferay.portal.NoSuchUserNotificationEventException { 2436 return getPersistence().findByPrimaryKey(userNotificationEventId); 2437 } 2438 2439 /** 2440 * Returns the user notification event with the primary key or returns <code>null</code> if it could not be found. 2441 * 2442 * @param userNotificationEventId the primary key of the user notification event 2443 * @return the user notification event, or <code>null</code> if a user notification event with the primary key could not be found 2444 */ 2445 public static UserNotificationEvent fetchByPrimaryKey( 2446 long userNotificationEventId) { 2447 return getPersistence().fetchByPrimaryKey(userNotificationEventId); 2448 } 2449 2450 public static java.util.Map<java.io.Serializable, UserNotificationEvent> fetchByPrimaryKeys( 2451 java.util.Set<java.io.Serializable> primaryKeys) { 2452 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2453 } 2454 2455 /** 2456 * Returns all the user notification events. 2457 * 2458 * @return the user notification events 2459 */ 2460 public static List<UserNotificationEvent> findAll() { 2461 return getPersistence().findAll(); 2462 } 2463 2464 /** 2465 * Returns a range of all the user notification events. 2466 * 2467 * <p> 2468 * 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. 2469 * </p> 2470 * 2471 * @param start the lower bound of the range of user notification events 2472 * @param end the upper bound of the range of user notification events (not inclusive) 2473 * @return the range of user notification events 2474 */ 2475 public static List<UserNotificationEvent> findAll(int start, int end) { 2476 return getPersistence().findAll(start, end); 2477 } 2478 2479 /** 2480 * Returns an ordered range of all the user notification events. 2481 * 2482 * <p> 2483 * 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. 2484 * </p> 2485 * 2486 * @param start the lower bound of the range of user notification events 2487 * @param end the upper bound of the range of user notification events (not inclusive) 2488 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2489 * @return the ordered range of user notification events 2490 */ 2491 public static List<UserNotificationEvent> findAll(int start, int end, 2492 OrderByComparator<UserNotificationEvent> orderByComparator) { 2493 return getPersistence().findAll(start, end, orderByComparator); 2494 } 2495 2496 /** 2497 * Returns an ordered range of all the user notification events. 2498 * 2499 * <p> 2500 * 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. 2501 * </p> 2502 * 2503 * @param start the lower bound of the range of user notification events 2504 * @param end the upper bound of the range of user notification events (not inclusive) 2505 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2506 * @param retrieveFromCache whether to retrieve from the finder cache 2507 * @return the ordered range of user notification events 2508 */ 2509 public static List<UserNotificationEvent> findAll(int start, int end, 2510 OrderByComparator<UserNotificationEvent> orderByComparator, 2511 boolean retrieveFromCache) { 2512 return getPersistence() 2513 .findAll(start, end, orderByComparator, retrieveFromCache); 2514 } 2515 2516 /** 2517 * Removes all the user notification events from the database. 2518 */ 2519 public static void removeAll() { 2520 getPersistence().removeAll(); 2521 } 2522 2523 /** 2524 * Returns the number of user notification events. 2525 * 2526 * @return the number of user notification events 2527 */ 2528 public static int countAll() { 2529 return getPersistence().countAll(); 2530 } 2531 2532 public static java.util.Set<java.lang.String> getBadColumnNames() { 2533 return getPersistence().getBadColumnNames(); 2534 } 2535 2536 public static UserNotificationEventPersistence getPersistence() { 2537 if (_persistence == null) { 2538 _persistence = (UserNotificationEventPersistence)PortalBeanLocatorUtil.locate(UserNotificationEventPersistence.class.getName()); 2539 2540 ReferenceRegistry.registerReference(UserNotificationEventUtil.class, 2541 "_persistence"); 2542 } 2543 2544 return _persistence; 2545 } 2546 2547 /** 2548 * @deprecated As of 6.2.0 2549 */ 2550 @Deprecated 2551 public void setPersistence(UserNotificationEventPersistence persistence) { 2552 } 2553 2554 private static UserNotificationEventPersistence _persistence; 2555 }