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