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