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