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 the first user notification event in the ordered set where uuid = ?. 161 * 162 * @param uuid the uuid 163 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 164 * @return the first matching user notification event 165 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 166 */ 167 public static UserNotificationEvent findByUuid_First( 168 java.lang.String uuid, 169 OrderByComparator<UserNotificationEvent> orderByComparator) 170 throws com.liferay.portal.NoSuchUserNotificationEventException { 171 return getPersistence().findByUuid_First(uuid, orderByComparator); 172 } 173 174 /** 175 * Returns the first user notification event in the ordered set where uuid = ?. 176 * 177 * @param uuid the uuid 178 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 179 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 180 */ 181 public static UserNotificationEvent fetchByUuid_First( 182 java.lang.String uuid, 183 OrderByComparator<UserNotificationEvent> orderByComparator) { 184 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 185 } 186 187 /** 188 * Returns the last user notification event in the ordered set where uuid = ?. 189 * 190 * @param uuid the uuid 191 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 192 * @return the last matching user notification event 193 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 194 */ 195 public static UserNotificationEvent findByUuid_Last(java.lang.String uuid, 196 OrderByComparator<UserNotificationEvent> orderByComparator) 197 throws com.liferay.portal.NoSuchUserNotificationEventException { 198 return getPersistence().findByUuid_Last(uuid, orderByComparator); 199 } 200 201 /** 202 * Returns the last user notification event in the ordered set where uuid = ?. 203 * 204 * @param uuid the uuid 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 207 */ 208 public static UserNotificationEvent fetchByUuid_Last( 209 java.lang.String uuid, 210 OrderByComparator<UserNotificationEvent> orderByComparator) { 211 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 212 } 213 214 /** 215 * Returns the user notification events before and after the current user notification event in the ordered set where uuid = ?. 216 * 217 * @param userNotificationEventId the primary key of the current user notification event 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the previous, current, and next user notification event 221 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 222 */ 223 public static UserNotificationEvent[] findByUuid_PrevAndNext( 224 long userNotificationEventId, java.lang.String uuid, 225 OrderByComparator<UserNotificationEvent> orderByComparator) 226 throws com.liferay.portal.NoSuchUserNotificationEventException { 227 return getPersistence() 228 .findByUuid_PrevAndNext(userNotificationEventId, uuid, 229 orderByComparator); 230 } 231 232 /** 233 * Removes all the user notification events where uuid = ? from the database. 234 * 235 * @param uuid the uuid 236 */ 237 public static void removeByUuid(java.lang.String uuid) { 238 getPersistence().removeByUuid(uuid); 239 } 240 241 /** 242 * Returns the number of user notification events where uuid = ?. 243 * 244 * @param uuid the uuid 245 * @return the number of matching user notification events 246 */ 247 public static int countByUuid(java.lang.String uuid) { 248 return getPersistence().countByUuid(uuid); 249 } 250 251 /** 252 * Returns all the user notification events where uuid = ? and companyId = ?. 253 * 254 * @param uuid the uuid 255 * @param companyId the company ID 256 * @return the matching user notification events 257 */ 258 public static List<UserNotificationEvent> findByUuid_C( 259 java.lang.String uuid, long companyId) { 260 return getPersistence().findByUuid_C(uuid, companyId); 261 } 262 263 /** 264 * Returns a range of all the user notification events where uuid = ? and companyId = ?. 265 * 266 * <p> 267 * 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. 268 * </p> 269 * 270 * @param uuid the uuid 271 * @param companyId the company ID 272 * @param start the lower bound of the range of user notification events 273 * @param end the upper bound of the range of user notification events (not inclusive) 274 * @return the range of matching user notification events 275 */ 276 public static List<UserNotificationEvent> findByUuid_C( 277 java.lang.String uuid, long companyId, int start, int end) { 278 return getPersistence().findByUuid_C(uuid, companyId, start, end); 279 } 280 281 /** 282 * Returns an ordered range of all the user notification events where uuid = ? and companyId = ?. 283 * 284 * <p> 285 * 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. 286 * </p> 287 * 288 * @param uuid the uuid 289 * @param companyId the company ID 290 * @param start the lower bound of the range of user notification events 291 * @param end the upper bound of the range of user notification events (not inclusive) 292 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 293 * @return the ordered range of matching user notification events 294 */ 295 public static List<UserNotificationEvent> findByUuid_C( 296 java.lang.String uuid, long companyId, int start, int end, 297 OrderByComparator<UserNotificationEvent> orderByComparator) { 298 return getPersistence() 299 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 300 } 301 302 /** 303 * Returns the first user notification event in the ordered set where uuid = ? and companyId = ?. 304 * 305 * @param uuid the uuid 306 * @param companyId the company ID 307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 308 * @return the first matching user notification event 309 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 310 */ 311 public static UserNotificationEvent findByUuid_C_First( 312 java.lang.String uuid, long companyId, 313 OrderByComparator<UserNotificationEvent> orderByComparator) 314 throws com.liferay.portal.NoSuchUserNotificationEventException { 315 return getPersistence() 316 .findByUuid_C_First(uuid, companyId, orderByComparator); 317 } 318 319 /** 320 * Returns the first user notification event in the ordered set where uuid = ? and companyId = ?. 321 * 322 * @param uuid the uuid 323 * @param companyId the company ID 324 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 325 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 326 */ 327 public static UserNotificationEvent fetchByUuid_C_First( 328 java.lang.String uuid, long companyId, 329 OrderByComparator<UserNotificationEvent> orderByComparator) { 330 return getPersistence() 331 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 332 } 333 334 /** 335 * Returns the last user notification event in the ordered set where uuid = ? and companyId = ?. 336 * 337 * @param uuid the uuid 338 * @param companyId the company ID 339 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 340 * @return the last matching user notification event 341 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 342 */ 343 public static UserNotificationEvent findByUuid_C_Last( 344 java.lang.String uuid, long companyId, 345 OrderByComparator<UserNotificationEvent> orderByComparator) 346 throws com.liferay.portal.NoSuchUserNotificationEventException { 347 return getPersistence() 348 .findByUuid_C_Last(uuid, companyId, orderByComparator); 349 } 350 351 /** 352 * Returns the last user notification event in the ordered set where uuid = ? and companyId = ?. 353 * 354 * @param uuid the uuid 355 * @param companyId the company ID 356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 357 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 358 */ 359 public static UserNotificationEvent fetchByUuid_C_Last( 360 java.lang.String uuid, long companyId, 361 OrderByComparator<UserNotificationEvent> orderByComparator) { 362 return getPersistence() 363 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 364 } 365 366 /** 367 * Returns the user notification events before and after the current user notification event in the ordered set where uuid = ? and companyId = ?. 368 * 369 * @param userNotificationEventId the primary key of the current user notification event 370 * @param uuid the uuid 371 * @param companyId the company ID 372 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 373 * @return the previous, current, and next user notification event 374 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 375 */ 376 public static UserNotificationEvent[] findByUuid_C_PrevAndNext( 377 long userNotificationEventId, java.lang.String uuid, long companyId, 378 OrderByComparator<UserNotificationEvent> orderByComparator) 379 throws com.liferay.portal.NoSuchUserNotificationEventException { 380 return getPersistence() 381 .findByUuid_C_PrevAndNext(userNotificationEventId, uuid, 382 companyId, orderByComparator); 383 } 384 385 /** 386 * Removes all the user notification events where uuid = ? and companyId = ? from the database. 387 * 388 * @param uuid the uuid 389 * @param companyId the company ID 390 */ 391 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 392 getPersistence().removeByUuid_C(uuid, companyId); 393 } 394 395 /** 396 * Returns the number of user notification events where uuid = ? and companyId = ?. 397 * 398 * @param uuid the uuid 399 * @param companyId the company ID 400 * @return the number of matching user notification events 401 */ 402 public static int countByUuid_C(java.lang.String uuid, long companyId) { 403 return getPersistence().countByUuid_C(uuid, companyId); 404 } 405 406 /** 407 * Returns all the user notification events where userId = ?. 408 * 409 * @param userId the user ID 410 * @return the matching user notification events 411 */ 412 public static List<UserNotificationEvent> findByUserId(long userId) { 413 return getPersistence().findByUserId(userId); 414 } 415 416 /** 417 * Returns a range of all the user notification events where userId = ?. 418 * 419 * <p> 420 * 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. 421 * </p> 422 * 423 * @param userId the user ID 424 * @param start the lower bound of the range of user notification events 425 * @param end the upper bound of the range of user notification events (not inclusive) 426 * @return the range of matching user notification events 427 */ 428 public static List<UserNotificationEvent> findByUserId(long userId, 429 int start, int end) { 430 return getPersistence().findByUserId(userId, start, end); 431 } 432 433 /** 434 * Returns an ordered range of all the user notification events where userId = ?. 435 * 436 * <p> 437 * 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. 438 * </p> 439 * 440 * @param userId the user ID 441 * @param start the lower bound of the range of user notification events 442 * @param end the upper bound of the range of user notification events (not inclusive) 443 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 444 * @return the ordered range of matching user notification events 445 */ 446 public static List<UserNotificationEvent> findByUserId(long userId, 447 int start, int end, 448 OrderByComparator<UserNotificationEvent> orderByComparator) { 449 return getPersistence() 450 .findByUserId(userId, start, end, orderByComparator); 451 } 452 453 /** 454 * Returns the first user notification event in the ordered set where userId = ?. 455 * 456 * @param userId the user ID 457 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 458 * @return the first matching user notification event 459 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 460 */ 461 public static UserNotificationEvent findByUserId_First(long userId, 462 OrderByComparator<UserNotificationEvent> orderByComparator) 463 throws com.liferay.portal.NoSuchUserNotificationEventException { 464 return getPersistence().findByUserId_First(userId, orderByComparator); 465 } 466 467 /** 468 * Returns the first user notification event in the ordered set where userId = ?. 469 * 470 * @param userId the user ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 473 */ 474 public static UserNotificationEvent fetchByUserId_First(long userId, 475 OrderByComparator<UserNotificationEvent> orderByComparator) { 476 return getPersistence().fetchByUserId_First(userId, orderByComparator); 477 } 478 479 /** 480 * Returns the last user notification event in the ordered set where userId = ?. 481 * 482 * @param userId the user ID 483 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 484 * @return the last matching user notification event 485 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 486 */ 487 public static UserNotificationEvent findByUserId_Last(long userId, 488 OrderByComparator<UserNotificationEvent> orderByComparator) 489 throws com.liferay.portal.NoSuchUserNotificationEventException { 490 return getPersistence().findByUserId_Last(userId, orderByComparator); 491 } 492 493 /** 494 * Returns the last user notification event in the ordered set where userId = ?. 495 * 496 * @param userId the user ID 497 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 498 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 499 */ 500 public static UserNotificationEvent fetchByUserId_Last(long userId, 501 OrderByComparator<UserNotificationEvent> orderByComparator) { 502 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 503 } 504 505 /** 506 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ?. 507 * 508 * @param userNotificationEventId the primary key of the current user notification event 509 * @param userId the user ID 510 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 511 * @return the previous, current, and next user notification event 512 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 513 */ 514 public static UserNotificationEvent[] findByUserId_PrevAndNext( 515 long userNotificationEventId, long userId, 516 OrderByComparator<UserNotificationEvent> orderByComparator) 517 throws com.liferay.portal.NoSuchUserNotificationEventException { 518 return getPersistence() 519 .findByUserId_PrevAndNext(userNotificationEventId, userId, 520 orderByComparator); 521 } 522 523 /** 524 * Removes all the user notification events where userId = ? from the database. 525 * 526 * @param userId the user ID 527 */ 528 public static void removeByUserId(long userId) { 529 getPersistence().removeByUserId(userId); 530 } 531 532 /** 533 * Returns the number of user notification events where userId = ?. 534 * 535 * @param userId the user ID 536 * @return the number of matching user notification events 537 */ 538 public static int countByUserId(long userId) { 539 return getPersistence().countByUserId(userId); 540 } 541 542 /** 543 * Returns all the user notification events where userId = ? and deliveryType = ?. 544 * 545 * @param userId the user ID 546 * @param deliveryType the delivery type 547 * @return the matching user notification events 548 */ 549 public static List<UserNotificationEvent> findByU_DT(long userId, 550 int deliveryType) { 551 return getPersistence().findByU_DT(userId, deliveryType); 552 } 553 554 /** 555 * Returns a range of all the user notification events where userId = ? and deliveryType = ?. 556 * 557 * <p> 558 * 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. 559 * </p> 560 * 561 * @param userId the user ID 562 * @param deliveryType the delivery type 563 * @param start the lower bound of the range of user notification events 564 * @param end the upper bound of the range of user notification events (not inclusive) 565 * @return the range of matching user notification events 566 */ 567 public static List<UserNotificationEvent> findByU_DT(long userId, 568 int deliveryType, int start, int end) { 569 return getPersistence().findByU_DT(userId, deliveryType, start, end); 570 } 571 572 /** 573 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ?. 574 * 575 * <p> 576 * 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. 577 * </p> 578 * 579 * @param userId the user ID 580 * @param deliveryType the delivery type 581 * @param start the lower bound of the range of user notification events 582 * @param end the upper bound of the range of user notification events (not inclusive) 583 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 584 * @return the ordered range of matching user notification events 585 */ 586 public static List<UserNotificationEvent> findByU_DT(long userId, 587 int deliveryType, int start, int end, 588 OrderByComparator<UserNotificationEvent> orderByComparator) { 589 return getPersistence() 590 .findByU_DT(userId, deliveryType, start, end, 591 orderByComparator); 592 } 593 594 /** 595 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ?. 596 * 597 * @param userId the user ID 598 * @param deliveryType the delivery type 599 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 600 * @return the first matching user notification event 601 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 602 */ 603 public static UserNotificationEvent findByU_DT_First(long userId, 604 int deliveryType, 605 OrderByComparator<UserNotificationEvent> orderByComparator) 606 throws com.liferay.portal.NoSuchUserNotificationEventException { 607 return getPersistence() 608 .findByU_DT_First(userId, deliveryType, orderByComparator); 609 } 610 611 /** 612 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ?. 613 * 614 * @param userId the user ID 615 * @param deliveryType the delivery type 616 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 617 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 618 */ 619 public static UserNotificationEvent fetchByU_DT_First(long userId, 620 int deliveryType, 621 OrderByComparator<UserNotificationEvent> orderByComparator) { 622 return getPersistence() 623 .fetchByU_DT_First(userId, deliveryType, orderByComparator); 624 } 625 626 /** 627 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ?. 628 * 629 * @param userId the user ID 630 * @param deliveryType the delivery type 631 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 632 * @return the last matching user notification event 633 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 634 */ 635 public static UserNotificationEvent findByU_DT_Last(long userId, 636 int deliveryType, 637 OrderByComparator<UserNotificationEvent> orderByComparator) 638 throws com.liferay.portal.NoSuchUserNotificationEventException { 639 return getPersistence() 640 .findByU_DT_Last(userId, deliveryType, orderByComparator); 641 } 642 643 /** 644 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ?. 645 * 646 * @param userId the user ID 647 * @param deliveryType the delivery type 648 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 649 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 650 */ 651 public static UserNotificationEvent fetchByU_DT_Last(long userId, 652 int deliveryType, 653 OrderByComparator<UserNotificationEvent> orderByComparator) { 654 return getPersistence() 655 .fetchByU_DT_Last(userId, deliveryType, orderByComparator); 656 } 657 658 /** 659 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ?. 660 * 661 * @param userNotificationEventId the primary key of the current user notification event 662 * @param userId the user ID 663 * @param deliveryType the delivery type 664 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 665 * @return the previous, current, and next user notification event 666 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 667 */ 668 public static UserNotificationEvent[] findByU_DT_PrevAndNext( 669 long userNotificationEventId, long userId, int deliveryType, 670 OrderByComparator<UserNotificationEvent> orderByComparator) 671 throws com.liferay.portal.NoSuchUserNotificationEventException { 672 return getPersistence() 673 .findByU_DT_PrevAndNext(userNotificationEventId, userId, 674 deliveryType, orderByComparator); 675 } 676 677 /** 678 * Removes all the user notification events where userId = ? and deliveryType = ? from the database. 679 * 680 * @param userId the user ID 681 * @param deliveryType the delivery type 682 */ 683 public static void removeByU_DT(long userId, int deliveryType) { 684 getPersistence().removeByU_DT(userId, deliveryType); 685 } 686 687 /** 688 * Returns the number of user notification events where userId = ? and deliveryType = ?. 689 * 690 * @param userId the user ID 691 * @param deliveryType the delivery type 692 * @return the number of matching user notification events 693 */ 694 public static int countByU_DT(long userId, int deliveryType) { 695 return getPersistence().countByU_DT(userId, deliveryType); 696 } 697 698 /** 699 * Returns all the user notification events where userId = ? and delivered = ?. 700 * 701 * @param userId the user ID 702 * @param delivered the delivered 703 * @return the matching user notification events 704 */ 705 public static List<UserNotificationEvent> findByU_D(long userId, 706 boolean delivered) { 707 return getPersistence().findByU_D(userId, delivered); 708 } 709 710 /** 711 * Returns a range of all the user notification events where userId = ? and delivered = ?. 712 * 713 * <p> 714 * 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. 715 * </p> 716 * 717 * @param userId the user ID 718 * @param delivered the delivered 719 * @param start the lower bound of the range of user notification events 720 * @param end the upper bound of the range of user notification events (not inclusive) 721 * @return the range of matching user notification events 722 */ 723 public static List<UserNotificationEvent> findByU_D(long userId, 724 boolean delivered, int start, int end) { 725 return getPersistence().findByU_D(userId, delivered, start, end); 726 } 727 728 /** 729 * Returns an ordered range of all the user notification events where userId = ? and delivered = ?. 730 * 731 * <p> 732 * 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. 733 * </p> 734 * 735 * @param userId the user ID 736 * @param delivered the delivered 737 * @param start the lower bound of the range of user notification events 738 * @param end the upper bound of the range of user notification events (not inclusive) 739 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 740 * @return the ordered range of matching user notification events 741 */ 742 public static List<UserNotificationEvent> findByU_D(long userId, 743 boolean delivered, int start, int end, 744 OrderByComparator<UserNotificationEvent> orderByComparator) { 745 return getPersistence() 746 .findByU_D(userId, delivered, start, end, orderByComparator); 747 } 748 749 /** 750 * Returns the first user notification event in the ordered set where userId = ? and delivered = ?. 751 * 752 * @param userId the user ID 753 * @param delivered the delivered 754 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 755 * @return the first matching user notification event 756 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 757 */ 758 public static UserNotificationEvent findByU_D_First(long userId, 759 boolean delivered, 760 OrderByComparator<UserNotificationEvent> orderByComparator) 761 throws com.liferay.portal.NoSuchUserNotificationEventException { 762 return getPersistence() 763 .findByU_D_First(userId, delivered, orderByComparator); 764 } 765 766 /** 767 * Returns the first user notification event in the ordered set where userId = ? and delivered = ?. 768 * 769 * @param userId the user ID 770 * @param delivered the delivered 771 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 772 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 773 */ 774 public static UserNotificationEvent fetchByU_D_First(long userId, 775 boolean delivered, 776 OrderByComparator<UserNotificationEvent> orderByComparator) { 777 return getPersistence() 778 .fetchByU_D_First(userId, delivered, orderByComparator); 779 } 780 781 /** 782 * Returns the last user notification event in the ordered set where userId = ? and delivered = ?. 783 * 784 * @param userId the user ID 785 * @param delivered the delivered 786 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 787 * @return the last matching user notification event 788 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 789 */ 790 public static UserNotificationEvent findByU_D_Last(long userId, 791 boolean delivered, 792 OrderByComparator<UserNotificationEvent> orderByComparator) 793 throws com.liferay.portal.NoSuchUserNotificationEventException { 794 return getPersistence() 795 .findByU_D_Last(userId, delivered, orderByComparator); 796 } 797 798 /** 799 * Returns the last user notification event in the ordered set where userId = ? and delivered = ?. 800 * 801 * @param userId the user ID 802 * @param delivered the delivered 803 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 804 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 805 */ 806 public static UserNotificationEvent fetchByU_D_Last(long userId, 807 boolean delivered, 808 OrderByComparator<UserNotificationEvent> orderByComparator) { 809 return getPersistence() 810 .fetchByU_D_Last(userId, delivered, orderByComparator); 811 } 812 813 /** 814 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and delivered = ?. 815 * 816 * @param userNotificationEventId the primary key of the current user notification event 817 * @param userId the user ID 818 * @param delivered the delivered 819 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 820 * @return the previous, current, and next user notification event 821 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 822 */ 823 public static UserNotificationEvent[] findByU_D_PrevAndNext( 824 long userNotificationEventId, long userId, boolean delivered, 825 OrderByComparator<UserNotificationEvent> orderByComparator) 826 throws com.liferay.portal.NoSuchUserNotificationEventException { 827 return getPersistence() 828 .findByU_D_PrevAndNext(userNotificationEventId, userId, 829 delivered, orderByComparator); 830 } 831 832 /** 833 * Removes all the user notification events where userId = ? and delivered = ? from the database. 834 * 835 * @param userId the user ID 836 * @param delivered the delivered 837 */ 838 public static void removeByU_D(long userId, boolean delivered) { 839 getPersistence().removeByU_D(userId, delivered); 840 } 841 842 /** 843 * Returns the number of user notification events where userId = ? and delivered = ?. 844 * 845 * @param userId the user ID 846 * @param delivered the delivered 847 * @return the number of matching user notification events 848 */ 849 public static int countByU_D(long userId, boolean delivered) { 850 return getPersistence().countByU_D(userId, delivered); 851 } 852 853 /** 854 * Returns all the user notification events where userId = ? and archived = ?. 855 * 856 * @param userId the user ID 857 * @param archived the archived 858 * @return the matching user notification events 859 */ 860 public static List<UserNotificationEvent> findByU_A(long userId, 861 boolean archived) { 862 return getPersistence().findByU_A(userId, archived); 863 } 864 865 /** 866 * Returns a range of all the user notification events where userId = ? and archived = ?. 867 * 868 * <p> 869 * 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. 870 * </p> 871 * 872 * @param userId the user ID 873 * @param archived the archived 874 * @param start the lower bound of the range of user notification events 875 * @param end the upper bound of the range of user notification events (not inclusive) 876 * @return the range of matching user notification events 877 */ 878 public static List<UserNotificationEvent> findByU_A(long userId, 879 boolean archived, int start, int end) { 880 return getPersistence().findByU_A(userId, archived, start, end); 881 } 882 883 /** 884 * Returns an ordered range of all the user notification events where userId = ? and archived = ?. 885 * 886 * <p> 887 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 888 * </p> 889 * 890 * @param userId the user ID 891 * @param archived the archived 892 * @param start the lower bound of the range of user notification events 893 * @param end the upper bound of the range of user notification events (not inclusive) 894 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 895 * @return the ordered range of matching user notification events 896 */ 897 public static List<UserNotificationEvent> findByU_A(long userId, 898 boolean archived, int start, int end, 899 OrderByComparator<UserNotificationEvent> orderByComparator) { 900 return getPersistence() 901 .findByU_A(userId, archived, start, end, orderByComparator); 902 } 903 904 /** 905 * Returns the first user notification event in the ordered set where userId = ? and archived = ?. 906 * 907 * @param userId the user ID 908 * @param archived the archived 909 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 910 * @return the first matching user notification event 911 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 912 */ 913 public static UserNotificationEvent findByU_A_First(long userId, 914 boolean archived, 915 OrderByComparator<UserNotificationEvent> orderByComparator) 916 throws com.liferay.portal.NoSuchUserNotificationEventException { 917 return getPersistence() 918 .findByU_A_First(userId, archived, orderByComparator); 919 } 920 921 /** 922 * Returns the first user notification event in the ordered set where userId = ? and archived = ?. 923 * 924 * @param userId the user ID 925 * @param archived the archived 926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 927 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 928 */ 929 public static UserNotificationEvent fetchByU_A_First(long userId, 930 boolean archived, 931 OrderByComparator<UserNotificationEvent> orderByComparator) { 932 return getPersistence() 933 .fetchByU_A_First(userId, archived, orderByComparator); 934 } 935 936 /** 937 * Returns the last user notification event in the ordered set where userId = ? and archived = ?. 938 * 939 * @param userId the user ID 940 * @param archived the archived 941 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 942 * @return the last matching user notification event 943 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 944 */ 945 public static UserNotificationEvent findByU_A_Last(long userId, 946 boolean archived, 947 OrderByComparator<UserNotificationEvent> orderByComparator) 948 throws com.liferay.portal.NoSuchUserNotificationEventException { 949 return getPersistence() 950 .findByU_A_Last(userId, archived, orderByComparator); 951 } 952 953 /** 954 * Returns the last user notification event in the ordered set where userId = ? and archived = ?. 955 * 956 * @param userId the user ID 957 * @param archived the archived 958 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 959 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 960 */ 961 public static UserNotificationEvent fetchByU_A_Last(long userId, 962 boolean archived, 963 OrderByComparator<UserNotificationEvent> orderByComparator) { 964 return getPersistence() 965 .fetchByU_A_Last(userId, archived, orderByComparator); 966 } 967 968 /** 969 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and archived = ?. 970 * 971 * @param userNotificationEventId the primary key of the current user notification event 972 * @param userId the user ID 973 * @param archived the archived 974 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 975 * @return the previous, current, and next user notification event 976 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 977 */ 978 public static UserNotificationEvent[] findByU_A_PrevAndNext( 979 long userNotificationEventId, long userId, boolean archived, 980 OrderByComparator<UserNotificationEvent> orderByComparator) 981 throws com.liferay.portal.NoSuchUserNotificationEventException { 982 return getPersistence() 983 .findByU_A_PrevAndNext(userNotificationEventId, userId, 984 archived, orderByComparator); 985 } 986 987 /** 988 * Removes all the user notification events where userId = ? and archived = ? from the database. 989 * 990 * @param userId the user ID 991 * @param archived the archived 992 */ 993 public static void removeByU_A(long userId, boolean archived) { 994 getPersistence().removeByU_A(userId, archived); 995 } 996 997 /** 998 * Returns the number of user notification events where userId = ? and archived = ?. 999 * 1000 * @param userId the user ID 1001 * @param archived the archived 1002 * @return the number of matching user notification events 1003 */ 1004 public static int countByU_A(long userId, boolean archived) { 1005 return getPersistence().countByU_A(userId, archived); 1006 } 1007 1008 /** 1009 * Returns all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1010 * 1011 * @param userId the user ID 1012 * @param deliveryType the delivery type 1013 * @param delivered the delivered 1014 * @return the matching user notification events 1015 */ 1016 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1017 int deliveryType, boolean delivered) { 1018 return getPersistence().findByU_DT_D(userId, deliveryType, delivered); 1019 } 1020 1021 /** 1022 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1023 * 1024 * <p> 1025 * 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. 1026 * </p> 1027 * 1028 * @param userId the user ID 1029 * @param deliveryType the delivery type 1030 * @param delivered the delivered 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 * @return the range of matching user notification events 1034 */ 1035 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1036 int deliveryType, boolean delivered, int start, int end) { 1037 return getPersistence() 1038 .findByU_DT_D(userId, deliveryType, delivered, start, end); 1039 } 1040 1041 /** 1042 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ?. 1043 * 1044 * <p> 1045 * 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. 1046 * </p> 1047 * 1048 * @param userId the user ID 1049 * @param deliveryType the delivery type 1050 * @param delivered the delivered 1051 * @param start the lower bound of the range of user notification events 1052 * @param end the upper bound of the range of user notification events (not inclusive) 1053 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1054 * @return the ordered range of matching user notification events 1055 */ 1056 public static List<UserNotificationEvent> findByU_DT_D(long userId, 1057 int deliveryType, boolean delivered, int start, int end, 1058 OrderByComparator<UserNotificationEvent> orderByComparator) { 1059 return getPersistence() 1060 .findByU_DT_D(userId, deliveryType, delivered, start, end, 1061 orderByComparator); 1062 } 1063 1064 /** 1065 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1066 * 1067 * @param userId the user ID 1068 * @param deliveryType the delivery type 1069 * @param delivered the delivered 1070 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1071 * @return the first matching user notification event 1072 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1073 */ 1074 public static UserNotificationEvent findByU_DT_D_First(long userId, 1075 int deliveryType, boolean delivered, 1076 OrderByComparator<UserNotificationEvent> orderByComparator) 1077 throws com.liferay.portal.NoSuchUserNotificationEventException { 1078 return getPersistence() 1079 .findByU_DT_D_First(userId, deliveryType, delivered, 1080 orderByComparator); 1081 } 1082 1083 /** 1084 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1085 * 1086 * @param userId the user ID 1087 * @param deliveryType the delivery type 1088 * @param delivered the delivered 1089 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1090 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1091 */ 1092 public static UserNotificationEvent fetchByU_DT_D_First(long userId, 1093 int deliveryType, boolean delivered, 1094 OrderByComparator<UserNotificationEvent> orderByComparator) { 1095 return getPersistence() 1096 .fetchByU_DT_D_First(userId, deliveryType, delivered, 1097 orderByComparator); 1098 } 1099 1100 /** 1101 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1102 * 1103 * @param userId the user ID 1104 * @param deliveryType the delivery type 1105 * @param delivered the delivered 1106 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1107 * @return the last matching user notification event 1108 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1109 */ 1110 public static UserNotificationEvent findByU_DT_D_Last(long userId, 1111 int deliveryType, boolean delivered, 1112 OrderByComparator<UserNotificationEvent> orderByComparator) 1113 throws com.liferay.portal.NoSuchUserNotificationEventException { 1114 return getPersistence() 1115 .findByU_DT_D_Last(userId, deliveryType, delivered, 1116 orderByComparator); 1117 } 1118 1119 /** 1120 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1121 * 1122 * @param userId the user ID 1123 * @param deliveryType the delivery type 1124 * @param delivered the delivered 1125 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1126 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1127 */ 1128 public static UserNotificationEvent fetchByU_DT_D_Last(long userId, 1129 int deliveryType, boolean delivered, 1130 OrderByComparator<UserNotificationEvent> orderByComparator) { 1131 return getPersistence() 1132 .fetchByU_DT_D_Last(userId, deliveryType, delivered, 1133 orderByComparator); 1134 } 1135 1136 /** 1137 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ?. 1138 * 1139 * @param userNotificationEventId the primary key of the current user notification event 1140 * @param userId the user ID 1141 * @param deliveryType the delivery type 1142 * @param delivered the delivered 1143 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1144 * @return the previous, current, and next user notification event 1145 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1146 */ 1147 public static UserNotificationEvent[] findByU_DT_D_PrevAndNext( 1148 long userNotificationEventId, long userId, int deliveryType, 1149 boolean delivered, 1150 OrderByComparator<UserNotificationEvent> orderByComparator) 1151 throws com.liferay.portal.NoSuchUserNotificationEventException { 1152 return getPersistence() 1153 .findByU_DT_D_PrevAndNext(userNotificationEventId, userId, 1154 deliveryType, delivered, orderByComparator); 1155 } 1156 1157 /** 1158 * Removes all the user notification events where userId = ? and deliveryType = ? and delivered = ? from the database. 1159 * 1160 * @param userId the user ID 1161 * @param deliveryType the delivery type 1162 * @param delivered the delivered 1163 */ 1164 public static void removeByU_DT_D(long userId, int deliveryType, 1165 boolean delivered) { 1166 getPersistence().removeByU_DT_D(userId, deliveryType, delivered); 1167 } 1168 1169 /** 1170 * Returns the number of user notification events where userId = ? and deliveryType = ? and delivered = ?. 1171 * 1172 * @param userId the user ID 1173 * @param deliveryType the delivery type 1174 * @param delivered the delivered 1175 * @return the number of matching user notification events 1176 */ 1177 public static int countByU_DT_D(long userId, int deliveryType, 1178 boolean delivered) { 1179 return getPersistence().countByU_DT_D(userId, deliveryType, delivered); 1180 } 1181 1182 /** 1183 * Returns all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1184 * 1185 * @param userId the user ID 1186 * @param deliveryType the delivery type 1187 * @param archived the archived 1188 * @return the matching user notification events 1189 */ 1190 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1191 int deliveryType, boolean archived) { 1192 return getPersistence().findByU_DT_A(userId, deliveryType, archived); 1193 } 1194 1195 /** 1196 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1197 * 1198 * <p> 1199 * 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. 1200 * </p> 1201 * 1202 * @param userId the user ID 1203 * @param deliveryType the delivery type 1204 * @param archived the archived 1205 * @param start the lower bound of the range of user notification events 1206 * @param end the upper bound of the range of user notification events (not inclusive) 1207 * @return the range of matching user notification events 1208 */ 1209 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1210 int deliveryType, boolean archived, int start, int end) { 1211 return getPersistence() 1212 .findByU_DT_A(userId, deliveryType, archived, start, end); 1213 } 1214 1215 /** 1216 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and archived = ?. 1217 * 1218 * <p> 1219 * 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. 1220 * </p> 1221 * 1222 * @param userId the user ID 1223 * @param deliveryType the delivery type 1224 * @param archived the archived 1225 * @param start the lower bound of the range of user notification events 1226 * @param end the upper bound of the range of user notification events (not inclusive) 1227 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1228 * @return the ordered range of matching user notification events 1229 */ 1230 public static List<UserNotificationEvent> findByU_DT_A(long userId, 1231 int deliveryType, boolean archived, int start, int end, 1232 OrderByComparator<UserNotificationEvent> orderByComparator) { 1233 return getPersistence() 1234 .findByU_DT_A(userId, deliveryType, archived, start, end, 1235 orderByComparator); 1236 } 1237 1238 /** 1239 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1240 * 1241 * @param userId the user ID 1242 * @param deliveryType the delivery type 1243 * @param archived the archived 1244 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1245 * @return the first matching user notification event 1246 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1247 */ 1248 public static UserNotificationEvent findByU_DT_A_First(long userId, 1249 int deliveryType, boolean archived, 1250 OrderByComparator<UserNotificationEvent> orderByComparator) 1251 throws com.liferay.portal.NoSuchUserNotificationEventException { 1252 return getPersistence() 1253 .findByU_DT_A_First(userId, deliveryType, archived, 1254 orderByComparator); 1255 } 1256 1257 /** 1258 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1259 * 1260 * @param userId the user ID 1261 * @param deliveryType the delivery type 1262 * @param archived the archived 1263 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1264 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1265 */ 1266 public static UserNotificationEvent fetchByU_DT_A_First(long userId, 1267 int deliveryType, boolean archived, 1268 OrderByComparator<UserNotificationEvent> orderByComparator) { 1269 return getPersistence() 1270 .fetchByU_DT_A_First(userId, deliveryType, archived, 1271 orderByComparator); 1272 } 1273 1274 /** 1275 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1276 * 1277 * @param userId the user ID 1278 * @param deliveryType the delivery type 1279 * @param archived the archived 1280 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1281 * @return the last matching user notification event 1282 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1283 */ 1284 public static UserNotificationEvent findByU_DT_A_Last(long userId, 1285 int deliveryType, boolean archived, 1286 OrderByComparator<UserNotificationEvent> orderByComparator) 1287 throws com.liferay.portal.NoSuchUserNotificationEventException { 1288 return getPersistence() 1289 .findByU_DT_A_Last(userId, deliveryType, archived, 1290 orderByComparator); 1291 } 1292 1293 /** 1294 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1295 * 1296 * @param userId the user ID 1297 * @param deliveryType the delivery type 1298 * @param archived the archived 1299 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1300 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1301 */ 1302 public static UserNotificationEvent fetchByU_DT_A_Last(long userId, 1303 int deliveryType, boolean archived, 1304 OrderByComparator<UserNotificationEvent> orderByComparator) { 1305 return getPersistence() 1306 .fetchByU_DT_A_Last(userId, deliveryType, archived, 1307 orderByComparator); 1308 } 1309 1310 /** 1311 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and deliveryType = ? and archived = ?. 1312 * 1313 * @param userNotificationEventId the primary key of the current user notification event 1314 * @param userId the user ID 1315 * @param deliveryType the delivery type 1316 * @param archived the archived 1317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1318 * @return the previous, current, and next user notification event 1319 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1320 */ 1321 public static UserNotificationEvent[] findByU_DT_A_PrevAndNext( 1322 long userNotificationEventId, long userId, int deliveryType, 1323 boolean archived, 1324 OrderByComparator<UserNotificationEvent> orderByComparator) 1325 throws com.liferay.portal.NoSuchUserNotificationEventException { 1326 return getPersistence() 1327 .findByU_DT_A_PrevAndNext(userNotificationEventId, userId, 1328 deliveryType, archived, orderByComparator); 1329 } 1330 1331 /** 1332 * Removes all the user notification events where userId = ? and deliveryType = ? and archived = ? from the database. 1333 * 1334 * @param userId the user ID 1335 * @param deliveryType the delivery type 1336 * @param archived the archived 1337 */ 1338 public static void removeByU_DT_A(long userId, int deliveryType, 1339 boolean archived) { 1340 getPersistence().removeByU_DT_A(userId, deliveryType, archived); 1341 } 1342 1343 /** 1344 * Returns the number of user notification events where userId = ? and deliveryType = ? and archived = ?. 1345 * 1346 * @param userId the user ID 1347 * @param deliveryType the delivery type 1348 * @param archived the archived 1349 * @return the number of matching user notification events 1350 */ 1351 public static int countByU_DT_A(long userId, int deliveryType, 1352 boolean archived) { 1353 return getPersistence().countByU_DT_A(userId, deliveryType, archived); 1354 } 1355 1356 /** 1357 * Returns all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1358 * 1359 * @param userId the user ID 1360 * @param delivered the delivered 1361 * @param actionRequired the action required 1362 * @return the matching user notification events 1363 */ 1364 public static List<UserNotificationEvent> findByU_D_A(long userId, 1365 boolean delivered, boolean actionRequired) { 1366 return getPersistence().findByU_D_A(userId, delivered, actionRequired); 1367 } 1368 1369 /** 1370 * Returns a range of all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1371 * 1372 * <p> 1373 * 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. 1374 * </p> 1375 * 1376 * @param userId the user ID 1377 * @param delivered the delivered 1378 * @param actionRequired the action required 1379 * @param start the lower bound of the range of user notification events 1380 * @param end the upper bound of the range of user notification events (not inclusive) 1381 * @return the range of matching user notification events 1382 */ 1383 public static List<UserNotificationEvent> findByU_D_A(long userId, 1384 boolean delivered, boolean actionRequired, int start, int end) { 1385 return getPersistence() 1386 .findByU_D_A(userId, delivered, actionRequired, start, end); 1387 } 1388 1389 /** 1390 * Returns an ordered range of all the user notification events where userId = ? and delivered = ? and actionRequired = ?. 1391 * 1392 * <p> 1393 * 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. 1394 * </p> 1395 * 1396 * @param userId the user ID 1397 * @param delivered the delivered 1398 * @param actionRequired the action required 1399 * @param start the lower bound of the range of user notification events 1400 * @param end the upper bound of the range of user notification events (not inclusive) 1401 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1402 * @return the ordered range of matching user notification events 1403 */ 1404 public static List<UserNotificationEvent> findByU_D_A(long userId, 1405 boolean delivered, boolean actionRequired, int start, int end, 1406 OrderByComparator<UserNotificationEvent> orderByComparator) { 1407 return getPersistence() 1408 .findByU_D_A(userId, delivered, actionRequired, start, end, 1409 orderByComparator); 1410 } 1411 1412 /** 1413 * Returns the first user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1414 * 1415 * @param userId the user ID 1416 * @param delivered the delivered 1417 * @param actionRequired the action required 1418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1419 * @return the first matching user notification event 1420 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1421 */ 1422 public static UserNotificationEvent findByU_D_A_First(long userId, 1423 boolean delivered, boolean actionRequired, 1424 OrderByComparator<UserNotificationEvent> orderByComparator) 1425 throws com.liferay.portal.NoSuchUserNotificationEventException { 1426 return getPersistence() 1427 .findByU_D_A_First(userId, delivered, actionRequired, 1428 orderByComparator); 1429 } 1430 1431 /** 1432 * Returns the first user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1433 * 1434 * @param userId the user ID 1435 * @param delivered the delivered 1436 * @param actionRequired the action required 1437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1438 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1439 */ 1440 public static UserNotificationEvent fetchByU_D_A_First(long userId, 1441 boolean delivered, boolean actionRequired, 1442 OrderByComparator<UserNotificationEvent> orderByComparator) { 1443 return getPersistence() 1444 .fetchByU_D_A_First(userId, delivered, actionRequired, 1445 orderByComparator); 1446 } 1447 1448 /** 1449 * Returns the last user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1450 * 1451 * @param userId the user ID 1452 * @param delivered the delivered 1453 * @param actionRequired the action required 1454 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1455 * @return the last matching user notification event 1456 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1457 */ 1458 public static UserNotificationEvent findByU_D_A_Last(long userId, 1459 boolean delivered, boolean actionRequired, 1460 OrderByComparator<UserNotificationEvent> orderByComparator) 1461 throws com.liferay.portal.NoSuchUserNotificationEventException { 1462 return getPersistence() 1463 .findByU_D_A_Last(userId, delivered, actionRequired, 1464 orderByComparator); 1465 } 1466 1467 /** 1468 * Returns the last user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1469 * 1470 * @param userId the user ID 1471 * @param delivered the delivered 1472 * @param actionRequired the action required 1473 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1474 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1475 */ 1476 public static UserNotificationEvent fetchByU_D_A_Last(long userId, 1477 boolean delivered, boolean actionRequired, 1478 OrderByComparator<UserNotificationEvent> orderByComparator) { 1479 return getPersistence() 1480 .fetchByU_D_A_Last(userId, delivered, actionRequired, 1481 orderByComparator); 1482 } 1483 1484 /** 1485 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and delivered = ? and actionRequired = ?. 1486 * 1487 * @param userNotificationEventId the primary key of the current user notification event 1488 * @param userId the user ID 1489 * @param delivered the delivered 1490 * @param actionRequired the action required 1491 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1492 * @return the previous, current, and next user notification event 1493 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1494 */ 1495 public static UserNotificationEvent[] findByU_D_A_PrevAndNext( 1496 long userNotificationEventId, long userId, boolean delivered, 1497 boolean actionRequired, 1498 OrderByComparator<UserNotificationEvent> orderByComparator) 1499 throws com.liferay.portal.NoSuchUserNotificationEventException { 1500 return getPersistence() 1501 .findByU_D_A_PrevAndNext(userNotificationEventId, userId, 1502 delivered, actionRequired, orderByComparator); 1503 } 1504 1505 /** 1506 * Removes all the user notification events where userId = ? and delivered = ? and actionRequired = ? from the database. 1507 * 1508 * @param userId the user ID 1509 * @param delivered the delivered 1510 * @param actionRequired the action required 1511 */ 1512 public static void removeByU_D_A(long userId, boolean delivered, 1513 boolean actionRequired) { 1514 getPersistence().removeByU_D_A(userId, delivered, actionRequired); 1515 } 1516 1517 /** 1518 * Returns the number of user notification events where userId = ? and delivered = ? and actionRequired = ?. 1519 * 1520 * @param userId the user ID 1521 * @param delivered the delivered 1522 * @param actionRequired the action required 1523 * @return the number of matching user notification events 1524 */ 1525 public static int countByU_D_A(long userId, boolean delivered, 1526 boolean actionRequired) { 1527 return getPersistence().countByU_D_A(userId, delivered, actionRequired); 1528 } 1529 1530 /** 1531 * Returns all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1532 * 1533 * @param userId the user ID 1534 * @param actionRequired the action required 1535 * @param archived the archived 1536 * @return the matching user notification events 1537 */ 1538 public static List<UserNotificationEvent> findByU_A_A(long userId, 1539 boolean actionRequired, boolean archived) { 1540 return getPersistence().findByU_A_A(userId, actionRequired, archived); 1541 } 1542 1543 /** 1544 * Returns a range of all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1545 * 1546 * <p> 1547 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link UserNotificationEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1548 * </p> 1549 * 1550 * @param userId the user ID 1551 * @param actionRequired the action required 1552 * @param archived the archived 1553 * @param start the lower bound of the range of user notification events 1554 * @param end the upper bound of the range of user notification events (not inclusive) 1555 * @return the range of matching user notification events 1556 */ 1557 public static List<UserNotificationEvent> findByU_A_A(long userId, 1558 boolean actionRequired, boolean archived, int start, int end) { 1559 return getPersistence() 1560 .findByU_A_A(userId, actionRequired, archived, start, end); 1561 } 1562 1563 /** 1564 * Returns an ordered range of all the user notification events where userId = ? and actionRequired = ? and archived = ?. 1565 * 1566 * <p> 1567 * 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. 1568 * </p> 1569 * 1570 * @param userId the user ID 1571 * @param actionRequired the action required 1572 * @param archived the archived 1573 * @param start the lower bound of the range of user notification events 1574 * @param end the upper bound of the range of user notification events (not inclusive) 1575 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1576 * @return the ordered range of matching user notification events 1577 */ 1578 public static List<UserNotificationEvent> findByU_A_A(long userId, 1579 boolean actionRequired, boolean archived, int start, int end, 1580 OrderByComparator<UserNotificationEvent> orderByComparator) { 1581 return getPersistence() 1582 .findByU_A_A(userId, actionRequired, archived, start, end, 1583 orderByComparator); 1584 } 1585 1586 /** 1587 * Returns the first user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1588 * 1589 * @param userId the user ID 1590 * @param actionRequired the action required 1591 * @param archived the archived 1592 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1593 * @return the first matching user notification event 1594 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1595 */ 1596 public static UserNotificationEvent findByU_A_A_First(long userId, 1597 boolean actionRequired, boolean archived, 1598 OrderByComparator<UserNotificationEvent> orderByComparator) 1599 throws com.liferay.portal.NoSuchUserNotificationEventException { 1600 return getPersistence() 1601 .findByU_A_A_First(userId, actionRequired, archived, 1602 orderByComparator); 1603 } 1604 1605 /** 1606 * Returns the first user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1607 * 1608 * @param userId the user ID 1609 * @param actionRequired the action required 1610 * @param archived the archived 1611 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1612 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1613 */ 1614 public static UserNotificationEvent fetchByU_A_A_First(long userId, 1615 boolean actionRequired, boolean archived, 1616 OrderByComparator<UserNotificationEvent> orderByComparator) { 1617 return getPersistence() 1618 .fetchByU_A_A_First(userId, actionRequired, archived, 1619 orderByComparator); 1620 } 1621 1622 /** 1623 * Returns the last user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1624 * 1625 * @param userId the user ID 1626 * @param actionRequired the action required 1627 * @param archived the archived 1628 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1629 * @return the last matching user notification event 1630 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1631 */ 1632 public static UserNotificationEvent findByU_A_A_Last(long userId, 1633 boolean actionRequired, boolean archived, 1634 OrderByComparator<UserNotificationEvent> orderByComparator) 1635 throws com.liferay.portal.NoSuchUserNotificationEventException { 1636 return getPersistence() 1637 .findByU_A_A_Last(userId, actionRequired, archived, 1638 orderByComparator); 1639 } 1640 1641 /** 1642 * Returns the last user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1643 * 1644 * @param userId the user ID 1645 * @param actionRequired the action required 1646 * @param archived the archived 1647 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1648 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1649 */ 1650 public static UserNotificationEvent fetchByU_A_A_Last(long userId, 1651 boolean actionRequired, boolean archived, 1652 OrderByComparator<UserNotificationEvent> orderByComparator) { 1653 return getPersistence() 1654 .fetchByU_A_A_Last(userId, actionRequired, archived, 1655 orderByComparator); 1656 } 1657 1658 /** 1659 * Returns the user notification events before and after the current user notification event in the ordered set where userId = ? and actionRequired = ? and archived = ?. 1660 * 1661 * @param userNotificationEventId the primary key of the current user notification event 1662 * @param userId the user ID 1663 * @param actionRequired the action required 1664 * @param archived the archived 1665 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1666 * @return the previous, current, and next user notification event 1667 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1668 */ 1669 public static UserNotificationEvent[] findByU_A_A_PrevAndNext( 1670 long userNotificationEventId, long userId, boolean actionRequired, 1671 boolean archived, 1672 OrderByComparator<UserNotificationEvent> orderByComparator) 1673 throws com.liferay.portal.NoSuchUserNotificationEventException { 1674 return getPersistence() 1675 .findByU_A_A_PrevAndNext(userNotificationEventId, userId, 1676 actionRequired, archived, orderByComparator); 1677 } 1678 1679 /** 1680 * Removes all the user notification events where userId = ? and actionRequired = ? and archived = ? from the database. 1681 * 1682 * @param userId the user ID 1683 * @param actionRequired the action required 1684 * @param archived the archived 1685 */ 1686 public static void removeByU_A_A(long userId, boolean actionRequired, 1687 boolean archived) { 1688 getPersistence().removeByU_A_A(userId, actionRequired, archived); 1689 } 1690 1691 /** 1692 * Returns the number of user notification events where userId = ? and actionRequired = ? and archived = ?. 1693 * 1694 * @param userId the user ID 1695 * @param actionRequired the action required 1696 * @param archived the archived 1697 * @return the number of matching user notification events 1698 */ 1699 public static int countByU_A_A(long userId, boolean actionRequired, 1700 boolean archived) { 1701 return getPersistence().countByU_A_A(userId, actionRequired, archived); 1702 } 1703 1704 /** 1705 * Returns all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1706 * 1707 * @param userId the user ID 1708 * @param deliveryType the delivery type 1709 * @param delivered the delivered 1710 * @param actionRequired the action required 1711 * @return the matching user notification events 1712 */ 1713 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 1714 int deliveryType, boolean delivered, boolean actionRequired) { 1715 return getPersistence() 1716 .findByU_DT_D_A(userId, deliveryType, delivered, 1717 actionRequired); 1718 } 1719 1720 /** 1721 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1722 * 1723 * <p> 1724 * 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. 1725 * </p> 1726 * 1727 * @param userId the user ID 1728 * @param deliveryType the delivery type 1729 * @param delivered the delivered 1730 * @param actionRequired the action required 1731 * @param start the lower bound of the range of user notification events 1732 * @param end the upper bound of the range of user notification events (not inclusive) 1733 * @return the range of matching user notification events 1734 */ 1735 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 1736 int deliveryType, boolean delivered, boolean actionRequired, int start, 1737 int end) { 1738 return getPersistence() 1739 .findByU_DT_D_A(userId, deliveryType, delivered, 1740 actionRequired, start, end); 1741 } 1742 1743 /** 1744 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1745 * 1746 * <p> 1747 * 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. 1748 * </p> 1749 * 1750 * @param userId the user ID 1751 * @param deliveryType the delivery type 1752 * @param delivered the delivered 1753 * @param actionRequired the action required 1754 * @param start the lower bound of the range of user notification events 1755 * @param end the upper bound of the range of user notification events (not inclusive) 1756 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1757 * @return the ordered range of matching user notification events 1758 */ 1759 public static List<UserNotificationEvent> findByU_DT_D_A(long userId, 1760 int deliveryType, boolean delivered, boolean actionRequired, int start, 1761 int end, OrderByComparator<UserNotificationEvent> orderByComparator) { 1762 return getPersistence() 1763 .findByU_DT_D_A(userId, deliveryType, delivered, 1764 actionRequired, start, end, orderByComparator); 1765 } 1766 1767 /** 1768 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1769 * 1770 * @param userId the user ID 1771 * @param deliveryType the delivery type 1772 * @param delivered the delivered 1773 * @param actionRequired the action required 1774 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1775 * @return the first matching user notification event 1776 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1777 */ 1778 public static UserNotificationEvent findByU_DT_D_A_First(long userId, 1779 int deliveryType, boolean delivered, boolean actionRequired, 1780 OrderByComparator<UserNotificationEvent> orderByComparator) 1781 throws com.liferay.portal.NoSuchUserNotificationEventException { 1782 return getPersistence() 1783 .findByU_DT_D_A_First(userId, deliveryType, delivered, 1784 actionRequired, orderByComparator); 1785 } 1786 1787 /** 1788 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1789 * 1790 * @param userId the user ID 1791 * @param deliveryType the delivery type 1792 * @param delivered the delivered 1793 * @param actionRequired the action required 1794 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1795 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1796 */ 1797 public static UserNotificationEvent fetchByU_DT_D_A_First(long userId, 1798 int deliveryType, boolean delivered, boolean actionRequired, 1799 OrderByComparator<UserNotificationEvent> orderByComparator) { 1800 return getPersistence() 1801 .fetchByU_DT_D_A_First(userId, deliveryType, delivered, 1802 actionRequired, orderByComparator); 1803 } 1804 1805 /** 1806 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1807 * 1808 * @param userId the user ID 1809 * @param deliveryType the delivery type 1810 * @param delivered the delivered 1811 * @param actionRequired the action required 1812 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1813 * @return the last matching user notification event 1814 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1815 */ 1816 public static UserNotificationEvent findByU_DT_D_A_Last(long userId, 1817 int deliveryType, boolean delivered, boolean actionRequired, 1818 OrderByComparator<UserNotificationEvent> orderByComparator) 1819 throws com.liferay.portal.NoSuchUserNotificationEventException { 1820 return getPersistence() 1821 .findByU_DT_D_A_Last(userId, deliveryType, delivered, 1822 actionRequired, orderByComparator); 1823 } 1824 1825 /** 1826 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1827 * 1828 * @param userId the user ID 1829 * @param deliveryType the delivery type 1830 * @param delivered the delivered 1831 * @param actionRequired the action required 1832 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1833 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 1834 */ 1835 public static UserNotificationEvent fetchByU_DT_D_A_Last(long userId, 1836 int deliveryType, boolean delivered, boolean actionRequired, 1837 OrderByComparator<UserNotificationEvent> orderByComparator) { 1838 return getPersistence() 1839 .fetchByU_DT_D_A_Last(userId, deliveryType, delivered, 1840 actionRequired, orderByComparator); 1841 } 1842 1843 /** 1844 * 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 = ?. 1845 * 1846 * @param userNotificationEventId the primary key of the current user notification event 1847 * @param userId the user ID 1848 * @param deliveryType the delivery type 1849 * @param delivered the delivered 1850 * @param actionRequired the action required 1851 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1852 * @return the previous, current, and next user notification event 1853 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 1854 */ 1855 public static UserNotificationEvent[] findByU_DT_D_A_PrevAndNext( 1856 long userNotificationEventId, long userId, int deliveryType, 1857 boolean delivered, boolean actionRequired, 1858 OrderByComparator<UserNotificationEvent> orderByComparator) 1859 throws com.liferay.portal.NoSuchUserNotificationEventException { 1860 return getPersistence() 1861 .findByU_DT_D_A_PrevAndNext(userNotificationEventId, userId, 1862 deliveryType, delivered, actionRequired, orderByComparator); 1863 } 1864 1865 /** 1866 * Removes all the user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ? from the database. 1867 * 1868 * @param userId the user ID 1869 * @param deliveryType the delivery type 1870 * @param delivered the delivered 1871 * @param actionRequired the action required 1872 */ 1873 public static void removeByU_DT_D_A(long userId, int deliveryType, 1874 boolean delivered, boolean actionRequired) { 1875 getPersistence() 1876 .removeByU_DT_D_A(userId, deliveryType, delivered, actionRequired); 1877 } 1878 1879 /** 1880 * Returns the number of user notification events where userId = ? and deliveryType = ? and delivered = ? and actionRequired = ?. 1881 * 1882 * @param userId the user ID 1883 * @param deliveryType the delivery type 1884 * @param delivered the delivered 1885 * @param actionRequired the action required 1886 * @return the number of matching user notification events 1887 */ 1888 public static int countByU_DT_D_A(long userId, int deliveryType, 1889 boolean delivered, boolean actionRequired) { 1890 return getPersistence() 1891 .countByU_DT_D_A(userId, deliveryType, delivered, 1892 actionRequired); 1893 } 1894 1895 /** 1896 * Returns all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 1897 * 1898 * @param userId the user ID 1899 * @param deliveryType the delivery type 1900 * @param actionRequired the action required 1901 * @param archived the archived 1902 * @return the matching user notification events 1903 */ 1904 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 1905 int deliveryType, boolean actionRequired, boolean archived) { 1906 return getPersistence() 1907 .findByU_DT_A_A(userId, deliveryType, actionRequired, 1908 archived); 1909 } 1910 1911 /** 1912 * Returns a range of all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 1913 * 1914 * <p> 1915 * 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. 1916 * </p> 1917 * 1918 * @param userId the user ID 1919 * @param deliveryType the delivery type 1920 * @param actionRequired the action required 1921 * @param archived the archived 1922 * @param start the lower bound of the range of user notification events 1923 * @param end the upper bound of the range of user notification events (not inclusive) 1924 * @return the range of matching user notification events 1925 */ 1926 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 1927 int deliveryType, boolean actionRequired, boolean archived, int start, 1928 int end) { 1929 return getPersistence() 1930 .findByU_DT_A_A(userId, deliveryType, actionRequired, 1931 archived, start, end); 1932 } 1933 1934 /** 1935 * Returns an ordered range of all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 1936 * 1937 * <p> 1938 * 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. 1939 * </p> 1940 * 1941 * @param userId the user ID 1942 * @param deliveryType the delivery type 1943 * @param actionRequired the action required 1944 * @param archived the archived 1945 * @param start the lower bound of the range of user notification events 1946 * @param end the upper bound of the range of user notification events (not inclusive) 1947 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1948 * @return the ordered range of matching user notification events 1949 */ 1950 public static List<UserNotificationEvent> findByU_DT_A_A(long userId, 1951 int deliveryType, boolean actionRequired, boolean archived, int start, 1952 int end, OrderByComparator<UserNotificationEvent> orderByComparator) { 1953 return getPersistence() 1954 .findByU_DT_A_A(userId, deliveryType, actionRequired, 1955 archived, start, end, orderByComparator); 1956 } 1957 1958 /** 1959 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 1960 * 1961 * @param userId the user ID 1962 * @param deliveryType the delivery type 1963 * @param actionRequired the action required 1964 * @param archived the archived 1965 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1966 * @return the first matching user notification event 1967 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 1968 */ 1969 public static UserNotificationEvent findByU_DT_A_A_First(long userId, 1970 int deliveryType, boolean actionRequired, boolean archived, 1971 OrderByComparator<UserNotificationEvent> orderByComparator) 1972 throws com.liferay.portal.NoSuchUserNotificationEventException { 1973 return getPersistence() 1974 .findByU_DT_A_A_First(userId, deliveryType, actionRequired, 1975 archived, orderByComparator); 1976 } 1977 1978 /** 1979 * Returns the first user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 1980 * 1981 * @param userId the user ID 1982 * @param deliveryType the delivery type 1983 * @param actionRequired the action required 1984 * @param archived the archived 1985 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1986 * @return the first matching user notification event, or <code>null</code> if a matching user notification event could not be found 1987 */ 1988 public static UserNotificationEvent fetchByU_DT_A_A_First(long userId, 1989 int deliveryType, boolean actionRequired, boolean archived, 1990 OrderByComparator<UserNotificationEvent> orderByComparator) { 1991 return getPersistence() 1992 .fetchByU_DT_A_A_First(userId, deliveryType, actionRequired, 1993 archived, orderByComparator); 1994 } 1995 1996 /** 1997 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 1998 * 1999 * @param userId the user ID 2000 * @param deliveryType the delivery type 2001 * @param actionRequired the action required 2002 * @param archived the archived 2003 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2004 * @return the last matching user notification event 2005 * @throws NoSuchUserNotificationEventException if a matching user notification event could not be found 2006 */ 2007 public static UserNotificationEvent findByU_DT_A_A_Last(long userId, 2008 int deliveryType, boolean actionRequired, boolean archived, 2009 OrderByComparator<UserNotificationEvent> orderByComparator) 2010 throws com.liferay.portal.NoSuchUserNotificationEventException { 2011 return getPersistence() 2012 .findByU_DT_A_A_Last(userId, deliveryType, actionRequired, 2013 archived, orderByComparator); 2014 } 2015 2016 /** 2017 * Returns the last user notification event in the ordered set where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2018 * 2019 * @param userId the user ID 2020 * @param deliveryType the delivery type 2021 * @param actionRequired the action required 2022 * @param archived the archived 2023 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2024 * @return the last matching user notification event, or <code>null</code> if a matching user notification event could not be found 2025 */ 2026 public static UserNotificationEvent fetchByU_DT_A_A_Last(long userId, 2027 int deliveryType, boolean actionRequired, boolean archived, 2028 OrderByComparator<UserNotificationEvent> orderByComparator) { 2029 return getPersistence() 2030 .fetchByU_DT_A_A_Last(userId, deliveryType, actionRequired, 2031 archived, orderByComparator); 2032 } 2033 2034 /** 2035 * 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 = ?. 2036 * 2037 * @param userNotificationEventId the primary key of the current user notification event 2038 * @param userId the user ID 2039 * @param deliveryType the delivery type 2040 * @param actionRequired the action required 2041 * @param archived the archived 2042 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2043 * @return the previous, current, and next user notification event 2044 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2045 */ 2046 public static UserNotificationEvent[] findByU_DT_A_A_PrevAndNext( 2047 long userNotificationEventId, long userId, int deliveryType, 2048 boolean actionRequired, boolean archived, 2049 OrderByComparator<UserNotificationEvent> orderByComparator) 2050 throws com.liferay.portal.NoSuchUserNotificationEventException { 2051 return getPersistence() 2052 .findByU_DT_A_A_PrevAndNext(userNotificationEventId, userId, 2053 deliveryType, actionRequired, archived, orderByComparator); 2054 } 2055 2056 /** 2057 * Removes all the user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ? from the database. 2058 * 2059 * @param userId the user ID 2060 * @param deliveryType the delivery type 2061 * @param actionRequired the action required 2062 * @param archived the archived 2063 */ 2064 public static void removeByU_DT_A_A(long userId, int deliveryType, 2065 boolean actionRequired, boolean archived) { 2066 getPersistence() 2067 .removeByU_DT_A_A(userId, deliveryType, actionRequired, archived); 2068 } 2069 2070 /** 2071 * Returns the number of user notification events where userId = ? and deliveryType = ? and actionRequired = ? and archived = ?. 2072 * 2073 * @param userId the user ID 2074 * @param deliveryType the delivery type 2075 * @param actionRequired the action required 2076 * @param archived the archived 2077 * @return the number of matching user notification events 2078 */ 2079 public static int countByU_DT_A_A(long userId, int deliveryType, 2080 boolean actionRequired, boolean archived) { 2081 return getPersistence() 2082 .countByU_DT_A_A(userId, deliveryType, actionRequired, 2083 archived); 2084 } 2085 2086 /** 2087 * Caches the user notification event in the entity cache if it is enabled. 2088 * 2089 * @param userNotificationEvent the user notification event 2090 */ 2091 public static void cacheResult(UserNotificationEvent userNotificationEvent) { 2092 getPersistence().cacheResult(userNotificationEvent); 2093 } 2094 2095 /** 2096 * Caches the user notification events in the entity cache if it is enabled. 2097 * 2098 * @param userNotificationEvents the user notification events 2099 */ 2100 public static void cacheResult( 2101 List<UserNotificationEvent> userNotificationEvents) { 2102 getPersistence().cacheResult(userNotificationEvents); 2103 } 2104 2105 /** 2106 * Creates a new user notification event with the primary key. Does not add the user notification event to the database. 2107 * 2108 * @param userNotificationEventId the primary key for the new user notification event 2109 * @return the new user notification event 2110 */ 2111 public static UserNotificationEvent create(long userNotificationEventId) { 2112 return getPersistence().create(userNotificationEventId); 2113 } 2114 2115 /** 2116 * Removes the user notification event with the primary key from the database. Also notifies the appropriate model listeners. 2117 * 2118 * @param userNotificationEventId the primary key of the user notification event 2119 * @return the user notification event that was removed 2120 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2121 */ 2122 public static UserNotificationEvent remove(long userNotificationEventId) 2123 throws com.liferay.portal.NoSuchUserNotificationEventException { 2124 return getPersistence().remove(userNotificationEventId); 2125 } 2126 2127 public static UserNotificationEvent updateImpl( 2128 UserNotificationEvent userNotificationEvent) { 2129 return getPersistence().updateImpl(userNotificationEvent); 2130 } 2131 2132 /** 2133 * Returns the user notification event with the primary key or throws a {@link NoSuchUserNotificationEventException} if it could not be found. 2134 * 2135 * @param userNotificationEventId the primary key of the user notification event 2136 * @return the user notification event 2137 * @throws NoSuchUserNotificationEventException if a user notification event with the primary key could not be found 2138 */ 2139 public static UserNotificationEvent findByPrimaryKey( 2140 long userNotificationEventId) 2141 throws com.liferay.portal.NoSuchUserNotificationEventException { 2142 return getPersistence().findByPrimaryKey(userNotificationEventId); 2143 } 2144 2145 /** 2146 * Returns the user notification event with the primary key or returns <code>null</code> if it could not be found. 2147 * 2148 * @param userNotificationEventId the primary key of the user notification event 2149 * @return the user notification event, or <code>null</code> if a user notification event with the primary key could not be found 2150 */ 2151 public static UserNotificationEvent fetchByPrimaryKey( 2152 long userNotificationEventId) { 2153 return getPersistence().fetchByPrimaryKey(userNotificationEventId); 2154 } 2155 2156 public static java.util.Map<java.io.Serializable, UserNotificationEvent> fetchByPrimaryKeys( 2157 java.util.Set<java.io.Serializable> primaryKeys) { 2158 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2159 } 2160 2161 /** 2162 * Returns all the user notification events. 2163 * 2164 * @return the user notification events 2165 */ 2166 public static List<UserNotificationEvent> findAll() { 2167 return getPersistence().findAll(); 2168 } 2169 2170 /** 2171 * Returns a range of all the user notification events. 2172 * 2173 * <p> 2174 * 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. 2175 * </p> 2176 * 2177 * @param start the lower bound of the range of user notification events 2178 * @param end the upper bound of the range of user notification events (not inclusive) 2179 * @return the range of user notification events 2180 */ 2181 public static List<UserNotificationEvent> findAll(int start, int end) { 2182 return getPersistence().findAll(start, end); 2183 } 2184 2185 /** 2186 * Returns an ordered range of all the user notification events. 2187 * 2188 * <p> 2189 * 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. 2190 * </p> 2191 * 2192 * @param start the lower bound of the range of user notification events 2193 * @param end the upper bound of the range of user notification events (not inclusive) 2194 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2195 * @return the ordered range of user notification events 2196 */ 2197 public static List<UserNotificationEvent> findAll(int start, int end, 2198 OrderByComparator<UserNotificationEvent> orderByComparator) { 2199 return getPersistence().findAll(start, end, orderByComparator); 2200 } 2201 2202 /** 2203 * Removes all the user notification events from the database. 2204 */ 2205 public static void removeAll() { 2206 getPersistence().removeAll(); 2207 } 2208 2209 /** 2210 * Returns the number of user notification events. 2211 * 2212 * @return the number of user notification events 2213 */ 2214 public static int countAll() { 2215 return getPersistence().countAll(); 2216 } 2217 2218 public static UserNotificationEventPersistence getPersistence() { 2219 if (_persistence == null) { 2220 _persistence = (UserNotificationEventPersistence)PortalBeanLocatorUtil.locate(UserNotificationEventPersistence.class.getName()); 2221 2222 ReferenceRegistry.registerReference(UserNotificationEventUtil.class, 2223 "_persistence"); 2224 } 2225 2226 return _persistence; 2227 } 2228 2229 /** 2230 * @deprecated As of 6.2.0 2231 */ 2232 @Deprecated 2233 public void setPersistence(UserNotificationEventPersistence persistence) { 2234 } 2235 2236 private static UserNotificationEventPersistence _persistence; 2237 }