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.social.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.service.persistence.BasePersistence; 020 021 import com.liferay.social.kernel.exception.NoSuchActivityLimitException; 022 import com.liferay.social.kernel.model.SocialActivityLimit; 023 024 /** 025 * The persistence interface for the social activity limit service. 026 * 027 * <p> 028 * Caching information and settings can be found in <code>portal.properties</code> 029 * </p> 030 * 031 * @author Brian Wing Shun Chan 032 * @see com.liferay.portlet.social.service.persistence.impl.SocialActivityLimitPersistenceImpl 033 * @see SocialActivityLimitUtil 034 * @generated 035 */ 036 @ProviderType 037 public interface SocialActivityLimitPersistence extends BasePersistence<SocialActivityLimit> { 038 /* 039 * NOTE FOR DEVELOPERS: 040 * 041 * Never modify or reference this interface directly. Always use {@link SocialActivityLimitUtil} to access the social activity limit persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 042 */ 043 044 /** 045 * Returns all the social activity limits where groupId = ?. 046 * 047 * @param groupId the group ID 048 * @return the matching social activity limits 049 */ 050 public java.util.List<SocialActivityLimit> findByGroupId(long groupId); 051 052 /** 053 * Returns a range of all the social activity limits where groupId = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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 groupId the group ID 060 * @param start the lower bound of the range of social activity limits 061 * @param end the upper bound of the range of social activity limits (not inclusive) 062 * @return the range of matching social activity limits 063 */ 064 public java.util.List<SocialActivityLimit> findByGroupId(long groupId, 065 int start, int end); 066 067 /** 068 * Returns an ordered range of all the social activity limits where groupId = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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 groupId the group ID 075 * @param start the lower bound of the range of social activity limits 076 * @param end the upper bound of the range of social activity limits (not inclusive) 077 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 078 * @return the ordered range of matching social activity limits 079 */ 080 public java.util.List<SocialActivityLimit> findByGroupId(long groupId, 081 int start, int end, 082 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 083 084 /** 085 * Returns an ordered range of all the social activity limits where groupId = ?. 086 * 087 * <p> 088 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 089 * </p> 090 * 091 * @param groupId the group ID 092 * @param start the lower bound of the range of social activity limits 093 * @param end the upper bound of the range of social activity limits (not inclusive) 094 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 095 * @param retrieveFromCache whether to retrieve from the finder cache 096 * @return the ordered range of matching social activity limits 097 */ 098 public java.util.List<SocialActivityLimit> findByGroupId(long groupId, 099 int start, int end, 100 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator, 101 boolean retrieveFromCache); 102 103 /** 104 * Returns the first social activity limit in the ordered set where groupId = ?. 105 * 106 * @param groupId the group ID 107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 108 * @return the first matching social activity limit 109 * @throws NoSuchActivityLimitException if a matching social activity limit could not be found 110 */ 111 public SocialActivityLimit findByGroupId_First(long groupId, 112 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 113 throws NoSuchActivityLimitException; 114 115 /** 116 * Returns the first social activity limit in the ordered set where groupId = ?. 117 * 118 * @param groupId the group ID 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the first matching social activity limit, or <code>null</code> if a matching social activity limit could not be found 121 */ 122 public SocialActivityLimit fetchByGroupId_First(long groupId, 123 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 124 125 /** 126 * Returns the last social activity limit in the ordered set where groupId = ?. 127 * 128 * @param groupId the group ID 129 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 130 * @return the last matching social activity limit 131 * @throws NoSuchActivityLimitException if a matching social activity limit could not be found 132 */ 133 public SocialActivityLimit findByGroupId_Last(long groupId, 134 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 135 throws NoSuchActivityLimitException; 136 137 /** 138 * Returns the last social activity limit in the ordered set where groupId = ?. 139 * 140 * @param groupId the group ID 141 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 142 * @return the last matching social activity limit, or <code>null</code> if a matching social activity limit could not be found 143 */ 144 public SocialActivityLimit fetchByGroupId_Last(long groupId, 145 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 146 147 /** 148 * Returns the social activity limits before and after the current social activity limit in the ordered set where groupId = ?. 149 * 150 * @param activityLimitId the primary key of the current social activity limit 151 * @param groupId the group ID 152 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 153 * @return the previous, current, and next social activity limit 154 * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found 155 */ 156 public SocialActivityLimit[] findByGroupId_PrevAndNext( 157 long activityLimitId, long groupId, 158 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 159 throws NoSuchActivityLimitException; 160 161 /** 162 * Removes all the social activity limits where groupId = ? from the database. 163 * 164 * @param groupId the group ID 165 */ 166 public void removeByGroupId(long groupId); 167 168 /** 169 * Returns the number of social activity limits where groupId = ?. 170 * 171 * @param groupId the group ID 172 * @return the number of matching social activity limits 173 */ 174 public int countByGroupId(long groupId); 175 176 /** 177 * Returns all the social activity limits where userId = ?. 178 * 179 * @param userId the user ID 180 * @return the matching social activity limits 181 */ 182 public java.util.List<SocialActivityLimit> findByUserId(long userId); 183 184 /** 185 * Returns a range of all the social activity limits where userId = ?. 186 * 187 * <p> 188 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 189 * </p> 190 * 191 * @param userId the user ID 192 * @param start the lower bound of the range of social activity limits 193 * @param end the upper bound of the range of social activity limits (not inclusive) 194 * @return the range of matching social activity limits 195 */ 196 public java.util.List<SocialActivityLimit> findByUserId(long userId, 197 int start, int end); 198 199 /** 200 * Returns an ordered range of all the social activity limits where userId = ?. 201 * 202 * <p> 203 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 204 * </p> 205 * 206 * @param userId the user ID 207 * @param start the lower bound of the range of social activity limits 208 * @param end the upper bound of the range of social activity limits (not inclusive) 209 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 210 * @return the ordered range of matching social activity limits 211 */ 212 public java.util.List<SocialActivityLimit> findByUserId(long userId, 213 int start, int end, 214 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 215 216 /** 217 * Returns an ordered range of all the social activity limits where userId = ?. 218 * 219 * <p> 220 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 221 * </p> 222 * 223 * @param userId the user ID 224 * @param start the lower bound of the range of social activity limits 225 * @param end the upper bound of the range of social activity limits (not inclusive) 226 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 227 * @param retrieveFromCache whether to retrieve from the finder cache 228 * @return the ordered range of matching social activity limits 229 */ 230 public java.util.List<SocialActivityLimit> findByUserId(long userId, 231 int start, int end, 232 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator, 233 boolean retrieveFromCache); 234 235 /** 236 * Returns the first social activity limit in the ordered set where userId = ?. 237 * 238 * @param userId the user ID 239 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 240 * @return the first matching social activity limit 241 * @throws NoSuchActivityLimitException if a matching social activity limit could not be found 242 */ 243 public SocialActivityLimit findByUserId_First(long userId, 244 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 245 throws NoSuchActivityLimitException; 246 247 /** 248 * Returns the first social activity limit in the ordered set where userId = ?. 249 * 250 * @param userId the user ID 251 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 252 * @return the first matching social activity limit, or <code>null</code> if a matching social activity limit could not be found 253 */ 254 public SocialActivityLimit fetchByUserId_First(long userId, 255 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 256 257 /** 258 * Returns the last social activity limit in the ordered set where userId = ?. 259 * 260 * @param userId the user ID 261 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 262 * @return the last matching social activity limit 263 * @throws NoSuchActivityLimitException if a matching social activity limit could not be found 264 */ 265 public SocialActivityLimit findByUserId_Last(long userId, 266 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 267 throws NoSuchActivityLimitException; 268 269 /** 270 * Returns the last social activity limit in the ordered set where userId = ?. 271 * 272 * @param userId the user ID 273 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 274 * @return the last matching social activity limit, or <code>null</code> if a matching social activity limit could not be found 275 */ 276 public SocialActivityLimit fetchByUserId_Last(long userId, 277 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 278 279 /** 280 * Returns the social activity limits before and after the current social activity limit in the ordered set where userId = ?. 281 * 282 * @param activityLimitId the primary key of the current social activity limit 283 * @param userId the user ID 284 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 285 * @return the previous, current, and next social activity limit 286 * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found 287 */ 288 public SocialActivityLimit[] findByUserId_PrevAndNext( 289 long activityLimitId, long userId, 290 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 291 throws NoSuchActivityLimitException; 292 293 /** 294 * Removes all the social activity limits where userId = ? from the database. 295 * 296 * @param userId the user ID 297 */ 298 public void removeByUserId(long userId); 299 300 /** 301 * Returns the number of social activity limits where userId = ?. 302 * 303 * @param userId the user ID 304 * @return the number of matching social activity limits 305 */ 306 public int countByUserId(long userId); 307 308 /** 309 * Returns all the social activity limits where classNameId = ? and classPK = ?. 310 * 311 * @param classNameId the class name ID 312 * @param classPK the class p k 313 * @return the matching social activity limits 314 */ 315 public java.util.List<SocialActivityLimit> findByC_C(long classNameId, 316 long classPK); 317 318 /** 319 * Returns a range of all the social activity limits where classNameId = ? and classPK = ?. 320 * 321 * <p> 322 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 323 * </p> 324 * 325 * @param classNameId the class name ID 326 * @param classPK the class p k 327 * @param start the lower bound of the range of social activity limits 328 * @param end the upper bound of the range of social activity limits (not inclusive) 329 * @return the range of matching social activity limits 330 */ 331 public java.util.List<SocialActivityLimit> findByC_C(long classNameId, 332 long classPK, int start, int end); 333 334 /** 335 * Returns an ordered range of all the social activity limits where classNameId = ? and classPK = ?. 336 * 337 * <p> 338 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 339 * </p> 340 * 341 * @param classNameId the class name ID 342 * @param classPK the class p k 343 * @param start the lower bound of the range of social activity limits 344 * @param end the upper bound of the range of social activity limits (not inclusive) 345 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 346 * @return the ordered range of matching social activity limits 347 */ 348 public java.util.List<SocialActivityLimit> findByC_C(long classNameId, 349 long classPK, int start, int end, 350 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 351 352 /** 353 * Returns an ordered range of all the social activity limits where classNameId = ? and classPK = ?. 354 * 355 * <p> 356 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 357 * </p> 358 * 359 * @param classNameId the class name ID 360 * @param classPK the class p k 361 * @param start the lower bound of the range of social activity limits 362 * @param end the upper bound of the range of social activity limits (not inclusive) 363 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 364 * @param retrieveFromCache whether to retrieve from the finder cache 365 * @return the ordered range of matching social activity limits 366 */ 367 public java.util.List<SocialActivityLimit> findByC_C(long classNameId, 368 long classPK, int start, int end, 369 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator, 370 boolean retrieveFromCache); 371 372 /** 373 * Returns the first social activity limit in the ordered set where classNameId = ? and classPK = ?. 374 * 375 * @param classNameId the class name ID 376 * @param classPK the class p k 377 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 378 * @return the first matching social activity limit 379 * @throws NoSuchActivityLimitException if a matching social activity limit could not be found 380 */ 381 public SocialActivityLimit findByC_C_First(long classNameId, long classPK, 382 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 383 throws NoSuchActivityLimitException; 384 385 /** 386 * Returns the first social activity limit in the ordered set where classNameId = ? and classPK = ?. 387 * 388 * @param classNameId the class name ID 389 * @param classPK the class p k 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the first matching social activity limit, or <code>null</code> if a matching social activity limit could not be found 392 */ 393 public SocialActivityLimit fetchByC_C_First(long classNameId, long classPK, 394 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 395 396 /** 397 * Returns the last social activity limit in the ordered set where classNameId = ? and classPK = ?. 398 * 399 * @param classNameId the class name ID 400 * @param classPK the class p k 401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 402 * @return the last matching social activity limit 403 * @throws NoSuchActivityLimitException if a matching social activity limit could not be found 404 */ 405 public SocialActivityLimit findByC_C_Last(long classNameId, long classPK, 406 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 407 throws NoSuchActivityLimitException; 408 409 /** 410 * Returns the last social activity limit in the ordered set where classNameId = ? and classPK = ?. 411 * 412 * @param classNameId the class name ID 413 * @param classPK the class p k 414 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 415 * @return the last matching social activity limit, or <code>null</code> if a matching social activity limit could not be found 416 */ 417 public SocialActivityLimit fetchByC_C_Last(long classNameId, long classPK, 418 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 419 420 /** 421 * Returns the social activity limits before and after the current social activity limit in the ordered set where classNameId = ? and classPK = ?. 422 * 423 * @param activityLimitId the primary key of the current social activity limit 424 * @param classNameId the class name ID 425 * @param classPK the class p k 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the previous, current, and next social activity limit 428 * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found 429 */ 430 public SocialActivityLimit[] findByC_C_PrevAndNext(long activityLimitId, 431 long classNameId, long classPK, 432 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator) 433 throws NoSuchActivityLimitException; 434 435 /** 436 * Removes all the social activity limits where classNameId = ? and classPK = ? from the database. 437 * 438 * @param classNameId the class name ID 439 * @param classPK the class p k 440 */ 441 public void removeByC_C(long classNameId, long classPK); 442 443 /** 444 * Returns the number of social activity limits where classNameId = ? and classPK = ?. 445 * 446 * @param classNameId the class name ID 447 * @param classPK the class p k 448 * @return the number of matching social activity limits 449 */ 450 public int countByC_C(long classNameId, long classPK); 451 452 /** 453 * Returns the social activity limit where groupId = ? and userId = ? and classNameId = ? and classPK = ? and activityType = ? and activityCounterName = ? or throws a {@link NoSuchActivityLimitException} if it could not be found. 454 * 455 * @param groupId the group ID 456 * @param userId the user ID 457 * @param classNameId the class name ID 458 * @param classPK the class p k 459 * @param activityType the activity type 460 * @param activityCounterName the activity counter name 461 * @return the matching social activity limit 462 * @throws NoSuchActivityLimitException if a matching social activity limit could not be found 463 */ 464 public SocialActivityLimit findByG_U_C_C_A_A(long groupId, long userId, 465 long classNameId, long classPK, int activityType, 466 java.lang.String activityCounterName) 467 throws NoSuchActivityLimitException; 468 469 /** 470 * Returns the social activity limit where groupId = ? and userId = ? and classNameId = ? and classPK = ? and activityType = ? and activityCounterName = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 471 * 472 * @param groupId the group ID 473 * @param userId the user ID 474 * @param classNameId the class name ID 475 * @param classPK the class p k 476 * @param activityType the activity type 477 * @param activityCounterName the activity counter name 478 * @return the matching social activity limit, or <code>null</code> if a matching social activity limit could not be found 479 */ 480 public SocialActivityLimit fetchByG_U_C_C_A_A(long groupId, long userId, 481 long classNameId, long classPK, int activityType, 482 java.lang.String activityCounterName); 483 484 /** 485 * Returns the social activity limit where groupId = ? and userId = ? and classNameId = ? and classPK = ? and activityType = ? and activityCounterName = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 486 * 487 * @param groupId the group ID 488 * @param userId the user ID 489 * @param classNameId the class name ID 490 * @param classPK the class p k 491 * @param activityType the activity type 492 * @param activityCounterName the activity counter name 493 * @param retrieveFromCache whether to retrieve from the finder cache 494 * @return the matching social activity limit, or <code>null</code> if a matching social activity limit could not be found 495 */ 496 public SocialActivityLimit fetchByG_U_C_C_A_A(long groupId, long userId, 497 long classNameId, long classPK, int activityType, 498 java.lang.String activityCounterName, boolean retrieveFromCache); 499 500 /** 501 * Removes the social activity limit where groupId = ? and userId = ? and classNameId = ? and classPK = ? and activityType = ? and activityCounterName = ? from the database. 502 * 503 * @param groupId the group ID 504 * @param userId the user ID 505 * @param classNameId the class name ID 506 * @param classPK the class p k 507 * @param activityType the activity type 508 * @param activityCounterName the activity counter name 509 * @return the social activity limit that was removed 510 */ 511 public SocialActivityLimit removeByG_U_C_C_A_A(long groupId, long userId, 512 long classNameId, long classPK, int activityType, 513 java.lang.String activityCounterName) 514 throws NoSuchActivityLimitException; 515 516 /** 517 * Returns the number of social activity limits where groupId = ? and userId = ? and classNameId = ? and classPK = ? and activityType = ? and activityCounterName = ?. 518 * 519 * @param groupId the group ID 520 * @param userId the user ID 521 * @param classNameId the class name ID 522 * @param classPK the class p k 523 * @param activityType the activity type 524 * @param activityCounterName the activity counter name 525 * @return the number of matching social activity limits 526 */ 527 public int countByG_U_C_C_A_A(long groupId, long userId, long classNameId, 528 long classPK, int activityType, java.lang.String activityCounterName); 529 530 /** 531 * Caches the social activity limit in the entity cache if it is enabled. 532 * 533 * @param socialActivityLimit the social activity limit 534 */ 535 public void cacheResult(SocialActivityLimit socialActivityLimit); 536 537 /** 538 * Caches the social activity limits in the entity cache if it is enabled. 539 * 540 * @param socialActivityLimits the social activity limits 541 */ 542 public void cacheResult( 543 java.util.List<SocialActivityLimit> socialActivityLimits); 544 545 /** 546 * Creates a new social activity limit with the primary key. Does not add the social activity limit to the database. 547 * 548 * @param activityLimitId the primary key for the new social activity limit 549 * @return the new social activity limit 550 */ 551 public SocialActivityLimit create(long activityLimitId); 552 553 /** 554 * Removes the social activity limit with the primary key from the database. Also notifies the appropriate model listeners. 555 * 556 * @param activityLimitId the primary key of the social activity limit 557 * @return the social activity limit that was removed 558 * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found 559 */ 560 public SocialActivityLimit remove(long activityLimitId) 561 throws NoSuchActivityLimitException; 562 563 public SocialActivityLimit updateImpl( 564 SocialActivityLimit socialActivityLimit); 565 566 /** 567 * Returns the social activity limit with the primary key or throws a {@link NoSuchActivityLimitException} if it could not be found. 568 * 569 * @param activityLimitId the primary key of the social activity limit 570 * @return the social activity limit 571 * @throws NoSuchActivityLimitException if a social activity limit with the primary key could not be found 572 */ 573 public SocialActivityLimit findByPrimaryKey(long activityLimitId) 574 throws NoSuchActivityLimitException; 575 576 /** 577 * Returns the social activity limit with the primary key or returns <code>null</code> if it could not be found. 578 * 579 * @param activityLimitId the primary key of the social activity limit 580 * @return the social activity limit, or <code>null</code> if a social activity limit with the primary key could not be found 581 */ 582 public SocialActivityLimit fetchByPrimaryKey(long activityLimitId); 583 584 @Override 585 public java.util.Map<java.io.Serializable, SocialActivityLimit> fetchByPrimaryKeys( 586 java.util.Set<java.io.Serializable> primaryKeys); 587 588 /** 589 * Returns all the social activity limits. 590 * 591 * @return the social activity limits 592 */ 593 public java.util.List<SocialActivityLimit> findAll(); 594 595 /** 596 * Returns a range of all the social activity limits. 597 * 598 * <p> 599 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 600 * </p> 601 * 602 * @param start the lower bound of the range of social activity limits 603 * @param end the upper bound of the range of social activity limits (not inclusive) 604 * @return the range of social activity limits 605 */ 606 public java.util.List<SocialActivityLimit> findAll(int start, int end); 607 608 /** 609 * Returns an ordered range of all the social activity limits. 610 * 611 * <p> 612 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 613 * </p> 614 * 615 * @param start the lower bound of the range of social activity limits 616 * @param end the upper bound of the range of social activity limits (not inclusive) 617 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 618 * @return the ordered range of social activity limits 619 */ 620 public java.util.List<SocialActivityLimit> findAll(int start, int end, 621 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator); 622 623 /** 624 * Returns an ordered range of all the social activity limits. 625 * 626 * <p> 627 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SocialActivityLimitModelImpl}. 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. 628 * </p> 629 * 630 * @param start the lower bound of the range of social activity limits 631 * @param end the upper bound of the range of social activity limits (not inclusive) 632 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 633 * @param retrieveFromCache whether to retrieve from the finder cache 634 * @return the ordered range of social activity limits 635 */ 636 public java.util.List<SocialActivityLimit> findAll(int start, int end, 637 com.liferay.portal.kernel.util.OrderByComparator<SocialActivityLimit> orderByComparator, 638 boolean retrieveFromCache); 639 640 /** 641 * Removes all the social activity limits from the database. 642 */ 643 public void removeAll(); 644 645 /** 646 * Returns the number of social activity limits. 647 * 648 * @return the number of social activity limits 649 */ 650 public int countAll(); 651 }