001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.SystemEvent; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the system event service. This utility wraps {@link com.liferay.portal.service.persistence.impl.SystemEventPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see SystemEventPersistence 037 * @see com.liferay.portal.service.persistence.impl.SystemEventPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class SystemEventUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(SystemEvent systemEvent) { 059 getPersistence().clearCache(systemEvent); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<SystemEvent> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<SystemEvent> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<SystemEvent> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<SystemEvent> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static SystemEvent update(SystemEvent systemEvent) { 100 return getPersistence().update(systemEvent); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static SystemEvent update(SystemEvent systemEvent, 107 ServiceContext serviceContext) { 108 return getPersistence().update(systemEvent, serviceContext); 109 } 110 111 /** 112 * Returns all the system events where groupId = ?. 113 * 114 * @param groupId the group ID 115 * @return the matching system events 116 */ 117 public static List<SystemEvent> findByGroupId(long groupId) { 118 return getPersistence().findByGroupId(groupId); 119 } 120 121 /** 122 * Returns a range of all the system events where groupId = ?. 123 * 124 * <p> 125 * 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 SystemEventModelImpl}. 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. 126 * </p> 127 * 128 * @param groupId the group ID 129 * @param start the lower bound of the range of system events 130 * @param end the upper bound of the range of system events (not inclusive) 131 * @return the range of matching system events 132 */ 133 public static List<SystemEvent> findByGroupId(long groupId, int start, 134 int end) { 135 return getPersistence().findByGroupId(groupId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the system events where groupId = ?. 140 * 141 * <p> 142 * 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 SystemEventModelImpl}. 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. 143 * </p> 144 * 145 * @param groupId the group ID 146 * @param start the lower bound of the range of system events 147 * @param end the upper bound of the range of system events (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching system events 150 */ 151 public static List<SystemEvent> findByGroupId(long groupId, int start, 152 int end, OrderByComparator<SystemEvent> orderByComparator) { 153 return getPersistence() 154 .findByGroupId(groupId, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns the first system event in the ordered set where groupId = ?. 159 * 160 * @param groupId the group ID 161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 162 * @return the first matching system event 163 * @throws NoSuchSystemEventException if a matching system event could not be found 164 */ 165 public static SystemEvent findByGroupId_First(long groupId, 166 OrderByComparator<SystemEvent> orderByComparator) 167 throws com.liferay.portal.NoSuchSystemEventException { 168 return getPersistence().findByGroupId_First(groupId, orderByComparator); 169 } 170 171 /** 172 * Returns the first system event in the ordered set where groupId = ?. 173 * 174 * @param groupId the group ID 175 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 176 * @return the first matching system event, or <code>null</code> if a matching system event could not be found 177 */ 178 public static SystemEvent fetchByGroupId_First(long groupId, 179 OrderByComparator<SystemEvent> orderByComparator) { 180 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 181 } 182 183 /** 184 * Returns the last system event in the ordered set where groupId = ?. 185 * 186 * @param groupId the group ID 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the last matching system event 189 * @throws NoSuchSystemEventException if a matching system event could not be found 190 */ 191 public static SystemEvent findByGroupId_Last(long groupId, 192 OrderByComparator<SystemEvent> orderByComparator) 193 throws com.liferay.portal.NoSuchSystemEventException { 194 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 195 } 196 197 /** 198 * Returns the last system event in the ordered set where groupId = ?. 199 * 200 * @param groupId the group ID 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching system event, or <code>null</code> if a matching system event could not be found 203 */ 204 public static SystemEvent fetchByGroupId_Last(long groupId, 205 OrderByComparator<SystemEvent> orderByComparator) { 206 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 207 } 208 209 /** 210 * Returns the system events before and after the current system event in the ordered set where groupId = ?. 211 * 212 * @param systemEventId the primary key of the current system event 213 * @param groupId the group ID 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the previous, current, and next system event 216 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 217 */ 218 public static SystemEvent[] findByGroupId_PrevAndNext(long systemEventId, 219 long groupId, OrderByComparator<SystemEvent> orderByComparator) 220 throws com.liferay.portal.NoSuchSystemEventException { 221 return getPersistence() 222 .findByGroupId_PrevAndNext(systemEventId, groupId, 223 orderByComparator); 224 } 225 226 /** 227 * Removes all the system events where groupId = ? from the database. 228 * 229 * @param groupId the group ID 230 */ 231 public static void removeByGroupId(long groupId) { 232 getPersistence().removeByGroupId(groupId); 233 } 234 235 /** 236 * Returns the number of system events where groupId = ?. 237 * 238 * @param groupId the group ID 239 * @return the number of matching system events 240 */ 241 public static int countByGroupId(long groupId) { 242 return getPersistence().countByGroupId(groupId); 243 } 244 245 /** 246 * Returns all the system events where groupId = ? and systemEventSetKey = ?. 247 * 248 * @param groupId the group ID 249 * @param systemEventSetKey the system event set key 250 * @return the matching system events 251 */ 252 public static List<SystemEvent> findByG_S(long groupId, 253 long systemEventSetKey) { 254 return getPersistence().findByG_S(groupId, systemEventSetKey); 255 } 256 257 /** 258 * Returns a range of all the system events where groupId = ? and systemEventSetKey = ?. 259 * 260 * <p> 261 * 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 SystemEventModelImpl}. 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. 262 * </p> 263 * 264 * @param groupId the group ID 265 * @param systemEventSetKey the system event set key 266 * @param start the lower bound of the range of system events 267 * @param end the upper bound of the range of system events (not inclusive) 268 * @return the range of matching system events 269 */ 270 public static List<SystemEvent> findByG_S(long groupId, 271 long systemEventSetKey, int start, int end) { 272 return getPersistence().findByG_S(groupId, systemEventSetKey, start, end); 273 } 274 275 /** 276 * Returns an ordered range of all the system events where groupId = ? and systemEventSetKey = ?. 277 * 278 * <p> 279 * 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 SystemEventModelImpl}. 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. 280 * </p> 281 * 282 * @param groupId the group ID 283 * @param systemEventSetKey the system event set key 284 * @param start the lower bound of the range of system events 285 * @param end the upper bound of the range of system events (not inclusive) 286 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 287 * @return the ordered range of matching system events 288 */ 289 public static List<SystemEvent> findByG_S(long groupId, 290 long systemEventSetKey, int start, int end, 291 OrderByComparator<SystemEvent> orderByComparator) { 292 return getPersistence() 293 .findByG_S(groupId, systemEventSetKey, start, end, 294 orderByComparator); 295 } 296 297 /** 298 * Returns the first system event in the ordered set where groupId = ? and systemEventSetKey = ?. 299 * 300 * @param groupId the group ID 301 * @param systemEventSetKey the system event set key 302 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 303 * @return the first matching system event 304 * @throws NoSuchSystemEventException if a matching system event could not be found 305 */ 306 public static SystemEvent findByG_S_First(long groupId, 307 long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) 308 throws com.liferay.portal.NoSuchSystemEventException { 309 return getPersistence() 310 .findByG_S_First(groupId, systemEventSetKey, 311 orderByComparator); 312 } 313 314 /** 315 * Returns the first system event in the ordered set where groupId = ? and systemEventSetKey = ?. 316 * 317 * @param groupId the group ID 318 * @param systemEventSetKey the system event set key 319 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 320 * @return the first matching system event, or <code>null</code> if a matching system event could not be found 321 */ 322 public static SystemEvent fetchByG_S_First(long groupId, 323 long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) { 324 return getPersistence() 325 .fetchByG_S_First(groupId, systemEventSetKey, 326 orderByComparator); 327 } 328 329 /** 330 * Returns the last system event in the ordered set where groupId = ? and systemEventSetKey = ?. 331 * 332 * @param groupId the group ID 333 * @param systemEventSetKey the system event set key 334 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 335 * @return the last matching system event 336 * @throws NoSuchSystemEventException if a matching system event could not be found 337 */ 338 public static SystemEvent findByG_S_Last(long groupId, 339 long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) 340 throws com.liferay.portal.NoSuchSystemEventException { 341 return getPersistence() 342 .findByG_S_Last(groupId, systemEventSetKey, orderByComparator); 343 } 344 345 /** 346 * Returns the last system event in the ordered set where groupId = ? and systemEventSetKey = ?. 347 * 348 * @param groupId the group ID 349 * @param systemEventSetKey the system event set key 350 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 351 * @return the last matching system event, or <code>null</code> if a matching system event could not be found 352 */ 353 public static SystemEvent fetchByG_S_Last(long groupId, 354 long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) { 355 return getPersistence() 356 .fetchByG_S_Last(groupId, systemEventSetKey, 357 orderByComparator); 358 } 359 360 /** 361 * Returns the system events before and after the current system event in the ordered set where groupId = ? and systemEventSetKey = ?. 362 * 363 * @param systemEventId the primary key of the current system event 364 * @param groupId the group ID 365 * @param systemEventSetKey the system event set key 366 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 367 * @return the previous, current, and next system event 368 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 369 */ 370 public static SystemEvent[] findByG_S_PrevAndNext(long systemEventId, 371 long groupId, long systemEventSetKey, 372 OrderByComparator<SystemEvent> orderByComparator) 373 throws com.liferay.portal.NoSuchSystemEventException { 374 return getPersistence() 375 .findByG_S_PrevAndNext(systemEventId, groupId, 376 systemEventSetKey, orderByComparator); 377 } 378 379 /** 380 * Removes all the system events where groupId = ? and systemEventSetKey = ? from the database. 381 * 382 * @param groupId the group ID 383 * @param systemEventSetKey the system event set key 384 */ 385 public static void removeByG_S(long groupId, long systemEventSetKey) { 386 getPersistence().removeByG_S(groupId, systemEventSetKey); 387 } 388 389 /** 390 * Returns the number of system events where groupId = ? and systemEventSetKey = ?. 391 * 392 * @param groupId the group ID 393 * @param systemEventSetKey the system event set key 394 * @return the number of matching system events 395 */ 396 public static int countByG_S(long groupId, long systemEventSetKey) { 397 return getPersistence().countByG_S(groupId, systemEventSetKey); 398 } 399 400 /** 401 * Returns all the system events where groupId = ? and classNameId = ? and classPK = ?. 402 * 403 * @param groupId the group ID 404 * @param classNameId the class name ID 405 * @param classPK the class p k 406 * @return the matching system events 407 */ 408 public static List<SystemEvent> findByG_C_C(long groupId, long classNameId, 409 long classPK) { 410 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 411 } 412 413 /** 414 * Returns a range of all the system events where groupId = ? and classNameId = ? and classPK = ?. 415 * 416 * <p> 417 * 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 SystemEventModelImpl}. 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. 418 * </p> 419 * 420 * @param groupId the group ID 421 * @param classNameId the class name ID 422 * @param classPK the class p k 423 * @param start the lower bound of the range of system events 424 * @param end the upper bound of the range of system events (not inclusive) 425 * @return the range of matching system events 426 */ 427 public static List<SystemEvent> findByG_C_C(long groupId, long classNameId, 428 long classPK, int start, int end) { 429 return getPersistence() 430 .findByG_C_C(groupId, classNameId, classPK, start, end); 431 } 432 433 /** 434 * Returns an ordered range of all the system events where groupId = ? and classNameId = ? and classPK = ?. 435 * 436 * <p> 437 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SystemEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 438 * </p> 439 * 440 * @param groupId the group ID 441 * @param classNameId the class name ID 442 * @param classPK the class p k 443 * @param start the lower bound of the range of system events 444 * @param end the upper bound of the range of system events (not inclusive) 445 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 446 * @return the ordered range of matching system events 447 */ 448 public static List<SystemEvent> findByG_C_C(long groupId, long classNameId, 449 long classPK, int start, int end, 450 OrderByComparator<SystemEvent> orderByComparator) { 451 return getPersistence() 452 .findByG_C_C(groupId, classNameId, classPK, start, end, 453 orderByComparator); 454 } 455 456 /** 457 * Returns the first system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 458 * 459 * @param groupId the group ID 460 * @param classNameId the class name ID 461 * @param classPK the class p k 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 463 * @return the first matching system event 464 * @throws NoSuchSystemEventException if a matching system event could not be found 465 */ 466 public static SystemEvent findByG_C_C_First(long groupId, long classNameId, 467 long classPK, OrderByComparator<SystemEvent> orderByComparator) 468 throws com.liferay.portal.NoSuchSystemEventException { 469 return getPersistence() 470 .findByG_C_C_First(groupId, classNameId, classPK, 471 orderByComparator); 472 } 473 474 /** 475 * Returns the first system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 476 * 477 * @param groupId the group ID 478 * @param classNameId the class name ID 479 * @param classPK the class p k 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the first matching system event, or <code>null</code> if a matching system event could not be found 482 */ 483 public static SystemEvent fetchByG_C_C_First(long groupId, 484 long classNameId, long classPK, 485 OrderByComparator<SystemEvent> orderByComparator) { 486 return getPersistence() 487 .fetchByG_C_C_First(groupId, classNameId, classPK, 488 orderByComparator); 489 } 490 491 /** 492 * Returns the last system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 493 * 494 * @param groupId the group ID 495 * @param classNameId the class name ID 496 * @param classPK the class p k 497 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 498 * @return the last matching system event 499 * @throws NoSuchSystemEventException if a matching system event could not be found 500 */ 501 public static SystemEvent findByG_C_C_Last(long groupId, long classNameId, 502 long classPK, OrderByComparator<SystemEvent> orderByComparator) 503 throws com.liferay.portal.NoSuchSystemEventException { 504 return getPersistence() 505 .findByG_C_C_Last(groupId, classNameId, classPK, 506 orderByComparator); 507 } 508 509 /** 510 * Returns the last system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 511 * 512 * @param groupId the group ID 513 * @param classNameId the class name ID 514 * @param classPK the class p k 515 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 516 * @return the last matching system event, or <code>null</code> if a matching system event could not be found 517 */ 518 public static SystemEvent fetchByG_C_C_Last(long groupId, long classNameId, 519 long classPK, OrderByComparator<SystemEvent> orderByComparator) { 520 return getPersistence() 521 .fetchByG_C_C_Last(groupId, classNameId, classPK, 522 orderByComparator); 523 } 524 525 /** 526 * Returns the system events before and after the current system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 527 * 528 * @param systemEventId the primary key of the current system event 529 * @param groupId the group ID 530 * @param classNameId the class name ID 531 * @param classPK the class p k 532 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 533 * @return the previous, current, and next system event 534 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 535 */ 536 public static SystemEvent[] findByG_C_C_PrevAndNext(long systemEventId, 537 long groupId, long classNameId, long classPK, 538 OrderByComparator<SystemEvent> orderByComparator) 539 throws com.liferay.portal.NoSuchSystemEventException { 540 return getPersistence() 541 .findByG_C_C_PrevAndNext(systemEventId, groupId, 542 classNameId, classPK, orderByComparator); 543 } 544 545 /** 546 * Removes all the system events where groupId = ? and classNameId = ? and classPK = ? from the database. 547 * 548 * @param groupId the group ID 549 * @param classNameId the class name ID 550 * @param classPK the class p k 551 */ 552 public static void removeByG_C_C(long groupId, long classNameId, 553 long classPK) { 554 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 555 } 556 557 /** 558 * Returns the number of system events where groupId = ? and classNameId = ? and classPK = ?. 559 * 560 * @param groupId the group ID 561 * @param classNameId the class name ID 562 * @param classPK the class p k 563 * @return the number of matching system events 564 */ 565 public static int countByG_C_C(long groupId, long classNameId, long classPK) { 566 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 567 } 568 569 /** 570 * Returns all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 571 * 572 * @param groupId the group ID 573 * @param classNameId the class name ID 574 * @param classPK the class p k 575 * @param type the type 576 * @return the matching system events 577 */ 578 public static List<SystemEvent> findByG_C_C_T(long groupId, 579 long classNameId, long classPK, int type) { 580 return getPersistence() 581 .findByG_C_C_T(groupId, classNameId, classPK, type); 582 } 583 584 /** 585 * Returns a range of all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 586 * 587 * <p> 588 * 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 SystemEventModelImpl}. 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. 589 * </p> 590 * 591 * @param groupId the group ID 592 * @param classNameId the class name ID 593 * @param classPK the class p k 594 * @param type the type 595 * @param start the lower bound of the range of system events 596 * @param end the upper bound of the range of system events (not inclusive) 597 * @return the range of matching system events 598 */ 599 public static List<SystemEvent> findByG_C_C_T(long groupId, 600 long classNameId, long classPK, int type, int start, int end) { 601 return getPersistence() 602 .findByG_C_C_T(groupId, classNameId, classPK, type, start, 603 end); 604 } 605 606 /** 607 * Returns an ordered range of all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 608 * 609 * <p> 610 * 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 SystemEventModelImpl}. 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. 611 * </p> 612 * 613 * @param groupId the group ID 614 * @param classNameId the class name ID 615 * @param classPK the class p k 616 * @param type the type 617 * @param start the lower bound of the range of system events 618 * @param end the upper bound of the range of system events (not inclusive) 619 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 620 * @return the ordered range of matching system events 621 */ 622 public static List<SystemEvent> findByG_C_C_T(long groupId, 623 long classNameId, long classPK, int type, int start, int end, 624 OrderByComparator<SystemEvent> orderByComparator) { 625 return getPersistence() 626 .findByG_C_C_T(groupId, classNameId, classPK, type, start, 627 end, orderByComparator); 628 } 629 630 /** 631 * Returns the first system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 632 * 633 * @param groupId the group ID 634 * @param classNameId the class name ID 635 * @param classPK the class p k 636 * @param type the type 637 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 638 * @return the first matching system event 639 * @throws NoSuchSystemEventException if a matching system event could not be found 640 */ 641 public static SystemEvent findByG_C_C_T_First(long groupId, 642 long classNameId, long classPK, int type, 643 OrderByComparator<SystemEvent> orderByComparator) 644 throws com.liferay.portal.NoSuchSystemEventException { 645 return getPersistence() 646 .findByG_C_C_T_First(groupId, classNameId, classPK, type, 647 orderByComparator); 648 } 649 650 /** 651 * Returns the first system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 652 * 653 * @param groupId the group ID 654 * @param classNameId the class name ID 655 * @param classPK the class p k 656 * @param type the type 657 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 658 * @return the first matching system event, or <code>null</code> if a matching system event could not be found 659 */ 660 public static SystemEvent fetchByG_C_C_T_First(long groupId, 661 long classNameId, long classPK, int type, 662 OrderByComparator<SystemEvent> orderByComparator) { 663 return getPersistence() 664 .fetchByG_C_C_T_First(groupId, classNameId, classPK, type, 665 orderByComparator); 666 } 667 668 /** 669 * Returns the last system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 670 * 671 * @param groupId the group ID 672 * @param classNameId the class name ID 673 * @param classPK the class p k 674 * @param type the type 675 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 676 * @return the last matching system event 677 * @throws NoSuchSystemEventException if a matching system event could not be found 678 */ 679 public static SystemEvent findByG_C_C_T_Last(long groupId, 680 long classNameId, long classPK, int type, 681 OrderByComparator<SystemEvent> orderByComparator) 682 throws com.liferay.portal.NoSuchSystemEventException { 683 return getPersistence() 684 .findByG_C_C_T_Last(groupId, classNameId, classPK, type, 685 orderByComparator); 686 } 687 688 /** 689 * Returns the last system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 690 * 691 * @param groupId the group ID 692 * @param classNameId the class name ID 693 * @param classPK the class p k 694 * @param type the type 695 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 696 * @return the last matching system event, or <code>null</code> if a matching system event could not be found 697 */ 698 public static SystemEvent fetchByG_C_C_T_Last(long groupId, 699 long classNameId, long classPK, int type, 700 OrderByComparator<SystemEvent> orderByComparator) { 701 return getPersistence() 702 .fetchByG_C_C_T_Last(groupId, classNameId, classPK, type, 703 orderByComparator); 704 } 705 706 /** 707 * Returns the system events before and after the current system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 708 * 709 * @param systemEventId the primary key of the current system event 710 * @param groupId the group ID 711 * @param classNameId the class name ID 712 * @param classPK the class p k 713 * @param type the type 714 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 715 * @return the previous, current, and next system event 716 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 717 */ 718 public static SystemEvent[] findByG_C_C_T_PrevAndNext(long systemEventId, 719 long groupId, long classNameId, long classPK, int type, 720 OrderByComparator<SystemEvent> orderByComparator) 721 throws com.liferay.portal.NoSuchSystemEventException { 722 return getPersistence() 723 .findByG_C_C_T_PrevAndNext(systemEventId, groupId, 724 classNameId, classPK, type, orderByComparator); 725 } 726 727 /** 728 * Removes all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ? from the database. 729 * 730 * @param groupId the group ID 731 * @param classNameId the class name ID 732 * @param classPK the class p k 733 * @param type the type 734 */ 735 public static void removeByG_C_C_T(long groupId, long classNameId, 736 long classPK, int type) { 737 getPersistence().removeByG_C_C_T(groupId, classNameId, classPK, type); 738 } 739 740 /** 741 * Returns the number of system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 742 * 743 * @param groupId the group ID 744 * @param classNameId the class name ID 745 * @param classPK the class p k 746 * @param type the type 747 * @return the number of matching system events 748 */ 749 public static int countByG_C_C_T(long groupId, long classNameId, 750 long classPK, int type) { 751 return getPersistence() 752 .countByG_C_C_T(groupId, classNameId, classPK, type); 753 } 754 755 /** 756 * Caches the system event in the entity cache if it is enabled. 757 * 758 * @param systemEvent the system event 759 */ 760 public static void cacheResult(SystemEvent systemEvent) { 761 getPersistence().cacheResult(systemEvent); 762 } 763 764 /** 765 * Caches the system events in the entity cache if it is enabled. 766 * 767 * @param systemEvents the system events 768 */ 769 public static void cacheResult(List<SystemEvent> systemEvents) { 770 getPersistence().cacheResult(systemEvents); 771 } 772 773 /** 774 * Creates a new system event with the primary key. Does not add the system event to the database. 775 * 776 * @param systemEventId the primary key for the new system event 777 * @return the new system event 778 */ 779 public static SystemEvent create(long systemEventId) { 780 return getPersistence().create(systemEventId); 781 } 782 783 /** 784 * Removes the system event with the primary key from the database. Also notifies the appropriate model listeners. 785 * 786 * @param systemEventId the primary key of the system event 787 * @return the system event that was removed 788 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 789 */ 790 public static SystemEvent remove(long systemEventId) 791 throws com.liferay.portal.NoSuchSystemEventException { 792 return getPersistence().remove(systemEventId); 793 } 794 795 public static SystemEvent updateImpl(SystemEvent systemEvent) { 796 return getPersistence().updateImpl(systemEvent); 797 } 798 799 /** 800 * Returns the system event with the primary key or throws a {@link NoSuchSystemEventException} if it could not be found. 801 * 802 * @param systemEventId the primary key of the system event 803 * @return the system event 804 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 805 */ 806 public static SystemEvent findByPrimaryKey(long systemEventId) 807 throws com.liferay.portal.NoSuchSystemEventException { 808 return getPersistence().findByPrimaryKey(systemEventId); 809 } 810 811 /** 812 * Returns the system event with the primary key or returns <code>null</code> if it could not be found. 813 * 814 * @param systemEventId the primary key of the system event 815 * @return the system event, or <code>null</code> if a system event with the primary key could not be found 816 */ 817 public static SystemEvent fetchByPrimaryKey(long systemEventId) { 818 return getPersistence().fetchByPrimaryKey(systemEventId); 819 } 820 821 public static java.util.Map<java.io.Serializable, SystemEvent> fetchByPrimaryKeys( 822 java.util.Set<java.io.Serializable> primaryKeys) { 823 return getPersistence().fetchByPrimaryKeys(primaryKeys); 824 } 825 826 /** 827 * Returns all the system events. 828 * 829 * @return the system events 830 */ 831 public static List<SystemEvent> findAll() { 832 return getPersistence().findAll(); 833 } 834 835 /** 836 * Returns a range of all the system events. 837 * 838 * <p> 839 * 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 SystemEventModelImpl}. 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. 840 * </p> 841 * 842 * @param start the lower bound of the range of system events 843 * @param end the upper bound of the range of system events (not inclusive) 844 * @return the range of system events 845 */ 846 public static List<SystemEvent> findAll(int start, int end) { 847 return getPersistence().findAll(start, end); 848 } 849 850 /** 851 * Returns an ordered range of all the system events. 852 * 853 * <p> 854 * 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 SystemEventModelImpl}. 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. 855 * </p> 856 * 857 * @param start the lower bound of the range of system events 858 * @param end the upper bound of the range of system events (not inclusive) 859 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 860 * @return the ordered range of system events 861 */ 862 public static List<SystemEvent> findAll(int start, int end, 863 OrderByComparator<SystemEvent> orderByComparator) { 864 return getPersistence().findAll(start, end, orderByComparator); 865 } 866 867 /** 868 * Removes all the system events from the database. 869 */ 870 public static void removeAll() { 871 getPersistence().removeAll(); 872 } 873 874 /** 875 * Returns the number of system events. 876 * 877 * @return the number of system events 878 */ 879 public static int countAll() { 880 return getPersistence().countAll(); 881 } 882 883 public static SystemEventPersistence getPersistence() { 884 if (_persistence == null) { 885 _persistence = (SystemEventPersistence)PortalBeanLocatorUtil.locate(SystemEventPersistence.class.getName()); 886 887 ReferenceRegistry.registerReference(SystemEventUtil.class, 888 "_persistence"); 889 } 890 891 return _persistence; 892 } 893 894 /** 895 * @deprecated As of 6.2.0 896 */ 897 @Deprecated 898 public void setPersistence(SystemEventPersistence persistence) { 899 } 900 901 private static SystemEventPersistence _persistence; 902 }