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