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.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.calendar.model.CalEvent; 022 023 /** 024 * The persistence interface for the cal event service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.calendar.service.persistence.impl.CalEventPersistenceImpl 032 * @see CalEventUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface CalEventPersistence extends BasePersistence<CalEvent> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link CalEventUtil} to access the cal event persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the cal events where uuid = ?. 045 * 046 * @param uuid the uuid 047 * @return the matching cal events 048 */ 049 public java.util.List<CalEvent> findByUuid(java.lang.String uuid); 050 051 /** 052 * Returns a range of all the cal events where uuid = ?. 053 * 054 * <p> 055 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 056 * </p> 057 * 058 * @param uuid the uuid 059 * @param start the lower bound of the range of cal events 060 * @param end the upper bound of the range of cal events (not inclusive) 061 * @return the range of matching cal events 062 */ 063 public java.util.List<CalEvent> findByUuid(java.lang.String uuid, 064 int start, int end); 065 066 /** 067 * Returns an ordered range of all the cal events where uuid = ?. 068 * 069 * <p> 070 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 071 * </p> 072 * 073 * @param uuid the uuid 074 * @param start the lower bound of the range of cal events 075 * @param end the upper bound of the range of cal events (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching cal events 078 */ 079 public java.util.List<CalEvent> findByUuid(java.lang.String uuid, 080 int start, int end, 081 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 082 083 /** 084 * Returns the first cal event in the ordered set where uuid = ?. 085 * 086 * @param uuid the uuid 087 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 088 * @return the first matching cal event 089 * @throws NoSuchEventException if a matching cal event could not be found 090 */ 091 public CalEvent findByUuid_First(java.lang.String uuid, 092 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 093 throws com.liferay.portlet.calendar.NoSuchEventException; 094 095 /** 096 * Returns the first cal event in the ordered set where uuid = ?. 097 * 098 * @param uuid the uuid 099 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 100 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 101 */ 102 public CalEvent fetchByUuid_First(java.lang.String uuid, 103 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 104 105 /** 106 * Returns the last cal event in the ordered set where uuid = ?. 107 * 108 * @param uuid the uuid 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the last matching cal event 111 * @throws NoSuchEventException if a matching cal event could not be found 112 */ 113 public CalEvent findByUuid_Last(java.lang.String uuid, 114 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 115 throws com.liferay.portlet.calendar.NoSuchEventException; 116 117 /** 118 * Returns the last cal event in the ordered set where uuid = ?. 119 * 120 * @param uuid the uuid 121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 122 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 123 */ 124 public CalEvent fetchByUuid_Last(java.lang.String uuid, 125 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 126 127 /** 128 * Returns the cal events before and after the current cal event in the ordered set where uuid = ?. 129 * 130 * @param eventId the primary key of the current cal event 131 * @param uuid the uuid 132 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 133 * @return the previous, current, and next cal event 134 * @throws NoSuchEventException if a cal event with the primary key could not be found 135 */ 136 public CalEvent[] findByUuid_PrevAndNext(long eventId, 137 java.lang.String uuid, 138 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 139 throws com.liferay.portlet.calendar.NoSuchEventException; 140 141 /** 142 * Removes all the cal events where uuid = ? from the database. 143 * 144 * @param uuid the uuid 145 */ 146 public void removeByUuid(java.lang.String uuid); 147 148 /** 149 * Returns the number of cal events where uuid = ?. 150 * 151 * @param uuid the uuid 152 * @return the number of matching cal events 153 */ 154 public int countByUuid(java.lang.String uuid); 155 156 /** 157 * Returns the cal event where uuid = ? and groupId = ? or throws a {@link NoSuchEventException} if it could not be found. 158 * 159 * @param uuid the uuid 160 * @param groupId the group ID 161 * @return the matching cal event 162 * @throws NoSuchEventException if a matching cal event could not be found 163 */ 164 public CalEvent findByUUID_G(java.lang.String uuid, long groupId) 165 throws com.liferay.portlet.calendar.NoSuchEventException; 166 167 /** 168 * Returns the cal event where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 169 * 170 * @param uuid the uuid 171 * @param groupId the group ID 172 * @return the matching cal event, or <code>null</code> if a matching cal event could not be found 173 */ 174 public CalEvent fetchByUUID_G(java.lang.String uuid, long groupId); 175 176 /** 177 * Returns the cal event where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 178 * 179 * @param uuid the uuid 180 * @param groupId the group ID 181 * @param retrieveFromCache whether to use the finder cache 182 * @return the matching cal event, or <code>null</code> if a matching cal event could not be found 183 */ 184 public CalEvent fetchByUUID_G(java.lang.String uuid, long groupId, 185 boolean retrieveFromCache); 186 187 /** 188 * Removes the cal event where uuid = ? and groupId = ? from the database. 189 * 190 * @param uuid the uuid 191 * @param groupId the group ID 192 * @return the cal event that was removed 193 */ 194 public CalEvent removeByUUID_G(java.lang.String uuid, long groupId) 195 throws com.liferay.portlet.calendar.NoSuchEventException; 196 197 /** 198 * Returns the number of cal events where uuid = ? and groupId = ?. 199 * 200 * @param uuid the uuid 201 * @param groupId the group ID 202 * @return the number of matching cal events 203 */ 204 public int countByUUID_G(java.lang.String uuid, long groupId); 205 206 /** 207 * Returns all the cal events where uuid = ? and companyId = ?. 208 * 209 * @param uuid the uuid 210 * @param companyId the company ID 211 * @return the matching cal events 212 */ 213 public java.util.List<CalEvent> findByUuid_C(java.lang.String uuid, 214 long companyId); 215 216 /** 217 * Returns a range of all the cal events where uuid = ? and companyId = ?. 218 * 219 * <p> 220 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 221 * </p> 222 * 223 * @param uuid the uuid 224 * @param companyId the company ID 225 * @param start the lower bound of the range of cal events 226 * @param end the upper bound of the range of cal events (not inclusive) 227 * @return the range of matching cal events 228 */ 229 public java.util.List<CalEvent> findByUuid_C(java.lang.String uuid, 230 long companyId, int start, int end); 231 232 /** 233 * Returns an ordered range of all the cal events where uuid = ? and companyId = ?. 234 * 235 * <p> 236 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 237 * </p> 238 * 239 * @param uuid the uuid 240 * @param companyId the company ID 241 * @param start the lower bound of the range of cal events 242 * @param end the upper bound of the range of cal events (not inclusive) 243 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 244 * @return the ordered range of matching cal events 245 */ 246 public java.util.List<CalEvent> findByUuid_C(java.lang.String uuid, 247 long companyId, int start, int end, 248 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 249 250 /** 251 * Returns the first cal event in the ordered set where uuid = ? and companyId = ?. 252 * 253 * @param uuid the uuid 254 * @param companyId the company ID 255 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 256 * @return the first matching cal event 257 * @throws NoSuchEventException if a matching cal event could not be found 258 */ 259 public CalEvent findByUuid_C_First(java.lang.String uuid, long companyId, 260 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 261 throws com.liferay.portlet.calendar.NoSuchEventException; 262 263 /** 264 * Returns the first cal event in the ordered set where uuid = ? and companyId = ?. 265 * 266 * @param uuid the uuid 267 * @param companyId the company ID 268 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 269 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 270 */ 271 public CalEvent fetchByUuid_C_First(java.lang.String uuid, long companyId, 272 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 273 274 /** 275 * Returns the last cal event in the ordered set where uuid = ? and companyId = ?. 276 * 277 * @param uuid the uuid 278 * @param companyId the company ID 279 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 280 * @return the last matching cal event 281 * @throws NoSuchEventException if a matching cal event could not be found 282 */ 283 public CalEvent findByUuid_C_Last(java.lang.String uuid, long companyId, 284 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 285 throws com.liferay.portlet.calendar.NoSuchEventException; 286 287 /** 288 * Returns the last cal event in the ordered set where uuid = ? and companyId = ?. 289 * 290 * @param uuid the uuid 291 * @param companyId the company ID 292 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 293 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 294 */ 295 public CalEvent fetchByUuid_C_Last(java.lang.String uuid, long companyId, 296 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 297 298 /** 299 * Returns the cal events before and after the current cal event in the ordered set where uuid = ? and companyId = ?. 300 * 301 * @param eventId the primary key of the current cal event 302 * @param uuid the uuid 303 * @param companyId the company ID 304 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 305 * @return the previous, current, and next cal event 306 * @throws NoSuchEventException if a cal event with the primary key could not be found 307 */ 308 public CalEvent[] findByUuid_C_PrevAndNext(long eventId, 309 java.lang.String uuid, long companyId, 310 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 311 throws com.liferay.portlet.calendar.NoSuchEventException; 312 313 /** 314 * Removes all the cal events where uuid = ? and companyId = ? from the database. 315 * 316 * @param uuid the uuid 317 * @param companyId the company ID 318 */ 319 public void removeByUuid_C(java.lang.String uuid, long companyId); 320 321 /** 322 * Returns the number of cal events where uuid = ? and companyId = ?. 323 * 324 * @param uuid the uuid 325 * @param companyId the company ID 326 * @return the number of matching cal events 327 */ 328 public int countByUuid_C(java.lang.String uuid, long companyId); 329 330 /** 331 * Returns all the cal events where groupId = ?. 332 * 333 * @param groupId the group ID 334 * @return the matching cal events 335 */ 336 public java.util.List<CalEvent> findByGroupId(long groupId); 337 338 /** 339 * Returns a range of all the cal events where groupId = ?. 340 * 341 * <p> 342 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 343 * </p> 344 * 345 * @param groupId the group ID 346 * @param start the lower bound of the range of cal events 347 * @param end the upper bound of the range of cal events (not inclusive) 348 * @return the range of matching cal events 349 */ 350 public java.util.List<CalEvent> findByGroupId(long groupId, int start, 351 int end); 352 353 /** 354 * Returns an ordered range of all the cal events where groupId = ?. 355 * 356 * <p> 357 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 358 * </p> 359 * 360 * @param groupId the group ID 361 * @param start the lower bound of the range of cal events 362 * @param end the upper bound of the range of cal events (not inclusive) 363 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 364 * @return the ordered range of matching cal events 365 */ 366 public java.util.List<CalEvent> findByGroupId(long groupId, int start, 367 int end, 368 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 369 370 /** 371 * Returns the first cal event in the ordered set where groupId = ?. 372 * 373 * @param groupId the group ID 374 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 375 * @return the first matching cal event 376 * @throws NoSuchEventException if a matching cal event could not be found 377 */ 378 public CalEvent findByGroupId_First(long groupId, 379 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 380 throws com.liferay.portlet.calendar.NoSuchEventException; 381 382 /** 383 * Returns the first cal event in the ordered set where groupId = ?. 384 * 385 * @param groupId the group 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 CalEvent fetchByGroupId_First(long groupId, 390 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 391 392 /** 393 * Returns the last cal event in the ordered set where groupId = ?. 394 * 395 * @param groupId the group ID 396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 397 * @return the last matching cal event 398 * @throws NoSuchEventException if a matching cal event could not be found 399 */ 400 public CalEvent findByGroupId_Last(long groupId, 401 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 402 throws com.liferay.portlet.calendar.NoSuchEventException; 403 404 /** 405 * Returns the last cal event in the ordered set where groupId = ?. 406 * 407 * @param groupId the group ID 408 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 409 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 410 */ 411 public CalEvent fetchByGroupId_Last(long groupId, 412 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 413 414 /** 415 * Returns the cal events before and after the current cal event in the ordered set where groupId = ?. 416 * 417 * @param eventId the primary key of the current cal event 418 * @param groupId the group ID 419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 420 * @return the previous, current, and next cal event 421 * @throws NoSuchEventException if a cal event with the primary key could not be found 422 */ 423 public CalEvent[] findByGroupId_PrevAndNext(long eventId, long groupId, 424 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 425 throws com.liferay.portlet.calendar.NoSuchEventException; 426 427 /** 428 * Removes all the cal events where groupId = ? from the database. 429 * 430 * @param groupId the group ID 431 */ 432 public void removeByGroupId(long groupId); 433 434 /** 435 * Returns the number of cal events where groupId = ?. 436 * 437 * @param groupId the group ID 438 * @return the number of matching cal events 439 */ 440 public int countByGroupId(long groupId); 441 442 /** 443 * Returns all the cal events where companyId = ?. 444 * 445 * @param companyId the company ID 446 * @return the matching cal events 447 */ 448 public java.util.List<CalEvent> findByCompanyId(long companyId); 449 450 /** 451 * Returns a range of all the cal events where companyId = ?. 452 * 453 * <p> 454 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 455 * </p> 456 * 457 * @param companyId the company ID 458 * @param start the lower bound of the range of cal events 459 * @param end the upper bound of the range of cal events (not inclusive) 460 * @return the range of matching cal events 461 */ 462 public java.util.List<CalEvent> findByCompanyId(long companyId, int start, 463 int end); 464 465 /** 466 * Returns an ordered range of all the cal events where companyId = ?. 467 * 468 * <p> 469 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 470 * </p> 471 * 472 * @param companyId the company ID 473 * @param start the lower bound of the range of cal events 474 * @param end the upper bound of the range of cal events (not inclusive) 475 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 476 * @return the ordered range of matching cal events 477 */ 478 public java.util.List<CalEvent> findByCompanyId(long companyId, int start, 479 int end, 480 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 481 482 /** 483 * Returns the first cal event in the ordered set where companyId = ?. 484 * 485 * @param companyId the company ID 486 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 487 * @return the first matching cal event 488 * @throws NoSuchEventException if a matching cal event could not be found 489 */ 490 public CalEvent findByCompanyId_First(long companyId, 491 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 492 throws com.liferay.portlet.calendar.NoSuchEventException; 493 494 /** 495 * Returns the first cal event in the ordered set where companyId = ?. 496 * 497 * @param companyId the company ID 498 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 499 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 500 */ 501 public CalEvent fetchByCompanyId_First(long companyId, 502 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 503 504 /** 505 * Returns the last cal event in the ordered set where companyId = ?. 506 * 507 * @param companyId the company ID 508 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 509 * @return the last matching cal event 510 * @throws NoSuchEventException if a matching cal event could not be found 511 */ 512 public CalEvent findByCompanyId_Last(long companyId, 513 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 514 throws com.liferay.portlet.calendar.NoSuchEventException; 515 516 /** 517 * Returns the last cal event in the ordered set where companyId = ?. 518 * 519 * @param companyId the company ID 520 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 521 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 522 */ 523 public CalEvent fetchByCompanyId_Last(long companyId, 524 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 525 526 /** 527 * Returns the cal events before and after the current cal event in the ordered set where companyId = ?. 528 * 529 * @param eventId the primary key of the current cal event 530 * @param companyId the company ID 531 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 532 * @return the previous, current, and next cal event 533 * @throws NoSuchEventException if a cal event with the primary key could not be found 534 */ 535 public CalEvent[] findByCompanyId_PrevAndNext(long eventId, long companyId, 536 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 537 throws com.liferay.portlet.calendar.NoSuchEventException; 538 539 /** 540 * Removes all the cal events where companyId = ? from the database. 541 * 542 * @param companyId the company ID 543 */ 544 public void removeByCompanyId(long companyId); 545 546 /** 547 * Returns the number of cal events where companyId = ?. 548 * 549 * @param companyId the company ID 550 * @return the number of matching cal events 551 */ 552 public int countByCompanyId(long companyId); 553 554 /** 555 * Returns all the cal events where remindBy ≠ ?. 556 * 557 * @param remindBy the remind by 558 * @return the matching cal events 559 */ 560 public java.util.List<CalEvent> findByNotRemindBy(int remindBy); 561 562 /** 563 * Returns a range of all the cal events where remindBy ≠ ?. 564 * 565 * <p> 566 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 567 * </p> 568 * 569 * @param remindBy the remind by 570 * @param start the lower bound of the range of cal events 571 * @param end the upper bound of the range of cal events (not inclusive) 572 * @return the range of matching cal events 573 */ 574 public java.util.List<CalEvent> findByNotRemindBy(int remindBy, int start, 575 int end); 576 577 /** 578 * Returns an ordered range of all the cal events where remindBy ≠ ?. 579 * 580 * <p> 581 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 582 * </p> 583 * 584 * @param remindBy the remind by 585 * @param start the lower bound of the range of cal events 586 * @param end the upper bound of the range of cal events (not inclusive) 587 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 588 * @return the ordered range of matching cal events 589 */ 590 public java.util.List<CalEvent> findByNotRemindBy(int remindBy, int start, 591 int end, 592 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 593 594 /** 595 * Returns the first cal event in the ordered set where remindBy ≠ ?. 596 * 597 * @param remindBy the remind by 598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 599 * @return the first matching cal event 600 * @throws NoSuchEventException if a matching cal event could not be found 601 */ 602 public CalEvent findByNotRemindBy_First(int remindBy, 603 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 604 throws com.liferay.portlet.calendar.NoSuchEventException; 605 606 /** 607 * Returns the first cal event in the ordered set where remindBy ≠ ?. 608 * 609 * @param remindBy the remind by 610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 611 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 612 */ 613 public CalEvent fetchByNotRemindBy_First(int remindBy, 614 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 615 616 /** 617 * Returns the last cal event in the ordered set where remindBy ≠ ?. 618 * 619 * @param remindBy the remind by 620 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 621 * @return the last matching cal event 622 * @throws NoSuchEventException if a matching cal event could not be found 623 */ 624 public CalEvent findByNotRemindBy_Last(int remindBy, 625 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 626 throws com.liferay.portlet.calendar.NoSuchEventException; 627 628 /** 629 * Returns the last cal event in the ordered set where remindBy ≠ ?. 630 * 631 * @param remindBy the remind by 632 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 633 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 634 */ 635 public CalEvent fetchByNotRemindBy_Last(int remindBy, 636 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 637 638 /** 639 * Returns the cal events before and after the current cal event in the ordered set where remindBy ≠ ?. 640 * 641 * @param eventId the primary key of the current cal event 642 * @param remindBy the remind by 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 NoSuchEventException if a cal event with the primary key could not be found 646 */ 647 public CalEvent[] findByNotRemindBy_PrevAndNext(long eventId, int remindBy, 648 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 649 throws com.liferay.portlet.calendar.NoSuchEventException; 650 651 /** 652 * Removes all the cal events where remindBy ≠ ? from the database. 653 * 654 * @param remindBy the remind by 655 */ 656 public void removeByNotRemindBy(int remindBy); 657 658 /** 659 * Returns the number of cal events where remindBy ≠ ?. 660 * 661 * @param remindBy the remind by 662 * @return the number of matching cal events 663 */ 664 public int countByNotRemindBy(int remindBy); 665 666 /** 667 * Returns all the cal events where groupId = ? and type = ?. 668 * 669 * @param groupId the group ID 670 * @param type the type 671 * @return the matching cal events 672 */ 673 public java.util.List<CalEvent> findByG_T(long groupId, 674 java.lang.String type); 675 676 /** 677 * Returns a range of all the cal events where groupId = ? and type = ?. 678 * 679 * <p> 680 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 681 * </p> 682 * 683 * @param groupId the group ID 684 * @param type the type 685 * @param start the lower bound of the range of cal events 686 * @param end the upper bound of the range of cal events (not inclusive) 687 * @return the range of matching cal events 688 */ 689 public java.util.List<CalEvent> findByG_T(long groupId, 690 java.lang.String type, int start, int end); 691 692 /** 693 * Returns an ordered range of all the cal events where groupId = ? and type = ?. 694 * 695 * <p> 696 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 697 * </p> 698 * 699 * @param groupId the group ID 700 * @param type the type 701 * @param start the lower bound of the range of cal events 702 * @param end the upper bound of the range of cal events (not inclusive) 703 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 704 * @return the ordered range of matching cal events 705 */ 706 public java.util.List<CalEvent> findByG_T(long groupId, 707 java.lang.String type, int start, int end, 708 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 709 710 /** 711 * Returns the first cal event in the ordered set where groupId = ? and type = ?. 712 * 713 * @param groupId the group ID 714 * @param type the type 715 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 716 * @return the first matching cal event 717 * @throws NoSuchEventException if a matching cal event could not be found 718 */ 719 public CalEvent findByG_T_First(long groupId, java.lang.String type, 720 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 721 throws com.liferay.portlet.calendar.NoSuchEventException; 722 723 /** 724 * Returns the first cal event in the ordered set where groupId = ? and type = ?. 725 * 726 * @param groupId the group ID 727 * @param type the type 728 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 729 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 730 */ 731 public CalEvent fetchByG_T_First(long groupId, java.lang.String type, 732 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 733 734 /** 735 * Returns the last cal event in the ordered set where groupId = ? and type = ?. 736 * 737 * @param groupId the group ID 738 * @param type the type 739 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 740 * @return the last matching cal event 741 * @throws NoSuchEventException if a matching cal event could not be found 742 */ 743 public CalEvent findByG_T_Last(long groupId, java.lang.String type, 744 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 745 throws com.liferay.portlet.calendar.NoSuchEventException; 746 747 /** 748 * Returns the last cal event in the ordered set where groupId = ? and type = ?. 749 * 750 * @param groupId the group ID 751 * @param type the type 752 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 753 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 754 */ 755 public CalEvent fetchByG_T_Last(long groupId, java.lang.String type, 756 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 757 758 /** 759 * Returns the cal events before and after the current cal event in the ordered set where groupId = ? and type = ?. 760 * 761 * @param eventId the primary key of the current cal event 762 * @param groupId the group ID 763 * @param type the type 764 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 765 * @return the previous, current, and next cal event 766 * @throws NoSuchEventException if a cal event with the primary key could not be found 767 */ 768 public CalEvent[] findByG_T_PrevAndNext(long eventId, long groupId, 769 java.lang.String type, 770 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 771 throws com.liferay.portlet.calendar.NoSuchEventException; 772 773 /** 774 * Returns all the cal events where groupId = ? and type = any ?. 775 * 776 * <p> 777 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 778 * </p> 779 * 780 * @param groupId the group ID 781 * @param types the types 782 * @return the matching cal events 783 */ 784 public java.util.List<CalEvent> findByG_T(long groupId, 785 java.lang.String[] types); 786 787 /** 788 * Returns a range of all the cal events where groupId = ? and type = any ?. 789 * 790 * <p> 791 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 792 * </p> 793 * 794 * @param groupId the group ID 795 * @param types the types 796 * @param start the lower bound of the range of cal events 797 * @param end the upper bound of the range of cal events (not inclusive) 798 * @return the range of matching cal events 799 */ 800 public java.util.List<CalEvent> findByG_T(long groupId, 801 java.lang.String[] types, int start, int end); 802 803 /** 804 * Returns an ordered range of all the cal events where groupId = ? and type = any ?. 805 * 806 * <p> 807 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 808 * </p> 809 * 810 * @param groupId the group ID 811 * @param types the types 812 * @param start the lower bound of the range of cal events 813 * @param end the upper bound of the range of cal events (not inclusive) 814 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 815 * @return the ordered range of matching cal events 816 */ 817 public java.util.List<CalEvent> findByG_T(long groupId, 818 java.lang.String[] types, int start, int end, 819 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 820 821 /** 822 * Removes all the cal events where groupId = ? and type = ? from the database. 823 * 824 * @param groupId the group ID 825 * @param type the type 826 */ 827 public void removeByG_T(long groupId, java.lang.String type); 828 829 /** 830 * Returns the number of cal events where groupId = ? and type = ?. 831 * 832 * @param groupId the group ID 833 * @param type the type 834 * @return the number of matching cal events 835 */ 836 public int countByG_T(long groupId, java.lang.String type); 837 838 /** 839 * Returns the number of cal events where groupId = ? and type = any ?. 840 * 841 * @param groupId the group ID 842 * @param types the types 843 * @return the number of matching cal events 844 */ 845 public int countByG_T(long groupId, java.lang.String[] types); 846 847 /** 848 * Returns all the cal events where groupId = ? and repeating = ?. 849 * 850 * @param groupId the group ID 851 * @param repeating the repeating 852 * @return the matching cal events 853 */ 854 public java.util.List<CalEvent> findByG_R(long groupId, boolean repeating); 855 856 /** 857 * Returns a range of all the cal events where groupId = ? and repeating = ?. 858 * 859 * <p> 860 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 861 * </p> 862 * 863 * @param groupId the group ID 864 * @param repeating the repeating 865 * @param start the lower bound of the range of cal events 866 * @param end the upper bound of the range of cal events (not inclusive) 867 * @return the range of matching cal events 868 */ 869 public java.util.List<CalEvent> findByG_R(long groupId, boolean repeating, 870 int start, int end); 871 872 /** 873 * Returns an ordered range of all the cal events where groupId = ? and repeating = ?. 874 * 875 * <p> 876 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 877 * </p> 878 * 879 * @param groupId the group ID 880 * @param repeating the repeating 881 * @param start the lower bound of the range of cal events 882 * @param end the upper bound of the range of cal events (not inclusive) 883 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 884 * @return the ordered range of matching cal events 885 */ 886 public java.util.List<CalEvent> findByG_R(long groupId, boolean repeating, 887 int start, int end, 888 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 889 890 /** 891 * Returns the first cal event in the ordered set where groupId = ? and repeating = ?. 892 * 893 * @param groupId the group ID 894 * @param repeating the repeating 895 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 896 * @return the first matching cal event 897 * @throws NoSuchEventException if a matching cal event could not be found 898 */ 899 public CalEvent findByG_R_First(long groupId, boolean repeating, 900 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 901 throws com.liferay.portlet.calendar.NoSuchEventException; 902 903 /** 904 * Returns the first cal event in the ordered set where groupId = ? and repeating = ?. 905 * 906 * @param groupId the group ID 907 * @param repeating the repeating 908 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 909 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 910 */ 911 public CalEvent fetchByG_R_First(long groupId, boolean repeating, 912 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 913 914 /** 915 * Returns the last cal event in the ordered set where groupId = ? and repeating = ?. 916 * 917 * @param groupId the group ID 918 * @param repeating the repeating 919 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 920 * @return the last matching cal event 921 * @throws NoSuchEventException if a matching cal event could not be found 922 */ 923 public CalEvent findByG_R_Last(long groupId, boolean repeating, 924 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 925 throws com.liferay.portlet.calendar.NoSuchEventException; 926 927 /** 928 * Returns the last cal event in the ordered set where groupId = ? and repeating = ?. 929 * 930 * @param groupId the group ID 931 * @param repeating the repeating 932 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 933 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 934 */ 935 public CalEvent fetchByG_R_Last(long groupId, boolean repeating, 936 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 937 938 /** 939 * Returns the cal events before and after the current cal event in the ordered set where groupId = ? and repeating = ?. 940 * 941 * @param eventId the primary key of the current cal event 942 * @param groupId the group ID 943 * @param repeating the repeating 944 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 945 * @return the previous, current, and next cal event 946 * @throws NoSuchEventException if a cal event with the primary key could not be found 947 */ 948 public CalEvent[] findByG_R_PrevAndNext(long eventId, long groupId, 949 boolean repeating, 950 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 951 throws com.liferay.portlet.calendar.NoSuchEventException; 952 953 /** 954 * Removes all the cal events where groupId = ? and repeating = ? from the database. 955 * 956 * @param groupId the group ID 957 * @param repeating the repeating 958 */ 959 public void removeByG_R(long groupId, boolean repeating); 960 961 /** 962 * Returns the number of cal events where groupId = ? and repeating = ?. 963 * 964 * @param groupId the group ID 965 * @param repeating the repeating 966 * @return the number of matching cal events 967 */ 968 public int countByG_R(long groupId, boolean repeating); 969 970 /** 971 * Returns all the cal events where groupId = ? and type = ? and repeating = ?. 972 * 973 * @param groupId the group ID 974 * @param type the type 975 * @param repeating the repeating 976 * @return the matching cal events 977 */ 978 public java.util.List<CalEvent> findByG_T_R(long groupId, 979 java.lang.String type, boolean repeating); 980 981 /** 982 * Returns a range of all the cal events where groupId = ? and type = ? and repeating = ?. 983 * 984 * <p> 985 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 986 * </p> 987 * 988 * @param groupId the group ID 989 * @param type the type 990 * @param repeating the repeating 991 * @param start the lower bound of the range of cal events 992 * @param end the upper bound of the range of cal events (not inclusive) 993 * @return the range of matching cal events 994 */ 995 public java.util.List<CalEvent> findByG_T_R(long groupId, 996 java.lang.String type, boolean repeating, int start, int end); 997 998 /** 999 * Returns an ordered range of all the cal events where groupId = ? and type = ? and repeating = ?. 1000 * 1001 * <p> 1002 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1003 * </p> 1004 * 1005 * @param groupId the group ID 1006 * @param type the type 1007 * @param repeating the repeating 1008 * @param start the lower bound of the range of cal events 1009 * @param end the upper bound of the range of cal events (not inclusive) 1010 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1011 * @return the ordered range of matching cal events 1012 */ 1013 public java.util.List<CalEvent> findByG_T_R(long groupId, 1014 java.lang.String type, boolean repeating, int start, int end, 1015 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 1016 1017 /** 1018 * Returns the first cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1019 * 1020 * @param groupId the group ID 1021 * @param type the type 1022 * @param repeating the repeating 1023 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1024 * @return the first matching cal event 1025 * @throws NoSuchEventException if a matching cal event could not be found 1026 */ 1027 public CalEvent findByG_T_R_First(long groupId, java.lang.String type, 1028 boolean repeating, 1029 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 1030 throws com.liferay.portlet.calendar.NoSuchEventException; 1031 1032 /** 1033 * Returns the first cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1034 * 1035 * @param groupId the group ID 1036 * @param type the type 1037 * @param repeating the repeating 1038 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1039 * @return the first matching cal event, or <code>null</code> if a matching cal event could not be found 1040 */ 1041 public CalEvent fetchByG_T_R_First(long groupId, java.lang.String type, 1042 boolean repeating, 1043 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 1044 1045 /** 1046 * Returns the last cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1047 * 1048 * @param groupId the group ID 1049 * @param type the type 1050 * @param repeating the repeating 1051 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1052 * @return the last matching cal event 1053 * @throws NoSuchEventException if a matching cal event could not be found 1054 */ 1055 public CalEvent findByG_T_R_Last(long groupId, java.lang.String type, 1056 boolean repeating, 1057 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 1058 throws com.liferay.portlet.calendar.NoSuchEventException; 1059 1060 /** 1061 * Returns the last cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1062 * 1063 * @param groupId the group ID 1064 * @param type the type 1065 * @param repeating the repeating 1066 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1067 * @return the last matching cal event, or <code>null</code> if a matching cal event could not be found 1068 */ 1069 public CalEvent fetchByG_T_R_Last(long groupId, java.lang.String type, 1070 boolean repeating, 1071 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 1072 1073 /** 1074 * Returns the cal events before and after the current cal event in the ordered set where groupId = ? and type = ? and repeating = ?. 1075 * 1076 * @param eventId the primary key of the current cal event 1077 * @param groupId the group ID 1078 * @param type the type 1079 * @param repeating the repeating 1080 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1081 * @return the previous, current, and next cal event 1082 * @throws NoSuchEventException if a cal event with the primary key could not be found 1083 */ 1084 public CalEvent[] findByG_T_R_PrevAndNext(long eventId, long groupId, 1085 java.lang.String type, boolean repeating, 1086 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator) 1087 throws com.liferay.portlet.calendar.NoSuchEventException; 1088 1089 /** 1090 * Returns all the cal events where groupId = ? and type = any ? and repeating = ?. 1091 * 1092 * <p> 1093 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1094 * </p> 1095 * 1096 * @param groupId the group ID 1097 * @param types the types 1098 * @param repeating the repeating 1099 * @return the matching cal events 1100 */ 1101 public java.util.List<CalEvent> findByG_T_R(long groupId, 1102 java.lang.String[] types, boolean repeating); 1103 1104 /** 1105 * Returns a range of all the cal events where groupId = ? and type = any ? and repeating = ?. 1106 * 1107 * <p> 1108 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1109 * </p> 1110 * 1111 * @param groupId the group ID 1112 * @param types the types 1113 * @param repeating the repeating 1114 * @param start the lower bound of the range of cal events 1115 * @param end the upper bound of the range of cal events (not inclusive) 1116 * @return the range of matching cal events 1117 */ 1118 public java.util.List<CalEvent> findByG_T_R(long groupId, 1119 java.lang.String[] types, boolean repeating, int start, int end); 1120 1121 /** 1122 * Returns an ordered range of all the cal events where groupId = ? and type = any ? and repeating = ?. 1123 * 1124 * <p> 1125 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1126 * </p> 1127 * 1128 * @param groupId the group ID 1129 * @param types the types 1130 * @param repeating the repeating 1131 * @param start the lower bound of the range of cal events 1132 * @param end the upper bound of the range of cal events (not inclusive) 1133 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1134 * @return the ordered range of matching cal events 1135 */ 1136 public java.util.List<CalEvent> findByG_T_R(long groupId, 1137 java.lang.String[] types, boolean repeating, int start, int end, 1138 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 1139 1140 /** 1141 * Removes all the cal events where groupId = ? and type = ? and repeating = ? from the database. 1142 * 1143 * @param groupId the group ID 1144 * @param type the type 1145 * @param repeating the repeating 1146 */ 1147 public void removeByG_T_R(long groupId, java.lang.String type, 1148 boolean repeating); 1149 1150 /** 1151 * Returns the number of cal events where groupId = ? and type = ? and repeating = ?. 1152 * 1153 * @param groupId the group ID 1154 * @param type the type 1155 * @param repeating the repeating 1156 * @return the number of matching cal events 1157 */ 1158 public int countByG_T_R(long groupId, java.lang.String type, 1159 boolean repeating); 1160 1161 /** 1162 * Returns the number of cal events where groupId = ? and type = any ? and repeating = ?. 1163 * 1164 * @param groupId the group ID 1165 * @param types the types 1166 * @param repeating the repeating 1167 * @return the number of matching cal events 1168 */ 1169 public int countByG_T_R(long groupId, java.lang.String[] types, 1170 boolean repeating); 1171 1172 /** 1173 * Caches the cal event in the entity cache if it is enabled. 1174 * 1175 * @param calEvent the cal event 1176 */ 1177 public void cacheResult(CalEvent calEvent); 1178 1179 /** 1180 * Caches the cal events in the entity cache if it is enabled. 1181 * 1182 * @param calEvents the cal events 1183 */ 1184 public void cacheResult(java.util.List<CalEvent> calEvents); 1185 1186 /** 1187 * Creates a new cal event with the primary key. Does not add the cal event to the database. 1188 * 1189 * @param eventId the primary key for the new cal event 1190 * @return the new cal event 1191 */ 1192 public CalEvent create(long eventId); 1193 1194 /** 1195 * Removes the cal event with the primary key from the database. Also notifies the appropriate model listeners. 1196 * 1197 * @param eventId the primary key of the cal event 1198 * @return the cal event that was removed 1199 * @throws NoSuchEventException if a cal event with the primary key could not be found 1200 */ 1201 public CalEvent remove(long eventId) 1202 throws com.liferay.portlet.calendar.NoSuchEventException; 1203 1204 public CalEvent updateImpl(CalEvent calEvent); 1205 1206 /** 1207 * Returns the cal event with the primary key or throws a {@link NoSuchEventException} if it could not be found. 1208 * 1209 * @param eventId the primary key of the cal event 1210 * @return the cal event 1211 * @throws NoSuchEventException if a cal event with the primary key could not be found 1212 */ 1213 public CalEvent findByPrimaryKey(long eventId) 1214 throws com.liferay.portlet.calendar.NoSuchEventException; 1215 1216 /** 1217 * Returns the cal event with the primary key or returns <code>null</code> if it could not be found. 1218 * 1219 * @param eventId the primary key of the cal event 1220 * @return the cal event, or <code>null</code> if a cal event with the primary key could not be found 1221 */ 1222 public CalEvent fetchByPrimaryKey(long eventId); 1223 1224 @Override 1225 public java.util.Map<java.io.Serializable, CalEvent> fetchByPrimaryKeys( 1226 java.util.Set<java.io.Serializable> primaryKeys); 1227 1228 /** 1229 * Returns all the cal events. 1230 * 1231 * @return the cal events 1232 */ 1233 public java.util.List<CalEvent> findAll(); 1234 1235 /** 1236 * Returns a range of all the cal events. 1237 * 1238 * <p> 1239 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1240 * </p> 1241 * 1242 * @param start the lower bound of the range of cal events 1243 * @param end the upper bound of the range of cal events (not inclusive) 1244 * @return the range of cal events 1245 */ 1246 public java.util.List<CalEvent> findAll(int start, int end); 1247 1248 /** 1249 * Returns an ordered range of all the cal events. 1250 * 1251 * <p> 1252 * 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 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 QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1253 * </p> 1254 * 1255 * @param start the lower bound of the range of cal events 1256 * @param end the upper bound of the range of cal events (not inclusive) 1257 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1258 * @return the ordered range of cal events 1259 */ 1260 public java.util.List<CalEvent> findAll(int start, int end, 1261 com.liferay.portal.kernel.util.OrderByComparator<CalEvent> orderByComparator); 1262 1263 /** 1264 * Removes all the cal events from the database. 1265 */ 1266 public void removeAll(); 1267 1268 /** 1269 * Returns the number of cal events. 1270 * 1271 * @return the number of cal events 1272 */ 1273 public int countAll(); 1274 }