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