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