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 an ordered range of all the system events where groupId = ?. 159 * 160 * <p> 161 * 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. 162 * </p> 163 * 164 * @param groupId the group ID 165 * @param start the lower bound of the range of system events 166 * @param end the upper bound of the range of system events (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching system events 170 */ 171 public static List<SystemEvent> findByGroupId(long groupId, int start, 172 int end, OrderByComparator<SystemEvent> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByGroupId(groupId, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first system event in the ordered set where groupId = ?. 181 * 182 * @param groupId the group ID 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching system event 185 * @throws NoSuchSystemEventException if a matching system event could not be found 186 */ 187 public static SystemEvent findByGroupId_First(long groupId, 188 OrderByComparator<SystemEvent> orderByComparator) 189 throws com.liferay.portal.exception.NoSuchSystemEventException { 190 return getPersistence().findByGroupId_First(groupId, orderByComparator); 191 } 192 193 /** 194 * Returns the first system event in the ordered set where groupId = ?. 195 * 196 * @param groupId the group ID 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching system event, or <code>null</code> if a matching system event could not be found 199 */ 200 public static SystemEvent fetchByGroupId_First(long groupId, 201 OrderByComparator<SystemEvent> orderByComparator) { 202 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 203 } 204 205 /** 206 * Returns the last system event in the ordered set where groupId = ?. 207 * 208 * @param groupId the group ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching system event 211 * @throws NoSuchSystemEventException if a matching system event could not be found 212 */ 213 public static SystemEvent findByGroupId_Last(long groupId, 214 OrderByComparator<SystemEvent> orderByComparator) 215 throws com.liferay.portal.exception.NoSuchSystemEventException { 216 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 217 } 218 219 /** 220 * Returns the last system event in the ordered set where groupId = ?. 221 * 222 * @param groupId the group ID 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching system event, or <code>null</code> if a matching system event could not be found 225 */ 226 public static SystemEvent fetchByGroupId_Last(long groupId, 227 OrderByComparator<SystemEvent> orderByComparator) { 228 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 229 } 230 231 /** 232 * Returns the system events before and after the current system event in the ordered set where groupId = ?. 233 * 234 * @param systemEventId the primary key of the current system event 235 * @param groupId the group ID 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next system event 238 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 239 */ 240 public static SystemEvent[] findByGroupId_PrevAndNext(long systemEventId, 241 long groupId, OrderByComparator<SystemEvent> orderByComparator) 242 throws com.liferay.portal.exception.NoSuchSystemEventException { 243 return getPersistence() 244 .findByGroupId_PrevAndNext(systemEventId, groupId, 245 orderByComparator); 246 } 247 248 /** 249 * Removes all the system events where groupId = ? from the database. 250 * 251 * @param groupId the group ID 252 */ 253 public static void removeByGroupId(long groupId) { 254 getPersistence().removeByGroupId(groupId); 255 } 256 257 /** 258 * Returns the number of system events where groupId = ?. 259 * 260 * @param groupId the group ID 261 * @return the number of matching system events 262 */ 263 public static int countByGroupId(long groupId) { 264 return getPersistence().countByGroupId(groupId); 265 } 266 267 /** 268 * Returns all the system events where groupId = ? and systemEventSetKey = ?. 269 * 270 * @param groupId the group ID 271 * @param systemEventSetKey the system event set key 272 * @return the matching system events 273 */ 274 public static List<SystemEvent> findByG_S(long groupId, 275 long systemEventSetKey) { 276 return getPersistence().findByG_S(groupId, systemEventSetKey); 277 } 278 279 /** 280 * Returns a range of all the system events where groupId = ? and systemEventSetKey = ?. 281 * 282 * <p> 283 * 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. 284 * </p> 285 * 286 * @param groupId the group ID 287 * @param systemEventSetKey the system event set key 288 * @param start the lower bound of the range of system events 289 * @param end the upper bound of the range of system events (not inclusive) 290 * @return the range of matching system events 291 */ 292 public static List<SystemEvent> findByG_S(long groupId, 293 long systemEventSetKey, int start, int end) { 294 return getPersistence().findByG_S(groupId, systemEventSetKey, start, end); 295 } 296 297 /** 298 * Returns an ordered range of all the system events where groupId = ? and systemEventSetKey = ?. 299 * 300 * <p> 301 * 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. 302 * </p> 303 * 304 * @param groupId the group ID 305 * @param systemEventSetKey the system event set key 306 * @param start the lower bound of the range of system events 307 * @param end the upper bound of the range of system events (not inclusive) 308 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 309 * @return the ordered range of matching system events 310 */ 311 public static List<SystemEvent> findByG_S(long groupId, 312 long systemEventSetKey, int start, int end, 313 OrderByComparator<SystemEvent> orderByComparator) { 314 return getPersistence() 315 .findByG_S(groupId, systemEventSetKey, start, end, 316 orderByComparator); 317 } 318 319 /** 320 * Returns an ordered range of all the system events where groupId = ? and systemEventSetKey = ?. 321 * 322 * <p> 323 * 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. 324 * </p> 325 * 326 * @param groupId the group ID 327 * @param systemEventSetKey the system event set key 328 * @param start the lower bound of the range of system events 329 * @param end the upper bound of the range of system events (not inclusive) 330 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 331 * @param retrieveFromCache whether to retrieve from the finder cache 332 * @return the ordered range of matching system events 333 */ 334 public static List<SystemEvent> findByG_S(long groupId, 335 long systemEventSetKey, int start, int end, 336 OrderByComparator<SystemEvent> orderByComparator, 337 boolean retrieveFromCache) { 338 return getPersistence() 339 .findByG_S(groupId, systemEventSetKey, start, end, 340 orderByComparator, retrieveFromCache); 341 } 342 343 /** 344 * Returns the first system event in the ordered set where groupId = ? and systemEventSetKey = ?. 345 * 346 * @param groupId the group ID 347 * @param systemEventSetKey the system event set key 348 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 349 * @return the first matching system event 350 * @throws NoSuchSystemEventException if a matching system event could not be found 351 */ 352 public static SystemEvent findByG_S_First(long groupId, 353 long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) 354 throws com.liferay.portal.exception.NoSuchSystemEventException { 355 return getPersistence() 356 .findByG_S_First(groupId, systemEventSetKey, 357 orderByComparator); 358 } 359 360 /** 361 * Returns the first system event in the ordered set where groupId = ? and systemEventSetKey = ?. 362 * 363 * @param groupId the group ID 364 * @param systemEventSetKey the system event set key 365 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 366 * @return the first matching system event, or <code>null</code> if a matching system event could not be found 367 */ 368 public static SystemEvent fetchByG_S_First(long groupId, 369 long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) { 370 return getPersistence() 371 .fetchByG_S_First(groupId, systemEventSetKey, 372 orderByComparator); 373 } 374 375 /** 376 * Returns the last system event in the ordered set where groupId = ? and systemEventSetKey = ?. 377 * 378 * @param groupId the group ID 379 * @param systemEventSetKey the system event set key 380 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 381 * @return the last matching system event 382 * @throws NoSuchSystemEventException if a matching system event could not be found 383 */ 384 public static SystemEvent findByG_S_Last(long groupId, 385 long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) 386 throws com.liferay.portal.exception.NoSuchSystemEventException { 387 return getPersistence() 388 .findByG_S_Last(groupId, systemEventSetKey, orderByComparator); 389 } 390 391 /** 392 * Returns the last system event in the ordered set where groupId = ? and systemEventSetKey = ?. 393 * 394 * @param groupId the group ID 395 * @param systemEventSetKey the system event set key 396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 397 * @return the last matching system event, or <code>null</code> if a matching system event could not be found 398 */ 399 public static SystemEvent fetchByG_S_Last(long groupId, 400 long systemEventSetKey, OrderByComparator<SystemEvent> orderByComparator) { 401 return getPersistence() 402 .fetchByG_S_Last(groupId, systemEventSetKey, 403 orderByComparator); 404 } 405 406 /** 407 * Returns the system events before and after the current system event in the ordered set where groupId = ? and systemEventSetKey = ?. 408 * 409 * @param systemEventId the primary key of the current system event 410 * @param groupId the group ID 411 * @param systemEventSetKey the system event set key 412 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 413 * @return the previous, current, and next system event 414 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 415 */ 416 public static SystemEvent[] findByG_S_PrevAndNext(long systemEventId, 417 long groupId, long systemEventSetKey, 418 OrderByComparator<SystemEvent> orderByComparator) 419 throws com.liferay.portal.exception.NoSuchSystemEventException { 420 return getPersistence() 421 .findByG_S_PrevAndNext(systemEventId, groupId, 422 systemEventSetKey, orderByComparator); 423 } 424 425 /** 426 * Removes all the system events where groupId = ? and systemEventSetKey = ? from the database. 427 * 428 * @param groupId the group ID 429 * @param systemEventSetKey the system event set key 430 */ 431 public static void removeByG_S(long groupId, long systemEventSetKey) { 432 getPersistence().removeByG_S(groupId, systemEventSetKey); 433 } 434 435 /** 436 * Returns the number of system events where groupId = ? and systemEventSetKey = ?. 437 * 438 * @param groupId the group ID 439 * @param systemEventSetKey the system event set key 440 * @return the number of matching system events 441 */ 442 public static int countByG_S(long groupId, long systemEventSetKey) { 443 return getPersistence().countByG_S(groupId, systemEventSetKey); 444 } 445 446 /** 447 * Returns all the system events where groupId = ? and classNameId = ? and classPK = ?. 448 * 449 * @param groupId the group ID 450 * @param classNameId the class name ID 451 * @param classPK the class p k 452 * @return the matching system events 453 */ 454 public static List<SystemEvent> findByG_C_C(long groupId, long classNameId, 455 long classPK) { 456 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 457 } 458 459 /** 460 * Returns a range of all the system events where groupId = ? and classNameId = ? and classPK = ?. 461 * 462 * <p> 463 * 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. 464 * </p> 465 * 466 * @param groupId the group ID 467 * @param classNameId the class name ID 468 * @param classPK the class p k 469 * @param start the lower bound of the range of system events 470 * @param end the upper bound of the range of system events (not inclusive) 471 * @return the range of matching system events 472 */ 473 public static List<SystemEvent> findByG_C_C(long groupId, long classNameId, 474 long classPK, int start, int end) { 475 return getPersistence() 476 .findByG_C_C(groupId, classNameId, classPK, start, end); 477 } 478 479 /** 480 * Returns an ordered range of all the system events where groupId = ? and classNameId = ? and classPK = ?. 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 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. 484 * </p> 485 * 486 * @param groupId the group ID 487 * @param classNameId the class name ID 488 * @param classPK the class p k 489 * @param start the lower bound of the range of system events 490 * @param end the upper bound of the range of system events (not inclusive) 491 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 492 * @return the ordered range of matching system events 493 */ 494 public static List<SystemEvent> findByG_C_C(long groupId, long classNameId, 495 long classPK, int start, int end, 496 OrderByComparator<SystemEvent> orderByComparator) { 497 return getPersistence() 498 .findByG_C_C(groupId, classNameId, classPK, start, end, 499 orderByComparator); 500 } 501 502 /** 503 * Returns an ordered range of all the system events where groupId = ? and classNameId = ? and classPK = ?. 504 * 505 * <p> 506 * 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. 507 * </p> 508 * 509 * @param groupId the group ID 510 * @param classNameId the class name ID 511 * @param classPK the class p k 512 * @param start the lower bound of the range of system events 513 * @param end the upper bound of the range of system events (not inclusive) 514 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 515 * @param retrieveFromCache whether to retrieve from the finder cache 516 * @return the ordered range of matching system events 517 */ 518 public static List<SystemEvent> findByG_C_C(long groupId, long classNameId, 519 long classPK, int start, int end, 520 OrderByComparator<SystemEvent> orderByComparator, 521 boolean retrieveFromCache) { 522 return getPersistence() 523 .findByG_C_C(groupId, classNameId, classPK, start, end, 524 orderByComparator, retrieveFromCache); 525 } 526 527 /** 528 * Returns the first system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 529 * 530 * @param groupId the group ID 531 * @param classNameId the class name ID 532 * @param classPK the class p k 533 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 534 * @return the first matching system event 535 * @throws NoSuchSystemEventException if a matching system event could not be found 536 */ 537 public static SystemEvent findByG_C_C_First(long groupId, long classNameId, 538 long classPK, OrderByComparator<SystemEvent> orderByComparator) 539 throws com.liferay.portal.exception.NoSuchSystemEventException { 540 return getPersistence() 541 .findByG_C_C_First(groupId, classNameId, classPK, 542 orderByComparator); 543 } 544 545 /** 546 * Returns the first system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 547 * 548 * @param groupId the group ID 549 * @param classNameId the class name ID 550 * @param classPK the class p k 551 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 552 * @return the first matching system event, or <code>null</code> if a matching system event could not be found 553 */ 554 public static SystemEvent fetchByG_C_C_First(long groupId, 555 long classNameId, long classPK, 556 OrderByComparator<SystemEvent> orderByComparator) { 557 return getPersistence() 558 .fetchByG_C_C_First(groupId, classNameId, classPK, 559 orderByComparator); 560 } 561 562 /** 563 * Returns the last system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 564 * 565 * @param groupId the group ID 566 * @param classNameId the class name ID 567 * @param classPK the class p k 568 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 569 * @return the last matching system event 570 * @throws NoSuchSystemEventException if a matching system event could not be found 571 */ 572 public static SystemEvent findByG_C_C_Last(long groupId, long classNameId, 573 long classPK, OrderByComparator<SystemEvent> orderByComparator) 574 throws com.liferay.portal.exception.NoSuchSystemEventException { 575 return getPersistence() 576 .findByG_C_C_Last(groupId, classNameId, classPK, 577 orderByComparator); 578 } 579 580 /** 581 * Returns the last system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 582 * 583 * @param groupId the group ID 584 * @param classNameId the class name ID 585 * @param classPK the class p k 586 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 587 * @return the last matching system event, or <code>null</code> if a matching system event could not be found 588 */ 589 public static SystemEvent fetchByG_C_C_Last(long groupId, long classNameId, 590 long classPK, OrderByComparator<SystemEvent> orderByComparator) { 591 return getPersistence() 592 .fetchByG_C_C_Last(groupId, classNameId, classPK, 593 orderByComparator); 594 } 595 596 /** 597 * Returns the system events before and after the current system event in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 598 * 599 * @param systemEventId the primary key of the current system event 600 * @param groupId the group ID 601 * @param classNameId the class name ID 602 * @param classPK the class p k 603 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 604 * @return the previous, current, and next system event 605 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 606 */ 607 public static SystemEvent[] findByG_C_C_PrevAndNext(long systemEventId, 608 long groupId, long classNameId, long classPK, 609 OrderByComparator<SystemEvent> orderByComparator) 610 throws com.liferay.portal.exception.NoSuchSystemEventException { 611 return getPersistence() 612 .findByG_C_C_PrevAndNext(systemEventId, groupId, 613 classNameId, classPK, orderByComparator); 614 } 615 616 /** 617 * Removes all the system events where groupId = ? and classNameId = ? and classPK = ? from the database. 618 * 619 * @param groupId the group ID 620 * @param classNameId the class name ID 621 * @param classPK the class p k 622 */ 623 public static void removeByG_C_C(long groupId, long classNameId, 624 long classPK) { 625 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 626 } 627 628 /** 629 * Returns the number of system events where groupId = ? and classNameId = ? and classPK = ?. 630 * 631 * @param groupId the group ID 632 * @param classNameId the class name ID 633 * @param classPK the class p k 634 * @return the number of matching system events 635 */ 636 public static int countByG_C_C(long groupId, long classNameId, long classPK) { 637 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 638 } 639 640 /** 641 * Returns all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 642 * 643 * @param groupId the group ID 644 * @param classNameId the class name ID 645 * @param classPK the class p k 646 * @param type the type 647 * @return the matching system events 648 */ 649 public static List<SystemEvent> findByG_C_C_T(long groupId, 650 long classNameId, long classPK, int type) { 651 return getPersistence() 652 .findByG_C_C_T(groupId, classNameId, classPK, type); 653 } 654 655 /** 656 * Returns a range of all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 657 * 658 * <p> 659 * 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. 660 * </p> 661 * 662 * @param groupId the group ID 663 * @param classNameId the class name ID 664 * @param classPK the class p k 665 * @param type the type 666 * @param start the lower bound of the range of system events 667 * @param end the upper bound of the range of system events (not inclusive) 668 * @return the range of matching system events 669 */ 670 public static List<SystemEvent> findByG_C_C_T(long groupId, 671 long classNameId, long classPK, int type, int start, int end) { 672 return getPersistence() 673 .findByG_C_C_T(groupId, classNameId, classPK, type, start, 674 end); 675 } 676 677 /** 678 * Returns an ordered range of all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 679 * 680 * <p> 681 * 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. 682 * </p> 683 * 684 * @param groupId the group ID 685 * @param classNameId the class name ID 686 * @param classPK the class p k 687 * @param type the type 688 * @param start the lower bound of the range of system events 689 * @param end the upper bound of the range of system events (not inclusive) 690 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 691 * @return the ordered range of matching system events 692 */ 693 public static List<SystemEvent> findByG_C_C_T(long groupId, 694 long classNameId, long classPK, int type, int start, int end, 695 OrderByComparator<SystemEvent> orderByComparator) { 696 return getPersistence() 697 .findByG_C_C_T(groupId, classNameId, classPK, type, start, 698 end, orderByComparator); 699 } 700 701 /** 702 * Returns an ordered range of all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 703 * 704 * <p> 705 * 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. 706 * </p> 707 * 708 * @param groupId the group ID 709 * @param classNameId the class name ID 710 * @param classPK the class p k 711 * @param type the type 712 * @param start the lower bound of the range of system events 713 * @param end the upper bound of the range of system events (not inclusive) 714 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 715 * @param retrieveFromCache whether to retrieve from the finder cache 716 * @return the ordered range of matching system events 717 */ 718 public static List<SystemEvent> findByG_C_C_T(long groupId, 719 long classNameId, long classPK, int type, int start, int end, 720 OrderByComparator<SystemEvent> orderByComparator, 721 boolean retrieveFromCache) { 722 return getPersistence() 723 .findByG_C_C_T(groupId, classNameId, classPK, type, start, 724 end, orderByComparator, retrieveFromCache); 725 } 726 727 /** 728 * Returns the first system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 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 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 735 * @return the first matching system event 736 * @throws NoSuchSystemEventException if a matching system event could not be found 737 */ 738 public static SystemEvent findByG_C_C_T_First(long groupId, 739 long classNameId, long classPK, int type, 740 OrderByComparator<SystemEvent> orderByComparator) 741 throws com.liferay.portal.exception.NoSuchSystemEventException { 742 return getPersistence() 743 .findByG_C_C_T_First(groupId, classNameId, classPK, type, 744 orderByComparator); 745 } 746 747 /** 748 * Returns the first system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 749 * 750 * @param groupId the group ID 751 * @param classNameId the class name ID 752 * @param classPK the class p k 753 * @param type the type 754 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 755 * @return the first matching system event, or <code>null</code> if a matching system event could not be found 756 */ 757 public static SystemEvent fetchByG_C_C_T_First(long groupId, 758 long classNameId, long classPK, int type, 759 OrderByComparator<SystemEvent> orderByComparator) { 760 return getPersistence() 761 .fetchByG_C_C_T_First(groupId, classNameId, classPK, type, 762 orderByComparator); 763 } 764 765 /** 766 * Returns the last system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 767 * 768 * @param groupId the group ID 769 * @param classNameId the class name ID 770 * @param classPK the class p k 771 * @param type the type 772 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 773 * @return the last matching system event 774 * @throws NoSuchSystemEventException if a matching system event could not be found 775 */ 776 public static SystemEvent findByG_C_C_T_Last(long groupId, 777 long classNameId, long classPK, int type, 778 OrderByComparator<SystemEvent> orderByComparator) 779 throws com.liferay.portal.exception.NoSuchSystemEventException { 780 return getPersistence() 781 .findByG_C_C_T_Last(groupId, classNameId, classPK, type, 782 orderByComparator); 783 } 784 785 /** 786 * Returns the last system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 787 * 788 * @param groupId the group ID 789 * @param classNameId the class name ID 790 * @param classPK the class p k 791 * @param type the type 792 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 793 * @return the last matching system event, or <code>null</code> if a matching system event could not be found 794 */ 795 public static SystemEvent fetchByG_C_C_T_Last(long groupId, 796 long classNameId, long classPK, int type, 797 OrderByComparator<SystemEvent> orderByComparator) { 798 return getPersistence() 799 .fetchByG_C_C_T_Last(groupId, classNameId, classPK, type, 800 orderByComparator); 801 } 802 803 /** 804 * Returns the system events before and after the current system event in the ordered set where groupId = ? and classNameId = ? and classPK = ? and type = ?. 805 * 806 * @param systemEventId the primary key of the current system event 807 * @param groupId the group ID 808 * @param classNameId the class name ID 809 * @param classPK the class p k 810 * @param type the type 811 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 812 * @return the previous, current, and next system event 813 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 814 */ 815 public static SystemEvent[] findByG_C_C_T_PrevAndNext(long systemEventId, 816 long groupId, long classNameId, long classPK, int type, 817 OrderByComparator<SystemEvent> orderByComparator) 818 throws com.liferay.portal.exception.NoSuchSystemEventException { 819 return getPersistence() 820 .findByG_C_C_T_PrevAndNext(systemEventId, groupId, 821 classNameId, classPK, type, orderByComparator); 822 } 823 824 /** 825 * Removes all the system events where groupId = ? and classNameId = ? and classPK = ? and type = ? from the database. 826 * 827 * @param groupId the group ID 828 * @param classNameId the class name ID 829 * @param classPK the class p k 830 * @param type the type 831 */ 832 public static void removeByG_C_C_T(long groupId, long classNameId, 833 long classPK, int type) { 834 getPersistence().removeByG_C_C_T(groupId, classNameId, classPK, type); 835 } 836 837 /** 838 * Returns the number of system events where groupId = ? and classNameId = ? and classPK = ? and type = ?. 839 * 840 * @param groupId the group ID 841 * @param classNameId the class name ID 842 * @param classPK the class p k 843 * @param type the type 844 * @return the number of matching system events 845 */ 846 public static int countByG_C_C_T(long groupId, long classNameId, 847 long classPK, int type) { 848 return getPersistence() 849 .countByG_C_C_T(groupId, classNameId, classPK, type); 850 } 851 852 /** 853 * Caches the system event in the entity cache if it is enabled. 854 * 855 * @param systemEvent the system event 856 */ 857 public static void cacheResult(SystemEvent systemEvent) { 858 getPersistence().cacheResult(systemEvent); 859 } 860 861 /** 862 * Caches the system events in the entity cache if it is enabled. 863 * 864 * @param systemEvents the system events 865 */ 866 public static void cacheResult(List<SystemEvent> systemEvents) { 867 getPersistence().cacheResult(systemEvents); 868 } 869 870 /** 871 * Creates a new system event with the primary key. Does not add the system event to the database. 872 * 873 * @param systemEventId the primary key for the new system event 874 * @return the new system event 875 */ 876 public static SystemEvent create(long systemEventId) { 877 return getPersistence().create(systemEventId); 878 } 879 880 /** 881 * Removes the system event with the primary key from the database. Also notifies the appropriate model listeners. 882 * 883 * @param systemEventId the primary key of the system event 884 * @return the system event that was removed 885 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 886 */ 887 public static SystemEvent remove(long systemEventId) 888 throws com.liferay.portal.exception.NoSuchSystemEventException { 889 return getPersistence().remove(systemEventId); 890 } 891 892 public static SystemEvent updateImpl(SystemEvent systemEvent) { 893 return getPersistence().updateImpl(systemEvent); 894 } 895 896 /** 897 * Returns the system event with the primary key or throws a {@link NoSuchSystemEventException} if it could not be found. 898 * 899 * @param systemEventId the primary key of the system event 900 * @return the system event 901 * @throws NoSuchSystemEventException if a system event with the primary key could not be found 902 */ 903 public static SystemEvent findByPrimaryKey(long systemEventId) 904 throws com.liferay.portal.exception.NoSuchSystemEventException { 905 return getPersistence().findByPrimaryKey(systemEventId); 906 } 907 908 /** 909 * Returns the system event with the primary key or returns <code>null</code> if it could not be found. 910 * 911 * @param systemEventId the primary key of the system event 912 * @return the system event, or <code>null</code> if a system event with the primary key could not be found 913 */ 914 public static SystemEvent fetchByPrimaryKey(long systemEventId) { 915 return getPersistence().fetchByPrimaryKey(systemEventId); 916 } 917 918 public static java.util.Map<java.io.Serializable, SystemEvent> fetchByPrimaryKeys( 919 java.util.Set<java.io.Serializable> primaryKeys) { 920 return getPersistence().fetchByPrimaryKeys(primaryKeys); 921 } 922 923 /** 924 * Returns all the system events. 925 * 926 * @return the system events 927 */ 928 public static List<SystemEvent> findAll() { 929 return getPersistence().findAll(); 930 } 931 932 /** 933 * Returns a range of all the system events. 934 * 935 * <p> 936 * 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. 937 * </p> 938 * 939 * @param start the lower bound of the range of system events 940 * @param end the upper bound of the range of system events (not inclusive) 941 * @return the range of system events 942 */ 943 public static List<SystemEvent> findAll(int start, int end) { 944 return getPersistence().findAll(start, end); 945 } 946 947 /** 948 * Returns an ordered range of all the system events. 949 * 950 * <p> 951 * 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. 952 * </p> 953 * 954 * @param start the lower bound of the range of system events 955 * @param end the upper bound of the range of system events (not inclusive) 956 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 957 * @return the ordered range of system events 958 */ 959 public static List<SystemEvent> findAll(int start, int end, 960 OrderByComparator<SystemEvent> orderByComparator) { 961 return getPersistence().findAll(start, end, orderByComparator); 962 } 963 964 /** 965 * Returns an ordered range of all the system events. 966 * 967 * <p> 968 * 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. 969 * </p> 970 * 971 * @param start the lower bound of the range of system events 972 * @param end the upper bound of the range of system events (not inclusive) 973 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 974 * @param retrieveFromCache whether to retrieve from the finder cache 975 * @return the ordered range of system events 976 */ 977 public static List<SystemEvent> findAll(int start, int end, 978 OrderByComparator<SystemEvent> orderByComparator, 979 boolean retrieveFromCache) { 980 return getPersistence() 981 .findAll(start, end, orderByComparator, retrieveFromCache); 982 } 983 984 /** 985 * Removes all the system events from the database. 986 */ 987 public static void removeAll() { 988 getPersistence().removeAll(); 989 } 990 991 /** 992 * Returns the number of system events. 993 * 994 * @return the number of system events 995 */ 996 public static int countAll() { 997 return getPersistence().countAll(); 998 } 999 1000 public static java.util.Set<java.lang.String> getBadColumnNames() { 1001 return getPersistence().getBadColumnNames(); 1002 } 1003 1004 public static SystemEventPersistence getPersistence() { 1005 if (_persistence == null) { 1006 _persistence = (SystemEventPersistence)PortalBeanLocatorUtil.locate(SystemEventPersistence.class.getName()); 1007 1008 ReferenceRegistry.registerReference(SystemEventUtil.class, 1009 "_persistence"); 1010 } 1011 1012 return _persistence; 1013 } 1014 1015 private static SystemEventPersistence _persistence; 1016 }