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