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.portlet.calendar.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.service.ServiceContext; 024 025 import com.liferay.portlet.calendar.model.CalEvent; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the cal event service. This utility wraps {@link com.liferay.portlet.calendar.service.persistence.impl.CalEventPersistenceImpl} 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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see CalEventPersistence 038 * @see com.liferay.portlet.calendar.service.persistence.impl.CalEventPersistenceImpl 039 * @deprecated As of 7.0.0, with no direct replacement 040 * @generated 041 */ 042 @Deprecated 043 @ProviderType 044 public class CalEventUtil { 045 /* 046 * NOTE FOR DEVELOPERS: 047 * 048 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 049 */ 050 051 /** 052 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 053 */ 054 public static void clearCache() { 055 getPersistence().clearCache(); 056 } 057 058 /** 059 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 060 */ 061 public static void clearCache(CalEvent calEvent) { 062 getPersistence().clearCache(calEvent); 063 } 064 065 /** 066 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 067 */ 068 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 069 return getPersistence().countWithDynamicQuery(dynamicQuery); 070 } 071 072 /** 073 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 074 */ 075 public static List<CalEvent> findWithDynamicQuery(DynamicQuery dynamicQuery) { 076 return getPersistence().findWithDynamicQuery(dynamicQuery); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 081 */ 082 public static List<CalEvent> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end) { 084 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 085 } 086 087 /** 088 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 089 */ 090 public static List<CalEvent> findWithDynamicQuery( 091 DynamicQuery dynamicQuery, int start, int end, 092 OrderByComparator<CalEvent> orderByComparator) { 093 return getPersistence() 094 .findWithDynamicQuery(dynamicQuery, start, end, 095 orderByComparator); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 100 */ 101 public static CalEvent update(CalEvent calEvent) { 102 return getPersistence().update(calEvent); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static CalEvent update(CalEvent calEvent, 109 ServiceContext serviceContext) { 110 return getPersistence().update(calEvent, serviceContext); 111 } 112 113 /** 114 * Returns all the cal events where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching cal events 118 */ 119 public static List<CalEvent> findByUuid(java.lang.String uuid) { 120 return getPersistence().findByUuid(uuid); 121 } 122 123 /** 124 * Returns a range of all the cal events where uuid = ?. 125 * 126 * <p> 127 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link CalEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 128 * </p> 129 * 130 * @param uuid the uuid 131 * @param start the lower bound of the range of cal events 132 * @param end the upper bound of the range of cal events (not inclusive) 133 * @return the range of matching cal events 134 */ 135 public static List<CalEvent> findByUuid(java.lang.String uuid, int start, 136 int end) { 137 return getPersistence().findByUuid(uuid, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the cal events where uuid = ?. 142 * 143 * <p> 144 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link CalEventModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 145 * </p> 146 * 147 * @param uuid the uuid 148 * @param start the lower bound of the range of cal events 149 * @param end the upper bound of the range of cal events (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching cal events 152 */ 153 public static List<CalEvent> findByUuid(java.lang.String uuid, int start, 154 int end, OrderByComparator<CalEvent> orderByComparator) { 155 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns an ordered range of all the cal events where uuid = ?. 160 * 161 * <p> 162 * 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 CalEventModelImpl}. 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. 163 * </p> 164 * 165 * @param uuid the uuid 166 * @param start the lower bound of the range of cal events 167 * @param end the upper bound of the range of cal events (not inclusive) 168 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 169 * @param retrieveFromCache whether to retrieve from the finder cache 170 * @return the ordered range of matching cal events 171 */ 172 public static List<CalEvent> findByUuid(java.lang.String uuid, int start, 173 int end, OrderByComparator<CalEvent> orderByComparator, 174 boolean retrieveFromCache) { 175 return getPersistence() 176 .findByUuid(uuid, start, end, orderByComparator, 177 retrieveFromCache); 178 } 179 180 /** 181 * Returns the first cal event in the ordered set where uuid = ?. 182 * 183 * @param uuid the uuid 184 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 185 * @return the first matching cal event 186 * @throws NoSuchEventException if a matching cal event could not be found 187 */ 188 public static CalEvent findByUuid_First(java.lang.String uuid, 189 OrderByComparator<CalEvent> orderByComparator) 190 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 191 return getPersistence().findByUuid_First(uuid, orderByComparator); 192 } 193 194 /** 195 * Returns the first cal event in the ordered set where uuid = ?. 196 * 197 * @param uuid the uuid 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 200 */ 201 public static CalEvent fetchByUuid_First(java.lang.String uuid, 202 OrderByComparator<CalEvent> orderByComparator) { 203 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 204 } 205 206 /** 207 * Returns the last cal event in the ordered set where uuid = ?. 208 * 209 * @param uuid the uuid 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the last matching cal event 212 * @throws NoSuchEventException if a matching cal event could not be found 213 */ 214 public static CalEvent findByUuid_Last(java.lang.String uuid, 215 OrderByComparator<CalEvent> orderByComparator) 216 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 217 return getPersistence().findByUuid_Last(uuid, orderByComparator); 218 } 219 220 /** 221 * Returns the last cal event in the ordered set where uuid = ?. 222 * 223 * @param uuid the uuid 224 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 225 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 226 */ 227 public static CalEvent fetchByUuid_Last(java.lang.String uuid, 228 OrderByComparator<CalEvent> orderByComparator) { 229 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 230 } 231 232 /** 233 * Returns the cal events before and after the current cal event in the ordered set where uuid = ?. 234 * 235 * @param eventId the primary key of the current cal event 236 * @param uuid the uuid 237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 238 * @return the previous, current, and next cal event 239 * @throws NoSuchEventException if a cal event with the primary key could not be found 240 */ 241 public static CalEvent[] findByUuid_PrevAndNext(long eventId, 242 java.lang.String uuid, OrderByComparator<CalEvent> orderByComparator) 243 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 244 return getPersistence() 245 .findByUuid_PrevAndNext(eventId, uuid, orderByComparator); 246 } 247 248 /** 249 * Removes all the cal events where uuid = ? from the database. 250 * 251 * @param uuid the uuid 252 */ 253 public static void removeByUuid(java.lang.String uuid) { 254 getPersistence().removeByUuid(uuid); 255 } 256 257 /** 258 * Returns the number of cal events where uuid = ?. 259 * 260 * @param uuid the uuid 261 * @return the number of matching cal events 262 */ 263 public static int countByUuid(java.lang.String uuid) { 264 return getPersistence().countByUuid(uuid); 265 } 266 267 /** 268 * Returns the cal event where uuid = ? and groupId = ? or throws a {@link NoSuchEventException} if it could not be found. 269 * 270 * @param uuid the uuid 271 * @param groupId the group ID 272 * @return the matching cal event 273 * @throws NoSuchEventException if a matching cal event could not be found 274 */ 275 public static CalEvent findByUUID_G(java.lang.String uuid, long groupId) 276 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 277 return getPersistence().findByUUID_G(uuid, groupId); 278 } 279 280 /** 281 * Returns the cal event where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 282 * 283 * @param uuid the uuid 284 * @param groupId the group ID 285 * @return the matching cal event, or <code>null</code> if a matching cal event could not be found 286 */ 287 public static CalEvent fetchByUUID_G(java.lang.String uuid, long groupId) { 288 return getPersistence().fetchByUUID_G(uuid, groupId); 289 } 290 291 /** 292 * Returns the cal event where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 293 * 294 * @param uuid the uuid 295 * @param groupId the group ID 296 * @param retrieveFromCache whether to retrieve from the finder cache 297 * @return the matching cal event, or <code>null</code> if a matching cal event could not be found 298 */ 299 public static CalEvent fetchByUUID_G(java.lang.String uuid, long groupId, 300 boolean retrieveFromCache) { 301 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 302 } 303 304 /** 305 * Removes the cal event where uuid = ? and groupId = ? from the database. 306 * 307 * @param uuid the uuid 308 * @param groupId the group ID 309 * @return the cal event that was removed 310 */ 311 public static CalEvent removeByUUID_G(java.lang.String uuid, long groupId) 312 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 313 return getPersistence().removeByUUID_G(uuid, groupId); 314 } 315 316 /** 317 * Returns the number of cal events where uuid = ? and groupId = ?. 318 * 319 * @param uuid the uuid 320 * @param groupId the group ID 321 * @return the number of matching cal events 322 */ 323 public static int countByUUID_G(java.lang.String uuid, long groupId) { 324 return getPersistence().countByUUID_G(uuid, groupId); 325 } 326 327 /** 328 * Returns all the cal events where uuid = ? and companyId = ?. 329 * 330 * @param uuid the uuid 331 * @param companyId the company ID 332 * @return the matching cal events 333 */ 334 public static List<CalEvent> findByUuid_C(java.lang.String uuid, 335 long companyId) { 336 return getPersistence().findByUuid_C(uuid, companyId); 337 } 338 339 /** 340 * Returns a range of all the cal events where uuid = ? and companyId = ?. 341 * 342 * <p> 343 * 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 CalEventModelImpl}. 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. 344 * </p> 345 * 346 * @param uuid the uuid 347 * @param companyId the company ID 348 * @param start the lower bound of the range of cal events 349 * @param end the upper bound of the range of cal events (not inclusive) 350 * @return the range of matching cal events 351 */ 352 public static List<CalEvent> findByUuid_C(java.lang.String uuid, 353 long companyId, int start, int end) { 354 return getPersistence().findByUuid_C(uuid, companyId, start, end); 355 } 356 357 /** 358 * Returns an ordered range of all the cal events where uuid = ? and companyId = ?. 359 * 360 * <p> 361 * 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 CalEventModelImpl}. 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. 362 * </p> 363 * 364 * @param uuid the uuid 365 * @param companyId the company ID 366 * @param start the lower bound of the range of cal events 367 * @param end the upper bound of the range of cal events (not inclusive) 368 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 369 * @return the ordered range of matching cal events 370 */ 371 public static List<CalEvent> findByUuid_C(java.lang.String uuid, 372 long companyId, int start, int end, 373 OrderByComparator<CalEvent> orderByComparator) { 374 return getPersistence() 375 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 376 } 377 378 /** 379 * Returns an ordered range of all the cal events where uuid = ? and companyId = ?. 380 * 381 * <p> 382 * 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 CalEventModelImpl}. 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. 383 * </p> 384 * 385 * @param uuid the uuid 386 * @param companyId the company ID 387 * @param start the lower bound of the range of cal events 388 * @param end the upper bound of the range of cal events (not inclusive) 389 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 390 * @param retrieveFromCache whether to retrieve from the finder cache 391 * @return the ordered range of matching cal events 392 */ 393 public static List<CalEvent> findByUuid_C(java.lang.String uuid, 394 long companyId, int start, int end, 395 OrderByComparator<CalEvent> orderByComparator, boolean retrieveFromCache) { 396 return getPersistence() 397 .findByUuid_C(uuid, companyId, start, end, 398 orderByComparator, retrieveFromCache); 399 } 400 401 /** 402 * Returns the first cal event in the ordered set where uuid = ? and companyId = ?. 403 * 404 * @param uuid the uuid 405 * @param companyId the company ID 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the first matching cal event 408 * @throws NoSuchEventException if a matching cal event could not be found 409 */ 410 public static CalEvent findByUuid_C_First(java.lang.String uuid, 411 long companyId, OrderByComparator<CalEvent> orderByComparator) 412 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 413 return getPersistence() 414 .findByUuid_C_First(uuid, companyId, orderByComparator); 415 } 416 417 /** 418 * Returns the first cal event in the ordered set where uuid = ? and companyId = ?. 419 * 420 * @param uuid the uuid 421 * @param companyId the company ID 422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 423 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 424 */ 425 public static CalEvent fetchByUuid_C_First(java.lang.String uuid, 426 long companyId, OrderByComparator<CalEvent> orderByComparator) { 427 return getPersistence() 428 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 429 } 430 431 /** 432 * Returns the last cal event in the ordered set where uuid = ? and companyId = ?. 433 * 434 * @param uuid the uuid 435 * @param companyId the company ID 436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 437 * @return the last matching cal event 438 * @throws NoSuchEventException if a matching cal event could not be found 439 */ 440 public static CalEvent findByUuid_C_Last(java.lang.String uuid, 441 long companyId, OrderByComparator<CalEvent> orderByComparator) 442 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 443 return getPersistence() 444 .findByUuid_C_Last(uuid, companyId, orderByComparator); 445 } 446 447 /** 448 * Returns the last cal event in the ordered set where uuid = ? and companyId = ?. 449 * 450 * @param uuid the uuid 451 * @param companyId the company ID 452 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 453 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 454 */ 455 public static CalEvent fetchByUuid_C_Last(java.lang.String uuid, 456 long companyId, OrderByComparator<CalEvent> orderByComparator) { 457 return getPersistence() 458 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 459 } 460 461 /** 462 * Returns the cal events before and after the current cal event in the ordered set where uuid = ? and companyId = ?. 463 * 464 * @param eventId the primary key of the current cal event 465 * @param uuid the uuid 466 * @param companyId the company ID 467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 468 * @return the previous, current, and next cal event 469 * @throws NoSuchEventException if a cal event with the primary key could not be found 470 */ 471 public static CalEvent[] findByUuid_C_PrevAndNext(long eventId, 472 java.lang.String uuid, long companyId, 473 OrderByComparator<CalEvent> orderByComparator) 474 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 475 return getPersistence() 476 .findByUuid_C_PrevAndNext(eventId, uuid, companyId, 477 orderByComparator); 478 } 479 480 /** 481 * Removes all the cal events where uuid = ? and companyId = ? from the database. 482 * 483 * @param uuid the uuid 484 * @param companyId the company ID 485 */ 486 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 487 getPersistence().removeByUuid_C(uuid, companyId); 488 } 489 490 /** 491 * Returns the number of cal events where uuid = ? and companyId = ?. 492 * 493 * @param uuid the uuid 494 * @param companyId the company ID 495 * @return the number of matching cal events 496 */ 497 public static int countByUuid_C(java.lang.String uuid, long companyId) { 498 return getPersistence().countByUuid_C(uuid, companyId); 499 } 500 501 /** 502 * Returns all the cal events where groupId = ?. 503 * 504 * @param groupId the group ID 505 * @return the matching cal events 506 */ 507 public static List<CalEvent> findByGroupId(long groupId) { 508 return getPersistence().findByGroupId(groupId); 509 } 510 511 /** 512 * Returns a range of all the cal events where groupId = ?. 513 * 514 * <p> 515 * 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 CalEventModelImpl}. 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. 516 * </p> 517 * 518 * @param groupId the group ID 519 * @param start the lower bound of the range of cal events 520 * @param end the upper bound of the range of cal events (not inclusive) 521 * @return the range of matching cal events 522 */ 523 public static List<CalEvent> findByGroupId(long groupId, int start, int end) { 524 return getPersistence().findByGroupId(groupId, start, end); 525 } 526 527 /** 528 * Returns an ordered range of all the cal events where groupId = ?. 529 * 530 * <p> 531 * 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 CalEventModelImpl}. 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. 532 * </p> 533 * 534 * @param groupId the group ID 535 * @param start the lower bound of the range of cal events 536 * @param end the upper bound of the range of cal events (not inclusive) 537 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 538 * @return the ordered range of matching cal events 539 */ 540 public static List<CalEvent> findByGroupId(long groupId, int start, 541 int end, OrderByComparator<CalEvent> orderByComparator) { 542 return getPersistence() 543 .findByGroupId(groupId, start, end, orderByComparator); 544 } 545 546 /** 547 * Returns an ordered range of all the cal events where groupId = ?. 548 * 549 * <p> 550 * 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 CalEventModelImpl}. 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. 551 * </p> 552 * 553 * @param groupId the group ID 554 * @param start the lower bound of the range of cal events 555 * @param end the upper bound of the range of cal events (not inclusive) 556 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 557 * @param retrieveFromCache whether to retrieve from the finder cache 558 * @return the ordered range of matching cal events 559 */ 560 public static List<CalEvent> findByGroupId(long groupId, int start, 561 int end, OrderByComparator<CalEvent> orderByComparator, 562 boolean retrieveFromCache) { 563 return getPersistence() 564 .findByGroupId(groupId, start, end, orderByComparator, 565 retrieveFromCache); 566 } 567 568 /** 569 * Returns the first cal event in the ordered set where groupId = ?. 570 * 571 * @param groupId the group ID 572 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 573 * @return the first matching cal event 574 * @throws NoSuchEventException if a matching cal event could not be found 575 */ 576 public static CalEvent findByGroupId_First(long groupId, 577 OrderByComparator<CalEvent> orderByComparator) 578 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 579 return getPersistence().findByGroupId_First(groupId, orderByComparator); 580 } 581 582 /** 583 * Returns the first cal event in the ordered set where groupId = ?. 584 * 585 * @param groupId the group ID 586 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 587 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 588 */ 589 public static CalEvent fetchByGroupId_First(long groupId, 590 OrderByComparator<CalEvent> orderByComparator) { 591 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 592 } 593 594 /** 595 * Returns the last cal event in the ordered set where groupId = ?. 596 * 597 * @param groupId the group ID 598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 599 * @return the last matching cal event 600 * @throws NoSuchEventException if a matching cal event could not be found 601 */ 602 public static CalEvent findByGroupId_Last(long groupId, 603 OrderByComparator<CalEvent> orderByComparator) 604 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 605 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 606 } 607 608 /** 609 * Returns the last cal event in the ordered set where groupId = ?. 610 * 611 * @param groupId the group ID 612 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 613 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 614 */ 615 public static CalEvent fetchByGroupId_Last(long groupId, 616 OrderByComparator<CalEvent> orderByComparator) { 617 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 618 } 619 620 /** 621 * Returns the cal events before and after the current cal event in the ordered set where groupId = ?. 622 * 623 * @param eventId the primary key of the current cal event 624 * @param groupId the group ID 625 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 626 * @return the previous, current, and next cal event 627 * @throws NoSuchEventException if a cal event with the primary key could not be found 628 */ 629 public static CalEvent[] findByGroupId_PrevAndNext(long eventId, 630 long groupId, OrderByComparator<CalEvent> orderByComparator) 631 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 632 return getPersistence() 633 .findByGroupId_PrevAndNext(eventId, groupId, 634 orderByComparator); 635 } 636 637 /** 638 * Removes all the cal events where groupId = ? from the database. 639 * 640 * @param groupId the group ID 641 */ 642 public static void removeByGroupId(long groupId) { 643 getPersistence().removeByGroupId(groupId); 644 } 645 646 /** 647 * Returns the number of cal events where groupId = ?. 648 * 649 * @param groupId the group ID 650 * @return the number of matching cal events 651 */ 652 public static int countByGroupId(long groupId) { 653 return getPersistence().countByGroupId(groupId); 654 } 655 656 /** 657 * Returns all the cal events where companyId = ?. 658 * 659 * @param companyId the company ID 660 * @return the matching cal events 661 */ 662 public static List<CalEvent> findByCompanyId(long companyId) { 663 return getPersistence().findByCompanyId(companyId); 664 } 665 666 /** 667 * Returns a range of all the cal events where companyId = ?. 668 * 669 * <p> 670 * 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 CalEventModelImpl}. 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. 671 * </p> 672 * 673 * @param companyId the company ID 674 * @param start the lower bound of the range of cal events 675 * @param end the upper bound of the range of cal events (not inclusive) 676 * @return the range of matching cal events 677 */ 678 public static List<CalEvent> findByCompanyId(long companyId, int start, 679 int end) { 680 return getPersistence().findByCompanyId(companyId, start, end); 681 } 682 683 /** 684 * Returns an ordered range of all the cal events where companyId = ?. 685 * 686 * <p> 687 * 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 CalEventModelImpl}. 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. 688 * </p> 689 * 690 * @param companyId the company ID 691 * @param start the lower bound of the range of cal events 692 * @param end the upper bound of the range of cal events (not inclusive) 693 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 694 * @return the ordered range of matching cal events 695 */ 696 public static List<CalEvent> findByCompanyId(long companyId, int start, 697 int end, OrderByComparator<CalEvent> orderByComparator) { 698 return getPersistence() 699 .findByCompanyId(companyId, start, end, orderByComparator); 700 } 701 702 /** 703 * Returns an ordered range of all the cal events where companyId = ?. 704 * 705 * <p> 706 * 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 CalEventModelImpl}. 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. 707 * </p> 708 * 709 * @param companyId the company ID 710 * @param start the lower bound of the range of cal events 711 * @param end the upper bound of the range of cal events (not inclusive) 712 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 713 * @param retrieveFromCache whether to retrieve from the finder cache 714 * @return the ordered range of matching cal events 715 */ 716 public static List<CalEvent> findByCompanyId(long companyId, int start, 717 int end, OrderByComparator<CalEvent> orderByComparator, 718 boolean retrieveFromCache) { 719 return getPersistence() 720 .findByCompanyId(companyId, start, end, orderByComparator, 721 retrieveFromCache); 722 } 723 724 /** 725 * Returns the first cal event in the ordered set where companyId = ?. 726 * 727 * @param companyId the company ID 728 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 729 * @return the first matching cal event 730 * @throws NoSuchEventException if a matching cal event could not be found 731 */ 732 public static CalEvent findByCompanyId_First(long companyId, 733 OrderByComparator<CalEvent> orderByComparator) 734 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 735 return getPersistence() 736 .findByCompanyId_First(companyId, orderByComparator); 737 } 738 739 /** 740 * Returns the first cal event in the ordered set where companyId = ?. 741 * 742 * @param companyId the company ID 743 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 744 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 745 */ 746 public static CalEvent fetchByCompanyId_First(long companyId, 747 OrderByComparator<CalEvent> orderByComparator) { 748 return getPersistence() 749 .fetchByCompanyId_First(companyId, orderByComparator); 750 } 751 752 /** 753 * Returns the last cal event in the ordered set where companyId = ?. 754 * 755 * @param companyId the company ID 756 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 757 * @return the last matching cal event 758 * @throws NoSuchEventException if a matching cal event could not be found 759 */ 760 public static CalEvent findByCompanyId_Last(long companyId, 761 OrderByComparator<CalEvent> orderByComparator) 762 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 763 return getPersistence() 764 .findByCompanyId_Last(companyId, orderByComparator); 765 } 766 767 /** 768 * Returns the last cal event in the ordered set where companyId = ?. 769 * 770 * @param companyId the company ID 771 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 772 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 773 */ 774 public static CalEvent fetchByCompanyId_Last(long companyId, 775 OrderByComparator<CalEvent> orderByComparator) { 776 return getPersistence() 777 .fetchByCompanyId_Last(companyId, orderByComparator); 778 } 779 780 /** 781 * Returns the cal events before and after the current cal event in the ordered set where companyId = ?. 782 * 783 * @param eventId the primary key of the current cal event 784 * @param companyId the company ID 785 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 786 * @return the previous, current, and next cal event 787 * @throws NoSuchEventException if a cal event with the primary key could not be found 788 */ 789 public static CalEvent[] findByCompanyId_PrevAndNext(long eventId, 790 long companyId, OrderByComparator<CalEvent> orderByComparator) 791 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 792 return getPersistence() 793 .findByCompanyId_PrevAndNext(eventId, companyId, 794 orderByComparator); 795 } 796 797 /** 798 * Removes all the cal events where companyId = ? from the database. 799 * 800 * @param companyId the company ID 801 */ 802 public static void removeByCompanyId(long companyId) { 803 getPersistence().removeByCompanyId(companyId); 804 } 805 806 /** 807 * Returns the number of cal events where companyId = ?. 808 * 809 * @param companyId the company ID 810 * @return the number of matching cal events 811 */ 812 public static int countByCompanyId(long companyId) { 813 return getPersistence().countByCompanyId(companyId); 814 } 815 816 /** 817 * Returns all the cal events where remindBy ≠ ?. 818 * 819 * @param remindBy the remind by 820 * @return the matching cal events 821 */ 822 public static List<CalEvent> findByNotRemindBy(int remindBy) { 823 return getPersistence().findByNotRemindBy(remindBy); 824 } 825 826 /** 827 * Returns a range of all the cal events where remindBy ≠ ?. 828 * 829 * <p> 830 * 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 CalEventModelImpl}. 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. 831 * </p> 832 * 833 * @param remindBy the remind by 834 * @param start the lower bound of the range of cal events 835 * @param end the upper bound of the range of cal events (not inclusive) 836 * @return the range of matching cal events 837 */ 838 public static List<CalEvent> findByNotRemindBy(int remindBy, int start, 839 int end) { 840 return getPersistence().findByNotRemindBy(remindBy, start, end); 841 } 842 843 /** 844 * Returns an ordered range of all the cal events where remindBy ≠ ?. 845 * 846 * <p> 847 * 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 CalEventModelImpl}. 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. 848 * </p> 849 * 850 * @param remindBy the remind by 851 * @param start the lower bound of the range of cal events 852 * @param end the upper bound of the range of cal events (not inclusive) 853 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 854 * @return the ordered range of matching cal events 855 */ 856 public static List<CalEvent> findByNotRemindBy(int remindBy, int start, 857 int end, OrderByComparator<CalEvent> orderByComparator) { 858 return getPersistence() 859 .findByNotRemindBy(remindBy, start, end, orderByComparator); 860 } 861 862 /** 863 * Returns an ordered range of all the cal events where remindBy ≠ ?. 864 * 865 * <p> 866 * 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 CalEventModelImpl}. 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. 867 * </p> 868 * 869 * @param remindBy the remind by 870 * @param start the lower bound of the range of cal events 871 * @param end the upper bound of the range of cal events (not inclusive) 872 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 873 * @param retrieveFromCache whether to retrieve from the finder cache 874 * @return the ordered range of matching cal events 875 */ 876 public static List<CalEvent> findByNotRemindBy(int remindBy, int start, 877 int end, OrderByComparator<CalEvent> orderByComparator, 878 boolean retrieveFromCache) { 879 return getPersistence() 880 .findByNotRemindBy(remindBy, start, end, orderByComparator, 881 retrieveFromCache); 882 } 883 884 /** 885 * Returns the first cal event in the ordered set where remindBy ≠ ?. 886 * 887 * @param remindBy the remind by 888 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 889 * @return the first matching cal event 890 * @throws NoSuchEventException if a matching cal event could not be found 891 */ 892 public static CalEvent findByNotRemindBy_First(int remindBy, 893 OrderByComparator<CalEvent> orderByComparator) 894 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 895 return getPersistence() 896 .findByNotRemindBy_First(remindBy, orderByComparator); 897 } 898 899 /** 900 * Returns the first cal event in the ordered set where remindBy ≠ ?. 901 * 902 * @param remindBy the remind by 903 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 904 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 905 */ 906 public static CalEvent fetchByNotRemindBy_First(int remindBy, 907 OrderByComparator<CalEvent> orderByComparator) { 908 return getPersistence() 909 .fetchByNotRemindBy_First(remindBy, orderByComparator); 910 } 911 912 /** 913 * Returns the last cal event in the ordered set where remindBy ≠ ?. 914 * 915 * @param remindBy the remind by 916 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 917 * @return the last matching cal event 918 * @throws NoSuchEventException if a matching cal event could not be found 919 */ 920 public static CalEvent findByNotRemindBy_Last(int remindBy, 921 OrderByComparator<CalEvent> orderByComparator) 922 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 923 return getPersistence() 924 .findByNotRemindBy_Last(remindBy, orderByComparator); 925 } 926 927 /** 928 * Returns the last cal event in the ordered set where remindBy ≠ ?. 929 * 930 * @param remindBy the remind by 931 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 932 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 933 */ 934 public static CalEvent fetchByNotRemindBy_Last(int remindBy, 935 OrderByComparator<CalEvent> orderByComparator) { 936 return getPersistence() 937 .fetchByNotRemindBy_Last(remindBy, orderByComparator); 938 } 939 940 /** 941 * Returns the cal events before and after the current cal event in the ordered set where remindBy ≠ ?. 942 * 943 * @param eventId the primary key of the current cal event 944 * @param remindBy the remind by 945 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 946 * @return the previous, current, and next cal event 947 * @throws NoSuchEventException if a cal event with the primary key could not be found 948 */ 949 public static CalEvent[] findByNotRemindBy_PrevAndNext(long eventId, 950 int remindBy, OrderByComparator<CalEvent> orderByComparator) 951 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 952 return getPersistence() 953 .findByNotRemindBy_PrevAndNext(eventId, remindBy, 954 orderByComparator); 955 } 956 957 /** 958 * Removes all the cal events where remindBy ≠ ? from the database. 959 * 960 * @param remindBy the remind by 961 */ 962 public static void removeByNotRemindBy(int remindBy) { 963 getPersistence().removeByNotRemindBy(remindBy); 964 } 965 966 /** 967 * Returns the number of cal events where remindBy ≠ ?. 968 * 969 * @param remindBy the remind by 970 * @return the number of matching cal events 971 */ 972 public static int countByNotRemindBy(int remindBy) { 973 return getPersistence().countByNotRemindBy(remindBy); 974 } 975 976 /** 977 * Returns all the cal events where groupId = ? and type = ?. 978 * 979 * @param groupId the group ID 980 * @param type the type 981 * @return the matching cal events 982 */ 983 public static List<CalEvent> findByG_T(long groupId, java.lang.String type) { 984 return getPersistence().findByG_T(groupId, type); 985 } 986 987 /** 988 * Returns a range of all the cal events where groupId = ? and type = ?. 989 * 990 * <p> 991 * 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 CalEventModelImpl}. 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. 992 * </p> 993 * 994 * @param groupId the group ID 995 * @param type the type 996 * @param start the lower bound of the range of cal events 997 * @param end the upper bound of the range of cal events (not inclusive) 998 * @return the range of matching cal events 999 */ 1000 public static List<CalEvent> findByG_T(long groupId, java.lang.String type, 1001 int start, int end) { 1002 return getPersistence().findByG_T(groupId, type, start, end); 1003 } 1004 1005 /** 1006 * Returns an ordered range of all the cal events where groupId = ? and type = ?. 1007 * 1008 * <p> 1009 * 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 CalEventModelImpl}. 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. 1010 * </p> 1011 * 1012 * @param groupId the group ID 1013 * @param type the type 1014 * @param start the lower bound of the range of cal events 1015 * @param end the upper bound of the range of cal events (not inclusive) 1016 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1017 * @return the ordered range of matching cal events 1018 */ 1019 public static List<CalEvent> findByG_T(long groupId, java.lang.String type, 1020 int start, int end, OrderByComparator<CalEvent> orderByComparator) { 1021 return getPersistence() 1022 .findByG_T(groupId, type, start, end, orderByComparator); 1023 } 1024 1025 /** 1026 * Returns an ordered range of all the cal events where groupId = ? and type = ?. 1027 * 1028 * <p> 1029 * 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 CalEventModelImpl}. 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. 1030 * </p> 1031 * 1032 * @param groupId the group ID 1033 * @param type the type 1034 * @param start the lower bound of the range of cal events 1035 * @param end the upper bound of the range of cal events (not inclusive) 1036 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1037 * @param retrieveFromCache whether to retrieve from the finder cache 1038 * @return the ordered range of matching cal events 1039 */ 1040 public static List<CalEvent> findByG_T(long groupId, java.lang.String type, 1041 int start, int end, OrderByComparator<CalEvent> orderByComparator, 1042 boolean retrieveFromCache) { 1043 return getPersistence() 1044 .findByG_T(groupId, type, start, end, orderByComparator, 1045 retrieveFromCache); 1046 } 1047 1048 /** 1049 * Returns the first cal event in the ordered set where groupId = ? and type = ?. 1050 * 1051 * @param groupId the group ID 1052 * @param type the type 1053 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1054 * @return the first matching cal event 1055 * @throws NoSuchEventException if a matching cal event could not be found 1056 */ 1057 public static CalEvent findByG_T_First(long groupId, java.lang.String type, 1058 OrderByComparator<CalEvent> orderByComparator) 1059 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1060 return getPersistence().findByG_T_First(groupId, type, orderByComparator); 1061 } 1062 1063 /** 1064 * Returns the first cal event in the ordered set where groupId = ? and type = ?. 1065 * 1066 * @param groupId the group ID 1067 * @param type the type 1068 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1069 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 1070 */ 1071 public static CalEvent fetchByG_T_First(long groupId, 1072 java.lang.String type, OrderByComparator<CalEvent> orderByComparator) { 1073 return getPersistence() 1074 .fetchByG_T_First(groupId, type, orderByComparator); 1075 } 1076 1077 /** 1078 * Returns the last cal event in the ordered set where groupId = ? and type = ?. 1079 * 1080 * @param groupId the group ID 1081 * @param type the type 1082 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1083 * @return the last matching cal event 1084 * @throws NoSuchEventException if a matching cal event could not be found 1085 */ 1086 public static CalEvent findByG_T_Last(long groupId, java.lang.String type, 1087 OrderByComparator<CalEvent> orderByComparator) 1088 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1089 return getPersistence().findByG_T_Last(groupId, type, orderByComparator); 1090 } 1091 1092 /** 1093 * Returns the last cal event in the ordered set where groupId = ? and type = ?. 1094 * 1095 * @param groupId the group ID 1096 * @param type the type 1097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1098 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 1099 */ 1100 public static CalEvent fetchByG_T_Last(long groupId, java.lang.String type, 1101 OrderByComparator<CalEvent> orderByComparator) { 1102 return getPersistence().fetchByG_T_Last(groupId, type, orderByComparator); 1103 } 1104 1105 /** 1106 * Returns the cal events before and after the current cal event in the ordered set where groupId = ? and type = ?. 1107 * 1108 * @param eventId the primary key of the current cal event 1109 * @param groupId the group ID 1110 * @param type the type 1111 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1112 * @return the previous, current, and next cal event 1113 * @throws NoSuchEventException if a cal event with the primary key could not be found 1114 */ 1115 public static CalEvent[] findByG_T_PrevAndNext(long eventId, long groupId, 1116 java.lang.String type, OrderByComparator<CalEvent> orderByComparator) 1117 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1118 return getPersistence() 1119 .findByG_T_PrevAndNext(eventId, groupId, type, 1120 orderByComparator); 1121 } 1122 1123 /** 1124 * Returns all the cal events where groupId = ? and type = any ?. 1125 * 1126 * <p> 1127 * 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 CalEventModelImpl}. 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. 1128 * </p> 1129 * 1130 * @param groupId the group ID 1131 * @param types the types 1132 * @return the matching cal events 1133 */ 1134 public static List<CalEvent> findByG_T(long groupId, 1135 java.lang.String[] types) { 1136 return getPersistence().findByG_T(groupId, types); 1137 } 1138 1139 /** 1140 * Returns a range of all the cal events where groupId = ? and type = any ?. 1141 * 1142 * <p> 1143 * 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 CalEventModelImpl}. 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. 1144 * </p> 1145 * 1146 * @param groupId the group ID 1147 * @param types the types 1148 * @param start the lower bound of the range of cal events 1149 * @param end the upper bound of the range of cal events (not inclusive) 1150 * @return the range of matching cal events 1151 */ 1152 public static List<CalEvent> findByG_T(long groupId, 1153 java.lang.String[] types, int start, int end) { 1154 return getPersistence().findByG_T(groupId, types, start, end); 1155 } 1156 1157 /** 1158 * Returns an ordered range of all the cal events where groupId = ? and type = any ?. 1159 * 1160 * <p> 1161 * 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 CalEventModelImpl}. 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. 1162 * </p> 1163 * 1164 * @param groupId the group ID 1165 * @param types the types 1166 * @param start the lower bound of the range of cal events 1167 * @param end the upper bound of the range of cal events (not inclusive) 1168 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1169 * @return the ordered range of matching cal events 1170 */ 1171 public static List<CalEvent> findByG_T(long groupId, 1172 java.lang.String[] types, int start, int end, 1173 OrderByComparator<CalEvent> orderByComparator) { 1174 return getPersistence() 1175 .findByG_T(groupId, types, start, end, orderByComparator); 1176 } 1177 1178 /** 1179 * Returns an ordered range of all the cal events where groupId = ? and type = ?, optionally using the finder cache. 1180 * 1181 * <p> 1182 * 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 CalEventModelImpl}. 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. 1183 * </p> 1184 * 1185 * @param groupId the group ID 1186 * @param type the type 1187 * @param start the lower bound of the range of cal events 1188 * @param end the upper bound of the range of cal events (not inclusive) 1189 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1190 * @param retrieveFromCache whether to retrieve from the finder cache 1191 * @return the ordered range of matching cal events 1192 */ 1193 public static List<CalEvent> findByG_T(long groupId, 1194 java.lang.String[] types, int start, int end, 1195 OrderByComparator<CalEvent> orderByComparator, boolean retrieveFromCache) { 1196 return getPersistence() 1197 .findByG_T(groupId, types, start, end, orderByComparator, 1198 retrieveFromCache); 1199 } 1200 1201 /** 1202 * Removes all the cal events where groupId = ? and type = ? from the database. 1203 * 1204 * @param groupId the group ID 1205 * @param type the type 1206 */ 1207 public static void removeByG_T(long groupId, java.lang.String type) { 1208 getPersistence().removeByG_T(groupId, type); 1209 } 1210 1211 /** 1212 * Returns the number of cal events where groupId = ? and type = ?. 1213 * 1214 * @param groupId the group ID 1215 * @param type the type 1216 * @return the number of matching cal events 1217 */ 1218 public static int countByG_T(long groupId, java.lang.String type) { 1219 return getPersistence().countByG_T(groupId, type); 1220 } 1221 1222 /** 1223 * Returns the number of cal events where groupId = ? and type = any ?. 1224 * 1225 * @param groupId the group ID 1226 * @param types the types 1227 * @return the number of matching cal events 1228 */ 1229 public static int countByG_T(long groupId, java.lang.String[] types) { 1230 return getPersistence().countByG_T(groupId, types); 1231 } 1232 1233 /** 1234 * Returns all the cal events where groupId = ? and repeating = ?. 1235 * 1236 * @param groupId the group ID 1237 * @param repeating the repeating 1238 * @return the matching cal events 1239 */ 1240 public static List<CalEvent> findByG_R(long groupId, boolean repeating) { 1241 return getPersistence().findByG_R(groupId, repeating); 1242 } 1243 1244 /** 1245 * Returns a range of all the cal events where groupId = ? and repeating = ?. 1246 * 1247 * <p> 1248 * 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 CalEventModelImpl}. 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. 1249 * </p> 1250 * 1251 * @param groupId the group ID 1252 * @param repeating the repeating 1253 * @param start the lower bound of the range of cal events 1254 * @param end the upper bound of the range of cal events (not inclusive) 1255 * @return the range of matching cal events 1256 */ 1257 public static List<CalEvent> findByG_R(long groupId, boolean repeating, 1258 int start, int end) { 1259 return getPersistence().findByG_R(groupId, repeating, start, end); 1260 } 1261 1262 /** 1263 * Returns an ordered range of all the cal events where groupId = ? and repeating = ?. 1264 * 1265 * <p> 1266 * 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 CalEventModelImpl}. 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. 1267 * </p> 1268 * 1269 * @param groupId the group ID 1270 * @param repeating the repeating 1271 * @param start the lower bound of the range of cal events 1272 * @param end the upper bound of the range of cal events (not inclusive) 1273 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1274 * @return the ordered range of matching cal events 1275 */ 1276 public static List<CalEvent> findByG_R(long groupId, boolean repeating, 1277 int start, int end, OrderByComparator<CalEvent> orderByComparator) { 1278 return getPersistence() 1279 .findByG_R(groupId, repeating, start, end, orderByComparator); 1280 } 1281 1282 /** 1283 * Returns an ordered range of all the cal events where groupId = ? and repeating = ?. 1284 * 1285 * <p> 1286 * 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 CalEventModelImpl}. 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. 1287 * </p> 1288 * 1289 * @param groupId the group ID 1290 * @param repeating the repeating 1291 * @param start the lower bound of the range of cal events 1292 * @param end the upper bound of the range of cal events (not inclusive) 1293 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1294 * @param retrieveFromCache whether to retrieve from the finder cache 1295 * @return the ordered range of matching cal events 1296 */ 1297 public static List<CalEvent> findByG_R(long groupId, boolean repeating, 1298 int start, int end, OrderByComparator<CalEvent> orderByComparator, 1299 boolean retrieveFromCache) { 1300 return getPersistence() 1301 .findByG_R(groupId, repeating, start, end, 1302 orderByComparator, retrieveFromCache); 1303 } 1304 1305 /** 1306 * Returns the first cal event in the ordered set where groupId = ? and repeating = ?. 1307 * 1308 * @param groupId the group ID 1309 * @param repeating the repeating 1310 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1311 * @return the first matching cal event 1312 * @throws NoSuchEventException if a matching cal event could not be found 1313 */ 1314 public static CalEvent findByG_R_First(long groupId, boolean repeating, 1315 OrderByComparator<CalEvent> orderByComparator) 1316 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1317 return getPersistence() 1318 .findByG_R_First(groupId, repeating, orderByComparator); 1319 } 1320 1321 /** 1322 * Returns the first cal event in the ordered set where groupId = ? and repeating = ?. 1323 * 1324 * @param groupId the group ID 1325 * @param repeating the repeating 1326 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1327 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 1328 */ 1329 public static CalEvent fetchByG_R_First(long groupId, boolean repeating, 1330 OrderByComparator<CalEvent> orderByComparator) { 1331 return getPersistence() 1332 .fetchByG_R_First(groupId, repeating, orderByComparator); 1333 } 1334 1335 /** 1336 * Returns the last cal event in the ordered set where groupId = ? and repeating = ?. 1337 * 1338 * @param groupId the group ID 1339 * @param repeating the repeating 1340 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1341 * @return the last matching cal event 1342 * @throws NoSuchEventException if a matching cal event could not be found 1343 */ 1344 public static CalEvent findByG_R_Last(long groupId, boolean repeating, 1345 OrderByComparator<CalEvent> orderByComparator) 1346 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1347 return getPersistence() 1348 .findByG_R_Last(groupId, repeating, orderByComparator); 1349 } 1350 1351 /** 1352 * Returns the last cal event in the ordered set where groupId = ? and repeating = ?. 1353 * 1354 * @param groupId the group ID 1355 * @param repeating the repeating 1356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1357 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 1358 */ 1359 public static CalEvent fetchByG_R_Last(long groupId, boolean repeating, 1360 OrderByComparator<CalEvent> orderByComparator) { 1361 return getPersistence() 1362 .fetchByG_R_Last(groupId, repeating, orderByComparator); 1363 } 1364 1365 /** 1366 * Returns the cal events before and after the current cal event in the ordered set where groupId = ? and repeating = ?. 1367 * 1368 * @param eventId the primary key of the current cal event 1369 * @param groupId the group ID 1370 * @param repeating the repeating 1371 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1372 * @return the previous, current, and next cal event 1373 * @throws NoSuchEventException if a cal event with the primary key could not be found 1374 */ 1375 public static CalEvent[] findByG_R_PrevAndNext(long eventId, long groupId, 1376 boolean repeating, OrderByComparator<CalEvent> orderByComparator) 1377 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1378 return getPersistence() 1379 .findByG_R_PrevAndNext(eventId, groupId, repeating, 1380 orderByComparator); 1381 } 1382 1383 /** 1384 * Removes all the cal events where groupId = ? and repeating = ? from the database. 1385 * 1386 * @param groupId the group ID 1387 * @param repeating the repeating 1388 */ 1389 public static void removeByG_R(long groupId, boolean repeating) { 1390 getPersistence().removeByG_R(groupId, repeating); 1391 } 1392 1393 /** 1394 * Returns the number of cal events where groupId = ? and repeating = ?. 1395 * 1396 * @param groupId the group ID 1397 * @param repeating the repeating 1398 * @return the number of matching cal events 1399 */ 1400 public static int countByG_R(long groupId, boolean repeating) { 1401 return getPersistence().countByG_R(groupId, repeating); 1402 } 1403 1404 /** 1405 * Returns all the cal events where groupId = ? and type = ? and repeating = ?. 1406 * 1407 * @param groupId the group ID 1408 * @param type the type 1409 * @param repeating the repeating 1410 * @return the matching cal events 1411 */ 1412 public static List<CalEvent> findByG_T_R(long groupId, 1413 java.lang.String type, boolean repeating) { 1414 return getPersistence().findByG_T_R(groupId, type, repeating); 1415 } 1416 1417 /** 1418 * Returns a range of all the cal events where groupId = ? and type = ? and repeating = ?. 1419 * 1420 * <p> 1421 * 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 CalEventModelImpl}. 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. 1422 * </p> 1423 * 1424 * @param groupId the group ID 1425 * @param type the type 1426 * @param repeating the repeating 1427 * @param start the lower bound of the range of cal events 1428 * @param end the upper bound of the range of cal events (not inclusive) 1429 * @return the range of matching cal events 1430 */ 1431 public static List<CalEvent> findByG_T_R(long groupId, 1432 java.lang.String type, boolean repeating, int start, int end) { 1433 return getPersistence().findByG_T_R(groupId, type, repeating, start, end); 1434 } 1435 1436 /** 1437 * Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?. 1438 * 1439 * <p> 1440 * 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 CalEventModelImpl}. 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. 1441 * </p> 1442 * 1443 * @param groupId the group ID 1444 * @param type the type 1445 * @param repeating the repeating 1446 * @param start the lower bound of the range of cal events 1447 * @param end the upper bound of the range of cal events (not inclusive) 1448 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1449 * @return the ordered range of matching cal events 1450 */ 1451 public static List<CalEvent> findByG_T_R(long groupId, 1452 java.lang.String type, boolean repeating, int start, int end, 1453 OrderByComparator<CalEvent> orderByComparator) { 1454 return getPersistence() 1455 .findByG_T_R(groupId, type, repeating, start, end, 1456 orderByComparator); 1457 } 1458 1459 /** 1460 * Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?. 1461 * 1462 * <p> 1463 * 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 CalEventModelImpl}. 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. 1464 * </p> 1465 * 1466 * @param groupId the group ID 1467 * @param type the type 1468 * @param repeating the repeating 1469 * @param start the lower bound of the range of cal events 1470 * @param end the upper bound of the range of cal events (not inclusive) 1471 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1472 * @param retrieveFromCache whether to retrieve from the finder cache 1473 * @return the ordered range of matching cal events 1474 */ 1475 public static List<CalEvent> findByG_T_R(long groupId, 1476 java.lang.String type, boolean repeating, int start, int end, 1477 OrderByComparator<CalEvent> orderByComparator, boolean retrieveFromCache) { 1478 return getPersistence() 1479 .findByG_T_R(groupId, type, repeating, start, end, 1480 orderByComparator, retrieveFromCache); 1481 } 1482 1483 /** 1484 * Returns the first cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1485 * 1486 * @param groupId the group ID 1487 * @param type the type 1488 * @param repeating the repeating 1489 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1490 * @return the first matching cal event 1491 * @throws NoSuchEventException if a matching cal event could not be found 1492 */ 1493 public static CalEvent findByG_T_R_First(long groupId, 1494 java.lang.String type, boolean repeating, 1495 OrderByComparator<CalEvent> orderByComparator) 1496 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1497 return getPersistence() 1498 .findByG_T_R_First(groupId, type, repeating, 1499 orderByComparator); 1500 } 1501 1502 /** 1503 * Returns the first cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1504 * 1505 * @param groupId the group ID 1506 * @param type the type 1507 * @param repeating the repeating 1508 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1509 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 1510 */ 1511 public static CalEvent fetchByG_T_R_First(long groupId, 1512 java.lang.String type, boolean repeating, 1513 OrderByComparator<CalEvent> orderByComparator) { 1514 return getPersistence() 1515 .fetchByG_T_R_First(groupId, type, repeating, 1516 orderByComparator); 1517 } 1518 1519 /** 1520 * Returns the last cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1521 * 1522 * @param groupId the group ID 1523 * @param type the type 1524 * @param repeating the repeating 1525 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1526 * @return the last matching cal event 1527 * @throws NoSuchEventException if a matching cal event could not be found 1528 */ 1529 public static CalEvent findByG_T_R_Last(long groupId, 1530 java.lang.String type, boolean repeating, 1531 OrderByComparator<CalEvent> orderByComparator) 1532 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1533 return getPersistence() 1534 .findByG_T_R_Last(groupId, type, repeating, orderByComparator); 1535 } 1536 1537 /** 1538 * Returns the last cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1539 * 1540 * @param groupId the group ID 1541 * @param type the type 1542 * @param repeating the repeating 1543 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1544 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 1545 */ 1546 public static CalEvent fetchByG_T_R_Last(long groupId, 1547 java.lang.String type, boolean repeating, 1548 OrderByComparator<CalEvent> orderByComparator) { 1549 return getPersistence() 1550 .fetchByG_T_R_Last(groupId, type, repeating, 1551 orderByComparator); 1552 } 1553 1554 /** 1555 * Returns the cal events before and after the current cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1556 * 1557 * @param eventId the primary key of the current cal event 1558 * @param groupId the group ID 1559 * @param type the type 1560 * @param repeating the repeating 1561 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1562 * @return the previous, current, and next cal event 1563 * @throws NoSuchEventException if a cal event with the primary key could not be found 1564 */ 1565 public static CalEvent[] findByG_T_R_PrevAndNext(long eventId, 1566 long groupId, java.lang.String type, boolean repeating, 1567 OrderByComparator<CalEvent> orderByComparator) 1568 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1569 return getPersistence() 1570 .findByG_T_R_PrevAndNext(eventId, groupId, type, repeating, 1571 orderByComparator); 1572 } 1573 1574 /** 1575 * Returns all the cal events where groupId = ? and type = any ? and repeating = ?. 1576 * 1577 * <p> 1578 * 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 CalEventModelImpl}. 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. 1579 * </p> 1580 * 1581 * @param groupId the group ID 1582 * @param types the types 1583 * @param repeating the repeating 1584 * @return the matching cal events 1585 */ 1586 public static List<CalEvent> findByG_T_R(long groupId, 1587 java.lang.String[] types, boolean repeating) { 1588 return getPersistence().findByG_T_R(groupId, types, repeating); 1589 } 1590 1591 /** 1592 * Returns a range of all the cal events where groupId = ? and type = any ? and repeating = ?. 1593 * 1594 * <p> 1595 * 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 CalEventModelImpl}. 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. 1596 * </p> 1597 * 1598 * @param groupId the group ID 1599 * @param types the types 1600 * @param repeating the repeating 1601 * @param start the lower bound of the range of cal events 1602 * @param end the upper bound of the range of cal events (not inclusive) 1603 * @return the range of matching cal events 1604 */ 1605 public static List<CalEvent> findByG_T_R(long groupId, 1606 java.lang.String[] types, boolean repeating, int start, int end) { 1607 return getPersistence() 1608 .findByG_T_R(groupId, types, repeating, start, end); 1609 } 1610 1611 /** 1612 * Returns an ordered range of all the cal events where groupId = ? and type = any ? and repeating = ?. 1613 * 1614 * <p> 1615 * 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 CalEventModelImpl}. 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. 1616 * </p> 1617 * 1618 * @param groupId the group ID 1619 * @param types the types 1620 * @param repeating the repeating 1621 * @param start the lower bound of the range of cal events 1622 * @param end the upper bound of the range of cal events (not inclusive) 1623 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1624 * @return the ordered range of matching cal events 1625 */ 1626 public static List<CalEvent> findByG_T_R(long groupId, 1627 java.lang.String[] types, boolean repeating, int start, int end, 1628 OrderByComparator<CalEvent> orderByComparator) { 1629 return getPersistence() 1630 .findByG_T_R(groupId, types, repeating, start, end, 1631 orderByComparator); 1632 } 1633 1634 /** 1635 * Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?, optionally using the finder cache. 1636 * 1637 * <p> 1638 * 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 CalEventModelImpl}. 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. 1639 * </p> 1640 * 1641 * @param groupId the group ID 1642 * @param type the type 1643 * @param repeating the repeating 1644 * @param start the lower bound of the range of cal events 1645 * @param end the upper bound of the range of cal events (not inclusive) 1646 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1647 * @param retrieveFromCache whether to retrieve from the finder cache 1648 * @return the ordered range of matching cal events 1649 */ 1650 public static List<CalEvent> findByG_T_R(long groupId, 1651 java.lang.String[] types, boolean repeating, int start, int end, 1652 OrderByComparator<CalEvent> orderByComparator, boolean retrieveFromCache) { 1653 return getPersistence() 1654 .findByG_T_R(groupId, types, repeating, start, end, 1655 orderByComparator, retrieveFromCache); 1656 } 1657 1658 /** 1659 * Removes all the cal events where groupId = ? and type = ? and repeating = ? from the database. 1660 * 1661 * @param groupId the group ID 1662 * @param type the type 1663 * @param repeating the repeating 1664 */ 1665 public static void removeByG_T_R(long groupId, java.lang.String type, 1666 boolean repeating) { 1667 getPersistence().removeByG_T_R(groupId, type, repeating); 1668 } 1669 1670 /** 1671 * Returns the number of cal events where groupId = ? and type = ? and repeating = ?. 1672 * 1673 * @param groupId the group ID 1674 * @param type the type 1675 * @param repeating the repeating 1676 * @return the number of matching cal events 1677 */ 1678 public static int countByG_T_R(long groupId, java.lang.String type, 1679 boolean repeating) { 1680 return getPersistence().countByG_T_R(groupId, type, repeating); 1681 } 1682 1683 /** 1684 * Returns the number of cal events where groupId = ? and type = any ? and repeating = ?. 1685 * 1686 * @param groupId the group ID 1687 * @param types the types 1688 * @param repeating the repeating 1689 * @return the number of matching cal events 1690 */ 1691 public static int countByG_T_R(long groupId, java.lang.String[] types, 1692 boolean repeating) { 1693 return getPersistence().countByG_T_R(groupId, types, repeating); 1694 } 1695 1696 /** 1697 * Caches the cal event in the entity cache if it is enabled. 1698 * 1699 * @param calEvent the cal event 1700 */ 1701 public static void cacheResult(CalEvent calEvent) { 1702 getPersistence().cacheResult(calEvent); 1703 } 1704 1705 /** 1706 * Caches the cal events in the entity cache if it is enabled. 1707 * 1708 * @param calEvents the cal events 1709 */ 1710 public static void cacheResult(List<CalEvent> calEvents) { 1711 getPersistence().cacheResult(calEvents); 1712 } 1713 1714 /** 1715 * Creates a new cal event with the primary key. Does not add the cal event to the database. 1716 * 1717 * @param eventId the primary key for the new cal event 1718 * @return the new cal event 1719 */ 1720 public static CalEvent create(long eventId) { 1721 return getPersistence().create(eventId); 1722 } 1723 1724 /** 1725 * Removes the cal event with the primary key from the database. Also notifies the appropriate model listeners. 1726 * 1727 * @param eventId the primary key of the cal event 1728 * @return the cal event that was removed 1729 * @throws NoSuchEventException if a cal event with the primary key could not be found 1730 */ 1731 public static CalEvent remove(long eventId) 1732 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1733 return getPersistence().remove(eventId); 1734 } 1735 1736 public static CalEvent updateImpl(CalEvent calEvent) { 1737 return getPersistence().updateImpl(calEvent); 1738 } 1739 1740 /** 1741 * Returns the cal event with the primary key or throws a {@link NoSuchEventException} if it could not be found. 1742 * 1743 * @param eventId the primary key of the cal event 1744 * @return the cal event 1745 * @throws NoSuchEventException if a cal event with the primary key could not be found 1746 */ 1747 public static CalEvent findByPrimaryKey(long eventId) 1748 throws com.liferay.portlet.calendar.exception.NoSuchEventException { 1749 return getPersistence().findByPrimaryKey(eventId); 1750 } 1751 1752 /** 1753 * Returns the cal event with the primary key or returns <code>null</code> if it could not be found. 1754 * 1755 * @param eventId the primary key of the cal event 1756 * @return the cal event, or <code>null</code> if a cal event with the primary key could not be found 1757 */ 1758 public static CalEvent fetchByPrimaryKey(long eventId) { 1759 return getPersistence().fetchByPrimaryKey(eventId); 1760 } 1761 1762 public static java.util.Map<java.io.Serializable, CalEvent> fetchByPrimaryKeys( 1763 java.util.Set<java.io.Serializable> primaryKeys) { 1764 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1765 } 1766 1767 /** 1768 * Returns all the cal events. 1769 * 1770 * @return the cal events 1771 */ 1772 public static List<CalEvent> findAll() { 1773 return getPersistence().findAll(); 1774 } 1775 1776 /** 1777 * Returns a range of all the cal events. 1778 * 1779 * <p> 1780 * 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 CalEventModelImpl}. 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. 1781 * </p> 1782 * 1783 * @param start the lower bound of the range of cal events 1784 * @param end the upper bound of the range of cal events (not inclusive) 1785 * @return the range of cal events 1786 */ 1787 public static List<CalEvent> findAll(int start, int end) { 1788 return getPersistence().findAll(start, end); 1789 } 1790 1791 /** 1792 * Returns an ordered range of all the cal events. 1793 * 1794 * <p> 1795 * 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 CalEventModelImpl}. 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. 1796 * </p> 1797 * 1798 * @param start the lower bound of the range of cal events 1799 * @param end the upper bound of the range of cal events (not inclusive) 1800 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1801 * @return the ordered range of cal events 1802 */ 1803 public static List<CalEvent> findAll(int start, int end, 1804 OrderByComparator<CalEvent> orderByComparator) { 1805 return getPersistence().findAll(start, end, orderByComparator); 1806 } 1807 1808 /** 1809 * Returns an ordered range of all the cal events. 1810 * 1811 * <p> 1812 * 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 CalEventModelImpl}. 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. 1813 * </p> 1814 * 1815 * @param start the lower bound of the range of cal events 1816 * @param end the upper bound of the range of cal events (not inclusive) 1817 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1818 * @param retrieveFromCache whether to retrieve from the finder cache 1819 * @return the ordered range of cal events 1820 */ 1821 public static List<CalEvent> findAll(int start, int end, 1822 OrderByComparator<CalEvent> orderByComparator, boolean retrieveFromCache) { 1823 return getPersistence() 1824 .findAll(start, end, orderByComparator, retrieveFromCache); 1825 } 1826 1827 /** 1828 * Removes all the cal events from the database. 1829 */ 1830 public static void removeAll() { 1831 getPersistence().removeAll(); 1832 } 1833 1834 /** 1835 * Returns the number of cal events. 1836 * 1837 * @return the number of cal events 1838 */ 1839 public static int countAll() { 1840 return getPersistence().countAll(); 1841 } 1842 1843 public static java.util.Set<java.lang.String> getBadColumnNames() { 1844 return getPersistence().getBadColumnNames(); 1845 } 1846 1847 public static CalEventPersistence getPersistence() { 1848 if (_persistence == null) { 1849 _persistence = (CalEventPersistence)PortalBeanLocatorUtil.locate(CalEventPersistence.class.getName()); 1850 1851 ReferenceRegistry.registerReference(CalEventUtil.class, 1852 "_persistence"); 1853 } 1854 1855 return _persistence; 1856 } 1857 1858 private static CalEventPersistence _persistence; 1859 }