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