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