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