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