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 an ordered range of all the social activities where groupId = ?. 160 * 161 * <p> 162 * 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. 163 * </p> 164 * 165 * @param groupId the group ID 166 * @param start the lower bound of the range of social activities 167 * @param end the upper bound of the range of social activities (not inclusive) 168 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 169 * @param retrieveFromCache whether to retrieve from the finder cache 170 * @return the ordered range of matching social activities 171 */ 172 public static List<SocialActivity> findByGroupId(long groupId, int start, 173 int end, OrderByComparator<SocialActivity> orderByComparator, 174 boolean retrieveFromCache) { 175 return getPersistence() 176 .findByGroupId(groupId, start, end, orderByComparator, 177 retrieveFromCache); 178 } 179 180 /** 181 * Returns the first social activity in the ordered set where groupId = ?. 182 * 183 * @param groupId the group ID 184 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 185 * @return the first matching social activity 186 * @throws NoSuchActivityException if a matching social activity could not be found 187 */ 188 public static SocialActivity findByGroupId_First(long groupId, 189 OrderByComparator<SocialActivity> orderByComparator) 190 throws com.liferay.portlet.social.exception.NoSuchActivityException { 191 return getPersistence().findByGroupId_First(groupId, orderByComparator); 192 } 193 194 /** 195 * Returns the first social activity in the ordered set where groupId = ?. 196 * 197 * @param groupId the group ID 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 200 */ 201 public static SocialActivity fetchByGroupId_First(long groupId, 202 OrderByComparator<SocialActivity> orderByComparator) { 203 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 204 } 205 206 /** 207 * Returns the last social activity in the ordered set where groupId = ?. 208 * 209 * @param groupId the group ID 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the last matching social activity 212 * @throws NoSuchActivityException if a matching social activity could not be found 213 */ 214 public static SocialActivity findByGroupId_Last(long groupId, 215 OrderByComparator<SocialActivity> orderByComparator) 216 throws com.liferay.portlet.social.exception.NoSuchActivityException { 217 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 218 } 219 220 /** 221 * Returns the last social activity in the ordered set where groupId = ?. 222 * 223 * @param groupId the group ID 224 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 225 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 226 */ 227 public static SocialActivity fetchByGroupId_Last(long groupId, 228 OrderByComparator<SocialActivity> orderByComparator) { 229 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 230 } 231 232 /** 233 * Returns the social activities before and after the current social activity in the ordered set where groupId = ?. 234 * 235 * @param activityId the primary key of the current social activity 236 * @param groupId the group ID 237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 238 * @return the previous, current, and next social activity 239 * @throws NoSuchActivityException if a social activity with the primary key could not be found 240 */ 241 public static SocialActivity[] findByGroupId_PrevAndNext(long activityId, 242 long groupId, OrderByComparator<SocialActivity> orderByComparator) 243 throws com.liferay.portlet.social.exception.NoSuchActivityException { 244 return getPersistence() 245 .findByGroupId_PrevAndNext(activityId, groupId, 246 orderByComparator); 247 } 248 249 /** 250 * Removes all the social activities where groupId = ? from the database. 251 * 252 * @param groupId the group ID 253 */ 254 public static void removeByGroupId(long groupId) { 255 getPersistence().removeByGroupId(groupId); 256 } 257 258 /** 259 * Returns the number of social activities where groupId = ?. 260 * 261 * @param groupId the group ID 262 * @return the number of matching social activities 263 */ 264 public static int countByGroupId(long groupId) { 265 return getPersistence().countByGroupId(groupId); 266 } 267 268 /** 269 * Returns all the social activities where companyId = ?. 270 * 271 * @param companyId the company ID 272 * @return the matching social activities 273 */ 274 public static List<SocialActivity> findByCompanyId(long companyId) { 275 return getPersistence().findByCompanyId(companyId); 276 } 277 278 /** 279 * Returns a range of all the social activities where companyId = ?. 280 * 281 * <p> 282 * 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. 283 * </p> 284 * 285 * @param companyId the company ID 286 * @param start the lower bound of the range of social activities 287 * @param end the upper bound of the range of social activities (not inclusive) 288 * @return the range of matching social activities 289 */ 290 public static List<SocialActivity> findByCompanyId(long companyId, 291 int start, int end) { 292 return getPersistence().findByCompanyId(companyId, start, end); 293 } 294 295 /** 296 * Returns an ordered range of all the social activities where companyId = ?. 297 * 298 * <p> 299 * 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. 300 * </p> 301 * 302 * @param companyId the company ID 303 * @param start the lower bound of the range of social activities 304 * @param end the upper bound of the range of social activities (not inclusive) 305 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 306 * @return the ordered range of matching social activities 307 */ 308 public static List<SocialActivity> findByCompanyId(long companyId, 309 int start, int end, OrderByComparator<SocialActivity> orderByComparator) { 310 return getPersistence() 311 .findByCompanyId(companyId, start, end, orderByComparator); 312 } 313 314 /** 315 * Returns an ordered range of all the social activities where companyId = ?. 316 * 317 * <p> 318 * 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. 319 * </p> 320 * 321 * @param companyId the company ID 322 * @param start the lower bound of the range of social activities 323 * @param end the upper bound of the range of social activities (not inclusive) 324 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 325 * @param retrieveFromCache whether to retrieve from the finder cache 326 * @return the ordered range of matching social activities 327 */ 328 public static List<SocialActivity> findByCompanyId(long companyId, 329 int start, int end, 330 OrderByComparator<SocialActivity> orderByComparator, 331 boolean retrieveFromCache) { 332 return getPersistence() 333 .findByCompanyId(companyId, start, end, orderByComparator, 334 retrieveFromCache); 335 } 336 337 /** 338 * Returns the first social activity in the ordered set where companyId = ?. 339 * 340 * @param companyId the company ID 341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 342 * @return the first matching social activity 343 * @throws NoSuchActivityException if a matching social activity could not be found 344 */ 345 public static SocialActivity findByCompanyId_First(long companyId, 346 OrderByComparator<SocialActivity> orderByComparator) 347 throws com.liferay.portlet.social.exception.NoSuchActivityException { 348 return getPersistence() 349 .findByCompanyId_First(companyId, orderByComparator); 350 } 351 352 /** 353 * Returns the first social activity in the ordered set where companyId = ?. 354 * 355 * @param companyId the company ID 356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 357 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 358 */ 359 public static SocialActivity fetchByCompanyId_First(long companyId, 360 OrderByComparator<SocialActivity> orderByComparator) { 361 return getPersistence() 362 .fetchByCompanyId_First(companyId, orderByComparator); 363 } 364 365 /** 366 * Returns the last social activity in the ordered set where companyId = ?. 367 * 368 * @param companyId the company ID 369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 370 * @return the last matching social activity 371 * @throws NoSuchActivityException if a matching social activity could not be found 372 */ 373 public static SocialActivity findByCompanyId_Last(long companyId, 374 OrderByComparator<SocialActivity> orderByComparator) 375 throws com.liferay.portlet.social.exception.NoSuchActivityException { 376 return getPersistence() 377 .findByCompanyId_Last(companyId, orderByComparator); 378 } 379 380 /** 381 * Returns the last social activity in the ordered set where companyId = ?. 382 * 383 * @param companyId the company ID 384 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 385 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 386 */ 387 public static SocialActivity fetchByCompanyId_Last(long companyId, 388 OrderByComparator<SocialActivity> orderByComparator) { 389 return getPersistence() 390 .fetchByCompanyId_Last(companyId, orderByComparator); 391 } 392 393 /** 394 * Returns the social activities before and after the current social activity in the ordered set where companyId = ?. 395 * 396 * @param activityId the primary key of the current social activity 397 * @param companyId the company ID 398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 399 * @return the previous, current, and next social activity 400 * @throws NoSuchActivityException if a social activity with the primary key could not be found 401 */ 402 public static SocialActivity[] findByCompanyId_PrevAndNext( 403 long activityId, long companyId, 404 OrderByComparator<SocialActivity> orderByComparator) 405 throws com.liferay.portlet.social.exception.NoSuchActivityException { 406 return getPersistence() 407 .findByCompanyId_PrevAndNext(activityId, companyId, 408 orderByComparator); 409 } 410 411 /** 412 * Removes all the social activities where companyId = ? from the database. 413 * 414 * @param companyId the company ID 415 */ 416 public static void removeByCompanyId(long companyId) { 417 getPersistence().removeByCompanyId(companyId); 418 } 419 420 /** 421 * Returns the number of social activities where companyId = ?. 422 * 423 * @param companyId the company ID 424 * @return the number of matching social activities 425 */ 426 public static int countByCompanyId(long companyId) { 427 return getPersistence().countByCompanyId(companyId); 428 } 429 430 /** 431 * Returns all the social activities where userId = ?. 432 * 433 * @param userId the user ID 434 * @return the matching social activities 435 */ 436 public static List<SocialActivity> findByUserId(long userId) { 437 return getPersistence().findByUserId(userId); 438 } 439 440 /** 441 * Returns a range of all the social activities where userId = ?. 442 * 443 * <p> 444 * 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. 445 * </p> 446 * 447 * @param userId the user ID 448 * @param start the lower bound of the range of social activities 449 * @param end the upper bound of the range of social activities (not inclusive) 450 * @return the range of matching social activities 451 */ 452 public static List<SocialActivity> findByUserId(long userId, int start, 453 int end) { 454 return getPersistence().findByUserId(userId, start, end); 455 } 456 457 /** 458 * Returns an ordered range of all the social activities where userId = ?. 459 * 460 * <p> 461 * 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. 462 * </p> 463 * 464 * @param userId the user ID 465 * @param start the lower bound of the range of social activities 466 * @param end the upper bound of the range of social activities (not inclusive) 467 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 468 * @return the ordered range of matching social activities 469 */ 470 public static List<SocialActivity> findByUserId(long userId, int start, 471 int end, OrderByComparator<SocialActivity> orderByComparator) { 472 return getPersistence() 473 .findByUserId(userId, start, end, orderByComparator); 474 } 475 476 /** 477 * Returns an ordered range of all the social activities where userId = ?. 478 * 479 * <p> 480 * 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. 481 * </p> 482 * 483 * @param userId the user ID 484 * @param start the lower bound of the range of social activities 485 * @param end the upper bound of the range of social activities (not inclusive) 486 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 487 * @param retrieveFromCache whether to retrieve from the finder cache 488 * @return the ordered range of matching social activities 489 */ 490 public static List<SocialActivity> findByUserId(long userId, int start, 491 int end, OrderByComparator<SocialActivity> orderByComparator, 492 boolean retrieveFromCache) { 493 return getPersistence() 494 .findByUserId(userId, start, end, orderByComparator, 495 retrieveFromCache); 496 } 497 498 /** 499 * Returns the first social activity in the ordered set where userId = ?. 500 * 501 * @param userId the user ID 502 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 503 * @return the first matching social activity 504 * @throws NoSuchActivityException if a matching social activity could not be found 505 */ 506 public static SocialActivity findByUserId_First(long userId, 507 OrderByComparator<SocialActivity> orderByComparator) 508 throws com.liferay.portlet.social.exception.NoSuchActivityException { 509 return getPersistence().findByUserId_First(userId, orderByComparator); 510 } 511 512 /** 513 * Returns the first social activity in the ordered set where userId = ?. 514 * 515 * @param userId the user ID 516 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 517 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 518 */ 519 public static SocialActivity fetchByUserId_First(long userId, 520 OrderByComparator<SocialActivity> orderByComparator) { 521 return getPersistence().fetchByUserId_First(userId, orderByComparator); 522 } 523 524 /** 525 * Returns the last social activity in the ordered set where userId = ?. 526 * 527 * @param userId the user ID 528 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 529 * @return the last matching social activity 530 * @throws NoSuchActivityException if a matching social activity could not be found 531 */ 532 public static SocialActivity findByUserId_Last(long userId, 533 OrderByComparator<SocialActivity> orderByComparator) 534 throws com.liferay.portlet.social.exception.NoSuchActivityException { 535 return getPersistence().findByUserId_Last(userId, orderByComparator); 536 } 537 538 /** 539 * Returns the last social activity in the ordered set where userId = ?. 540 * 541 * @param userId the user ID 542 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 543 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 544 */ 545 public static SocialActivity fetchByUserId_Last(long userId, 546 OrderByComparator<SocialActivity> orderByComparator) { 547 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 548 } 549 550 /** 551 * Returns the social activities before and after the current social activity in the ordered set where userId = ?. 552 * 553 * @param activityId the primary key of the current social activity 554 * @param userId the user ID 555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 556 * @return the previous, current, and next social activity 557 * @throws NoSuchActivityException if a social activity with the primary key could not be found 558 */ 559 public static SocialActivity[] findByUserId_PrevAndNext(long activityId, 560 long userId, OrderByComparator<SocialActivity> orderByComparator) 561 throws com.liferay.portlet.social.exception.NoSuchActivityException { 562 return getPersistence() 563 .findByUserId_PrevAndNext(activityId, userId, 564 orderByComparator); 565 } 566 567 /** 568 * Removes all the social activities where userId = ? from the database. 569 * 570 * @param userId the user ID 571 */ 572 public static void removeByUserId(long userId) { 573 getPersistence().removeByUserId(userId); 574 } 575 576 /** 577 * Returns the number of social activities where userId = ?. 578 * 579 * @param userId the user ID 580 * @return the number of matching social activities 581 */ 582 public static int countByUserId(long userId) { 583 return getPersistence().countByUserId(userId); 584 } 585 586 /** 587 * Returns all the social activities where activitySetId = ?. 588 * 589 * @param activitySetId the activity set ID 590 * @return the matching social activities 591 */ 592 public static List<SocialActivity> findByActivitySetId(long activitySetId) { 593 return getPersistence().findByActivitySetId(activitySetId); 594 } 595 596 /** 597 * Returns a range of all the social activities where activitySetId = ?. 598 * 599 * <p> 600 * 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. 601 * </p> 602 * 603 * @param activitySetId the activity set ID 604 * @param start the lower bound of the range of social activities 605 * @param end the upper bound of the range of social activities (not inclusive) 606 * @return the range of matching social activities 607 */ 608 public static List<SocialActivity> findByActivitySetId(long activitySetId, 609 int start, int end) { 610 return getPersistence().findByActivitySetId(activitySetId, start, end); 611 } 612 613 /** 614 * Returns an ordered range of all the social activities where activitySetId = ?. 615 * 616 * <p> 617 * 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. 618 * </p> 619 * 620 * @param activitySetId the activity set ID 621 * @param start the lower bound of the range of social activities 622 * @param end the upper bound of the range of social activities (not inclusive) 623 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 624 * @return the ordered range of matching social activities 625 */ 626 public static List<SocialActivity> findByActivitySetId(long activitySetId, 627 int start, int end, OrderByComparator<SocialActivity> orderByComparator) { 628 return getPersistence() 629 .findByActivitySetId(activitySetId, start, end, 630 orderByComparator); 631 } 632 633 /** 634 * Returns an ordered range of all the social activities where activitySetId = ?. 635 * 636 * <p> 637 * 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. 638 * </p> 639 * 640 * @param activitySetId the activity set ID 641 * @param start the lower bound of the range of social activities 642 * @param end the upper bound of the range of social activities (not inclusive) 643 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 644 * @param retrieveFromCache whether to retrieve from the finder cache 645 * @return the ordered range of matching social activities 646 */ 647 public static List<SocialActivity> findByActivitySetId(long activitySetId, 648 int start, int end, 649 OrderByComparator<SocialActivity> orderByComparator, 650 boolean retrieveFromCache) { 651 return getPersistence() 652 .findByActivitySetId(activitySetId, start, end, 653 orderByComparator, retrieveFromCache); 654 } 655 656 /** 657 * Returns the first social activity in the ordered set where activitySetId = ?. 658 * 659 * @param activitySetId the activity set ID 660 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 661 * @return the first matching social activity 662 * @throws NoSuchActivityException if a matching social activity could not be found 663 */ 664 public static SocialActivity findByActivitySetId_First(long activitySetId, 665 OrderByComparator<SocialActivity> orderByComparator) 666 throws com.liferay.portlet.social.exception.NoSuchActivityException { 667 return getPersistence() 668 .findByActivitySetId_First(activitySetId, orderByComparator); 669 } 670 671 /** 672 * Returns the first social activity in the ordered set where activitySetId = ?. 673 * 674 * @param activitySetId the activity set ID 675 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 676 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 677 */ 678 public static SocialActivity fetchByActivitySetId_First( 679 long activitySetId, OrderByComparator<SocialActivity> orderByComparator) { 680 return getPersistence() 681 .fetchByActivitySetId_First(activitySetId, orderByComparator); 682 } 683 684 /** 685 * Returns the last social activity in the ordered set where activitySetId = ?. 686 * 687 * @param activitySetId the activity set ID 688 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 689 * @return the last matching social activity 690 * @throws NoSuchActivityException if a matching social activity could not be found 691 */ 692 public static SocialActivity findByActivitySetId_Last(long activitySetId, 693 OrderByComparator<SocialActivity> orderByComparator) 694 throws com.liferay.portlet.social.exception.NoSuchActivityException { 695 return getPersistence() 696 .findByActivitySetId_Last(activitySetId, orderByComparator); 697 } 698 699 /** 700 * Returns the last social activity in the ordered set where activitySetId = ?. 701 * 702 * @param activitySetId the activity set ID 703 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 704 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 705 */ 706 public static SocialActivity fetchByActivitySetId_Last(long activitySetId, 707 OrderByComparator<SocialActivity> orderByComparator) { 708 return getPersistence() 709 .fetchByActivitySetId_Last(activitySetId, orderByComparator); 710 } 711 712 /** 713 * Returns the social activities before and after the current social activity in the ordered set where activitySetId = ?. 714 * 715 * @param activityId the primary key of the current social activity 716 * @param activitySetId the activity set ID 717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 718 * @return the previous, current, and next social activity 719 * @throws NoSuchActivityException if a social activity with the primary key could not be found 720 */ 721 public static SocialActivity[] findByActivitySetId_PrevAndNext( 722 long activityId, long activitySetId, 723 OrderByComparator<SocialActivity> orderByComparator) 724 throws com.liferay.portlet.social.exception.NoSuchActivityException { 725 return getPersistence() 726 .findByActivitySetId_PrevAndNext(activityId, activitySetId, 727 orderByComparator); 728 } 729 730 /** 731 * Removes all the social activities where activitySetId = ? from the database. 732 * 733 * @param activitySetId the activity set ID 734 */ 735 public static void removeByActivitySetId(long activitySetId) { 736 getPersistence().removeByActivitySetId(activitySetId); 737 } 738 739 /** 740 * Returns the number of social activities where activitySetId = ?. 741 * 742 * @param activitySetId the activity set ID 743 * @return the number of matching social activities 744 */ 745 public static int countByActivitySetId(long activitySetId) { 746 return getPersistence().countByActivitySetId(activitySetId); 747 } 748 749 /** 750 * Returns the social activity where mirrorActivityId = ? or throws a {@link NoSuchActivityException} if it could not be found. 751 * 752 * @param mirrorActivityId the mirror activity ID 753 * @return the matching social activity 754 * @throws NoSuchActivityException if a matching social activity could not be found 755 */ 756 public static SocialActivity findByMirrorActivityId(long mirrorActivityId) 757 throws com.liferay.portlet.social.exception.NoSuchActivityException { 758 return getPersistence().findByMirrorActivityId(mirrorActivityId); 759 } 760 761 /** 762 * Returns the social activity where mirrorActivityId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 763 * 764 * @param mirrorActivityId the mirror activity ID 765 * @return the matching social activity, or <code>null</code> if a matching social activity could not be found 766 */ 767 public static SocialActivity fetchByMirrorActivityId(long mirrorActivityId) { 768 return getPersistence().fetchByMirrorActivityId(mirrorActivityId); 769 } 770 771 /** 772 * Returns the social activity where mirrorActivityId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 773 * 774 * @param mirrorActivityId the mirror activity ID 775 * @param retrieveFromCache whether to retrieve from the finder cache 776 * @return the matching social activity, or <code>null</code> if a matching social activity could not be found 777 */ 778 public static SocialActivity fetchByMirrorActivityId( 779 long mirrorActivityId, boolean retrieveFromCache) { 780 return getPersistence() 781 .fetchByMirrorActivityId(mirrorActivityId, retrieveFromCache); 782 } 783 784 /** 785 * Removes the social activity where mirrorActivityId = ? from the database. 786 * 787 * @param mirrorActivityId the mirror activity ID 788 * @return the social activity that was removed 789 */ 790 public static SocialActivity removeByMirrorActivityId(long mirrorActivityId) 791 throws com.liferay.portlet.social.exception.NoSuchActivityException { 792 return getPersistence().removeByMirrorActivityId(mirrorActivityId); 793 } 794 795 /** 796 * Returns the number of social activities where mirrorActivityId = ?. 797 * 798 * @param mirrorActivityId the mirror activity ID 799 * @return the number of matching social activities 800 */ 801 public static int countByMirrorActivityId(long mirrorActivityId) { 802 return getPersistence().countByMirrorActivityId(mirrorActivityId); 803 } 804 805 /** 806 * Returns all the social activities where classNameId = ?. 807 * 808 * @param classNameId the class name ID 809 * @return the matching social activities 810 */ 811 public static List<SocialActivity> findByClassNameId(long classNameId) { 812 return getPersistence().findByClassNameId(classNameId); 813 } 814 815 /** 816 * Returns a range of all the social activities where classNameId = ?. 817 * 818 * <p> 819 * 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. 820 * </p> 821 * 822 * @param classNameId the class name ID 823 * @param start the lower bound of the range of social activities 824 * @param end the upper bound of the range of social activities (not inclusive) 825 * @return the range of matching social activities 826 */ 827 public static List<SocialActivity> findByClassNameId(long classNameId, 828 int start, int end) { 829 return getPersistence().findByClassNameId(classNameId, start, end); 830 } 831 832 /** 833 * Returns an ordered range of all the social activities where classNameId = ?. 834 * 835 * <p> 836 * 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. 837 * </p> 838 * 839 * @param classNameId the class name ID 840 * @param start the lower bound of the range of social activities 841 * @param end the upper bound of the range of social activities (not inclusive) 842 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 843 * @return the ordered range of matching social activities 844 */ 845 public static List<SocialActivity> findByClassNameId(long classNameId, 846 int start, int end, OrderByComparator<SocialActivity> orderByComparator) { 847 return getPersistence() 848 .findByClassNameId(classNameId, start, end, orderByComparator); 849 } 850 851 /** 852 * Returns an ordered range of all the social activities where classNameId = ?. 853 * 854 * <p> 855 * 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. 856 * </p> 857 * 858 * @param classNameId the class name ID 859 * @param start the lower bound of the range of social activities 860 * @param end the upper bound of the range of social activities (not inclusive) 861 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 862 * @param retrieveFromCache whether to retrieve from the finder cache 863 * @return the ordered range of matching social activities 864 */ 865 public static List<SocialActivity> findByClassNameId(long classNameId, 866 int start, int end, 867 OrderByComparator<SocialActivity> orderByComparator, 868 boolean retrieveFromCache) { 869 return getPersistence() 870 .findByClassNameId(classNameId, start, end, 871 orderByComparator, retrieveFromCache); 872 } 873 874 /** 875 * Returns the first social activity in the ordered set where classNameId = ?. 876 * 877 * @param classNameId the class name ID 878 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 879 * @return the first matching social activity 880 * @throws NoSuchActivityException if a matching social activity could not be found 881 */ 882 public static SocialActivity findByClassNameId_First(long classNameId, 883 OrderByComparator<SocialActivity> orderByComparator) 884 throws com.liferay.portlet.social.exception.NoSuchActivityException { 885 return getPersistence() 886 .findByClassNameId_First(classNameId, orderByComparator); 887 } 888 889 /** 890 * Returns the first social activity in the ordered set where classNameId = ?. 891 * 892 * @param classNameId the class name ID 893 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 894 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 895 */ 896 public static SocialActivity fetchByClassNameId_First(long classNameId, 897 OrderByComparator<SocialActivity> orderByComparator) { 898 return getPersistence() 899 .fetchByClassNameId_First(classNameId, orderByComparator); 900 } 901 902 /** 903 * Returns the last social activity in the ordered set where classNameId = ?. 904 * 905 * @param classNameId the class name ID 906 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 907 * @return the last matching social activity 908 * @throws NoSuchActivityException if a matching social activity could not be found 909 */ 910 public static SocialActivity findByClassNameId_Last(long classNameId, 911 OrderByComparator<SocialActivity> orderByComparator) 912 throws com.liferay.portlet.social.exception.NoSuchActivityException { 913 return getPersistence() 914 .findByClassNameId_Last(classNameId, orderByComparator); 915 } 916 917 /** 918 * Returns the last social activity in the ordered set where classNameId = ?. 919 * 920 * @param classNameId the class name ID 921 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 922 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 923 */ 924 public static SocialActivity fetchByClassNameId_Last(long classNameId, 925 OrderByComparator<SocialActivity> orderByComparator) { 926 return getPersistence() 927 .fetchByClassNameId_Last(classNameId, orderByComparator); 928 } 929 930 /** 931 * Returns the social activities before and after the current social activity in the ordered set where classNameId = ?. 932 * 933 * @param activityId the primary key of the current social activity 934 * @param classNameId the class name ID 935 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 936 * @return the previous, current, and next social activity 937 * @throws NoSuchActivityException if a social activity with the primary key could not be found 938 */ 939 public static SocialActivity[] findByClassNameId_PrevAndNext( 940 long activityId, long classNameId, 941 OrderByComparator<SocialActivity> orderByComparator) 942 throws com.liferay.portlet.social.exception.NoSuchActivityException { 943 return getPersistence() 944 .findByClassNameId_PrevAndNext(activityId, classNameId, 945 orderByComparator); 946 } 947 948 /** 949 * Removes all the social activities where classNameId = ? from the database. 950 * 951 * @param classNameId the class name ID 952 */ 953 public static void removeByClassNameId(long classNameId) { 954 getPersistence().removeByClassNameId(classNameId); 955 } 956 957 /** 958 * Returns the number of social activities where classNameId = ?. 959 * 960 * @param classNameId the class name ID 961 * @return the number of matching social activities 962 */ 963 public static int countByClassNameId(long classNameId) { 964 return getPersistence().countByClassNameId(classNameId); 965 } 966 967 /** 968 * Returns all the social activities where receiverUserId = ?. 969 * 970 * @param receiverUserId the receiver user ID 971 * @return the matching social activities 972 */ 973 public static List<SocialActivity> findByReceiverUserId(long receiverUserId) { 974 return getPersistence().findByReceiverUserId(receiverUserId); 975 } 976 977 /** 978 * Returns a range of all the social activities where receiverUserId = ?. 979 * 980 * <p> 981 * 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. 982 * </p> 983 * 984 * @param receiverUserId the receiver user ID 985 * @param start the lower bound of the range of social activities 986 * @param end the upper bound of the range of social activities (not inclusive) 987 * @return the range of matching social activities 988 */ 989 public static List<SocialActivity> findByReceiverUserId( 990 long receiverUserId, int start, int end) { 991 return getPersistence().findByReceiverUserId(receiverUserId, start, end); 992 } 993 994 /** 995 * Returns an ordered range of all the social activities where receiverUserId = ?. 996 * 997 * <p> 998 * 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. 999 * </p> 1000 * 1001 * @param receiverUserId the receiver user ID 1002 * @param start the lower bound of the range of social activities 1003 * @param end the upper bound of the range of social activities (not inclusive) 1004 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1005 * @return the ordered range of matching social activities 1006 */ 1007 public static List<SocialActivity> findByReceiverUserId( 1008 long receiverUserId, int start, int end, 1009 OrderByComparator<SocialActivity> orderByComparator) { 1010 return getPersistence() 1011 .findByReceiverUserId(receiverUserId, start, end, 1012 orderByComparator); 1013 } 1014 1015 /** 1016 * Returns an ordered range of all the social activities where receiverUserId = ?. 1017 * 1018 * <p> 1019 * 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. 1020 * </p> 1021 * 1022 * @param receiverUserId the receiver user ID 1023 * @param start the lower bound of the range of social activities 1024 * @param end the upper bound of the range of social activities (not inclusive) 1025 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1026 * @param retrieveFromCache whether to retrieve from the finder cache 1027 * @return the ordered range of matching social activities 1028 */ 1029 public static List<SocialActivity> findByReceiverUserId( 1030 long receiverUserId, int start, int end, 1031 OrderByComparator<SocialActivity> orderByComparator, 1032 boolean retrieveFromCache) { 1033 return getPersistence() 1034 .findByReceiverUserId(receiverUserId, start, end, 1035 orderByComparator, retrieveFromCache); 1036 } 1037 1038 /** 1039 * Returns the first social activity in the ordered set where receiverUserId = ?. 1040 * 1041 * @param receiverUserId the receiver user ID 1042 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1043 * @return the first matching social activity 1044 * @throws NoSuchActivityException if a matching social activity could not be found 1045 */ 1046 public static SocialActivity findByReceiverUserId_First( 1047 long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) 1048 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1049 return getPersistence() 1050 .findByReceiverUserId_First(receiverUserId, orderByComparator); 1051 } 1052 1053 /** 1054 * Returns the first social activity in the ordered set where receiverUserId = ?. 1055 * 1056 * @param receiverUserId the receiver user ID 1057 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1058 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 1059 */ 1060 public static SocialActivity fetchByReceiverUserId_First( 1061 long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) { 1062 return getPersistence() 1063 .fetchByReceiverUserId_First(receiverUserId, 1064 orderByComparator); 1065 } 1066 1067 /** 1068 * Returns the last social activity in the ordered set where receiverUserId = ?. 1069 * 1070 * @param receiverUserId the receiver user ID 1071 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1072 * @return the last matching social activity 1073 * @throws NoSuchActivityException if a matching social activity could not be found 1074 */ 1075 public static SocialActivity findByReceiverUserId_Last( 1076 long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) 1077 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1078 return getPersistence() 1079 .findByReceiverUserId_Last(receiverUserId, orderByComparator); 1080 } 1081 1082 /** 1083 * Returns the last social activity in the ordered set where receiverUserId = ?. 1084 * 1085 * @param receiverUserId the receiver user ID 1086 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1087 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 1088 */ 1089 public static SocialActivity fetchByReceiverUserId_Last( 1090 long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) { 1091 return getPersistence() 1092 .fetchByReceiverUserId_Last(receiverUserId, orderByComparator); 1093 } 1094 1095 /** 1096 * Returns the social activities before and after the current social activity in the ordered set where receiverUserId = ?. 1097 * 1098 * @param activityId the primary key of the current social activity 1099 * @param receiverUserId the receiver user ID 1100 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1101 * @return the previous, current, and next social activity 1102 * @throws NoSuchActivityException if a social activity with the primary key could not be found 1103 */ 1104 public static SocialActivity[] findByReceiverUserId_PrevAndNext( 1105 long activityId, long receiverUserId, 1106 OrderByComparator<SocialActivity> orderByComparator) 1107 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1108 return getPersistence() 1109 .findByReceiverUserId_PrevAndNext(activityId, 1110 receiverUserId, orderByComparator); 1111 } 1112 1113 /** 1114 * Removes all the social activities where receiverUserId = ? from the database. 1115 * 1116 * @param receiverUserId the receiver user ID 1117 */ 1118 public static void removeByReceiverUserId(long receiverUserId) { 1119 getPersistence().removeByReceiverUserId(receiverUserId); 1120 } 1121 1122 /** 1123 * Returns the number of social activities where receiverUserId = ?. 1124 * 1125 * @param receiverUserId the receiver user ID 1126 * @return the number of matching social activities 1127 */ 1128 public static int countByReceiverUserId(long receiverUserId) { 1129 return getPersistence().countByReceiverUserId(receiverUserId); 1130 } 1131 1132 /** 1133 * Returns all the social activities where classNameId = ? and classPK = ?. 1134 * 1135 * @param classNameId the class name ID 1136 * @param classPK the class p k 1137 * @return the matching social activities 1138 */ 1139 public static List<SocialActivity> findByC_C(long classNameId, long classPK) { 1140 return getPersistence().findByC_C(classNameId, classPK); 1141 } 1142 1143 /** 1144 * Returns a range of all the social activities where classNameId = ? and classPK = ?. 1145 * 1146 * <p> 1147 * 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. 1148 * </p> 1149 * 1150 * @param classNameId the class name ID 1151 * @param classPK the class p k 1152 * @param start the lower bound of the range of social activities 1153 * @param end the upper bound of the range of social activities (not inclusive) 1154 * @return the range of matching social activities 1155 */ 1156 public static List<SocialActivity> findByC_C(long classNameId, 1157 long classPK, int start, int end) { 1158 return getPersistence().findByC_C(classNameId, classPK, start, end); 1159 } 1160 1161 /** 1162 * Returns an ordered range of all the social activities where 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 classNameId the class name ID 1169 * @param classPK the class p k 1170 * @param start the lower bound of the range of social activities 1171 * @param end the upper bound of the range of social activities (not inclusive) 1172 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1173 * @return the ordered range of matching social activities 1174 */ 1175 public static List<SocialActivity> findByC_C(long classNameId, 1176 long classPK, int start, int end, 1177 OrderByComparator<SocialActivity> orderByComparator) { 1178 return getPersistence() 1179 .findByC_C(classNameId, classPK, start, end, 1180 orderByComparator); 1181 } 1182 1183 /** 1184 * Returns an ordered range of all the social activities where classNameId = ? and classPK = ?. 1185 * 1186 * <p> 1187 * 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. 1188 * </p> 1189 * 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 * @param retrieveFromCache whether to retrieve from the finder cache 1196 * @return the ordered range of matching social activities 1197 */ 1198 public static List<SocialActivity> findByC_C(long classNameId, 1199 long classPK, int start, int end, 1200 OrderByComparator<SocialActivity> orderByComparator, 1201 boolean retrieveFromCache) { 1202 return getPersistence() 1203 .findByC_C(classNameId, classPK, start, end, 1204 orderByComparator, retrieveFromCache); 1205 } 1206 1207 /** 1208 * Returns the first social activity in the ordered set where classNameId = ? and classPK = ?. 1209 * 1210 * @param classNameId the class name ID 1211 * @param classPK the class p k 1212 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1213 * @return the first matching social activity 1214 * @throws NoSuchActivityException if a matching social activity could not be found 1215 */ 1216 public static SocialActivity findByC_C_First(long classNameId, 1217 long classPK, OrderByComparator<SocialActivity> orderByComparator) 1218 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1219 return getPersistence() 1220 .findByC_C_First(classNameId, classPK, orderByComparator); 1221 } 1222 1223 /** 1224 * Returns the first social activity in the ordered set where classNameId = ? and classPK = ?. 1225 * 1226 * @param classNameId the class name ID 1227 * @param classPK the class p k 1228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1229 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 1230 */ 1231 public static SocialActivity fetchByC_C_First(long classNameId, 1232 long classPK, OrderByComparator<SocialActivity> orderByComparator) { 1233 return getPersistence() 1234 .fetchByC_C_First(classNameId, classPK, orderByComparator); 1235 } 1236 1237 /** 1238 * Returns the last social activity in the ordered set where classNameId = ? and classPK = ?. 1239 * 1240 * @param classNameId the class name ID 1241 * @param classPK the class p k 1242 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1243 * @return the last matching social activity 1244 * @throws NoSuchActivityException if a matching social activity could not be found 1245 */ 1246 public static SocialActivity findByC_C_Last(long classNameId, long classPK, 1247 OrderByComparator<SocialActivity> orderByComparator) 1248 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1249 return getPersistence() 1250 .findByC_C_Last(classNameId, classPK, orderByComparator); 1251 } 1252 1253 /** 1254 * Returns the last social activity in the ordered set where classNameId = ? and classPK = ?. 1255 * 1256 * @param classNameId the class name ID 1257 * @param classPK the class p k 1258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1259 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 1260 */ 1261 public static SocialActivity fetchByC_C_Last(long classNameId, 1262 long classPK, OrderByComparator<SocialActivity> orderByComparator) { 1263 return getPersistence() 1264 .fetchByC_C_Last(classNameId, classPK, orderByComparator); 1265 } 1266 1267 /** 1268 * Returns the social activities before and after the current social activity in the ordered set where classNameId = ? and classPK = ?. 1269 * 1270 * @param activityId the primary key of the current social activity 1271 * @param classNameId the class name ID 1272 * @param classPK the class p k 1273 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1274 * @return the previous, current, and next social activity 1275 * @throws NoSuchActivityException if a social activity with the primary key could not be found 1276 */ 1277 public static SocialActivity[] findByC_C_PrevAndNext(long activityId, 1278 long classNameId, long classPK, 1279 OrderByComparator<SocialActivity> orderByComparator) 1280 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1281 return getPersistence() 1282 .findByC_C_PrevAndNext(activityId, classNameId, classPK, 1283 orderByComparator); 1284 } 1285 1286 /** 1287 * Removes all the social activities where classNameId = ? and classPK = ? from the database. 1288 * 1289 * @param classNameId the class name ID 1290 * @param classPK the class p k 1291 */ 1292 public static void removeByC_C(long classNameId, long classPK) { 1293 getPersistence().removeByC_C(classNameId, classPK); 1294 } 1295 1296 /** 1297 * Returns the number of social activities where classNameId = ? and classPK = ?. 1298 * 1299 * @param classNameId the class name ID 1300 * @param classPK the class p k 1301 * @return the number of matching social activities 1302 */ 1303 public static int countByC_C(long classNameId, long classPK) { 1304 return getPersistence().countByC_C(classNameId, classPK); 1305 } 1306 1307 /** 1308 * Returns all the social activities where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1309 * 1310 * @param mirrorActivityId the mirror activity ID 1311 * @param classNameId the class name ID 1312 * @param classPK the class p k 1313 * @return the matching social activities 1314 */ 1315 public static List<SocialActivity> findByM_C_C(long mirrorActivityId, 1316 long classNameId, long classPK) { 1317 return getPersistence() 1318 .findByM_C_C(mirrorActivityId, classNameId, classPK); 1319 } 1320 1321 /** 1322 * Returns a range of all the social activities where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1323 * 1324 * <p> 1325 * 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. 1326 * </p> 1327 * 1328 * @param mirrorActivityId the mirror activity ID 1329 * @param classNameId the class name ID 1330 * @param classPK the class p k 1331 * @param start the lower bound of the range of social activities 1332 * @param end the upper bound of the range of social activities (not inclusive) 1333 * @return the range of matching social activities 1334 */ 1335 public static List<SocialActivity> findByM_C_C(long mirrorActivityId, 1336 long classNameId, long classPK, int start, int end) { 1337 return getPersistence() 1338 .findByM_C_C(mirrorActivityId, classNameId, classPK, start, 1339 end); 1340 } 1341 1342 /** 1343 * Returns an ordered range of all the social activities where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1344 * 1345 * <p> 1346 * 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. 1347 * </p> 1348 * 1349 * @param mirrorActivityId the mirror activity ID 1350 * @param classNameId the class name ID 1351 * @param classPK the class p k 1352 * @param start the lower bound of the range of social activities 1353 * @param end the upper bound of the range of social activities (not inclusive) 1354 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1355 * @return the ordered range of matching social activities 1356 */ 1357 public static List<SocialActivity> findByM_C_C(long mirrorActivityId, 1358 long classNameId, long classPK, int start, int end, 1359 OrderByComparator<SocialActivity> orderByComparator) { 1360 return getPersistence() 1361 .findByM_C_C(mirrorActivityId, classNameId, classPK, start, 1362 end, orderByComparator); 1363 } 1364 1365 /** 1366 * Returns an ordered range of all the social activities where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1367 * 1368 * <p> 1369 * 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. 1370 * </p> 1371 * 1372 * @param mirrorActivityId the mirror activity ID 1373 * @param classNameId the class name ID 1374 * @param classPK the class p k 1375 * @param start the lower bound of the range of social activities 1376 * @param end the upper bound of the range of social activities (not inclusive) 1377 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1378 * @param retrieveFromCache whether to retrieve from the finder cache 1379 * @return the ordered range of matching social activities 1380 */ 1381 public static List<SocialActivity> findByM_C_C(long mirrorActivityId, 1382 long classNameId, long classPK, int start, int end, 1383 OrderByComparator<SocialActivity> orderByComparator, 1384 boolean retrieveFromCache) { 1385 return getPersistence() 1386 .findByM_C_C(mirrorActivityId, classNameId, classPK, start, 1387 end, orderByComparator, retrieveFromCache); 1388 } 1389 1390 /** 1391 * Returns the first social activity in the ordered set where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1392 * 1393 * @param mirrorActivityId the mirror activity ID 1394 * @param classNameId the class name ID 1395 * @param classPK the class p k 1396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1397 * @return the first matching social activity 1398 * @throws NoSuchActivityException if a matching social activity could not be found 1399 */ 1400 public static SocialActivity findByM_C_C_First(long mirrorActivityId, 1401 long classNameId, long classPK, 1402 OrderByComparator<SocialActivity> orderByComparator) 1403 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1404 return getPersistence() 1405 .findByM_C_C_First(mirrorActivityId, classNameId, classPK, 1406 orderByComparator); 1407 } 1408 1409 /** 1410 * Returns the first social activity in the ordered set where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1411 * 1412 * @param mirrorActivityId the mirror activity ID 1413 * @param classNameId the class name ID 1414 * @param classPK the class p k 1415 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1416 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 1417 */ 1418 public static SocialActivity fetchByM_C_C_First(long mirrorActivityId, 1419 long classNameId, long classPK, 1420 OrderByComparator<SocialActivity> orderByComparator) { 1421 return getPersistence() 1422 .fetchByM_C_C_First(mirrorActivityId, classNameId, classPK, 1423 orderByComparator); 1424 } 1425 1426 /** 1427 * Returns the last social activity in the ordered set where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1428 * 1429 * @param mirrorActivityId the mirror activity ID 1430 * @param classNameId the class name ID 1431 * @param classPK the class p k 1432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1433 * @return the last matching social activity 1434 * @throws NoSuchActivityException if a matching social activity could not be found 1435 */ 1436 public static SocialActivity findByM_C_C_Last(long mirrorActivityId, 1437 long classNameId, long classPK, 1438 OrderByComparator<SocialActivity> orderByComparator) 1439 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1440 return getPersistence() 1441 .findByM_C_C_Last(mirrorActivityId, classNameId, classPK, 1442 orderByComparator); 1443 } 1444 1445 /** 1446 * Returns the last social activity in the ordered set where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1447 * 1448 * @param mirrorActivityId the mirror activity ID 1449 * @param classNameId the class name ID 1450 * @param classPK the class p k 1451 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1452 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 1453 */ 1454 public static SocialActivity fetchByM_C_C_Last(long mirrorActivityId, 1455 long classNameId, long classPK, 1456 OrderByComparator<SocialActivity> orderByComparator) { 1457 return getPersistence() 1458 .fetchByM_C_C_Last(mirrorActivityId, classNameId, classPK, 1459 orderByComparator); 1460 } 1461 1462 /** 1463 * Returns the social activities before and after the current social activity in the ordered set where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1464 * 1465 * @param activityId the primary key of the current social activity 1466 * @param mirrorActivityId the mirror activity ID 1467 * @param classNameId the class name ID 1468 * @param classPK the class p k 1469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1470 * @return the previous, current, and next social activity 1471 * @throws NoSuchActivityException if a social activity with the primary key could not be found 1472 */ 1473 public static SocialActivity[] findByM_C_C_PrevAndNext(long activityId, 1474 long mirrorActivityId, long classNameId, long classPK, 1475 OrderByComparator<SocialActivity> orderByComparator) 1476 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1477 return getPersistence() 1478 .findByM_C_C_PrevAndNext(activityId, mirrorActivityId, 1479 classNameId, classPK, orderByComparator); 1480 } 1481 1482 /** 1483 * Removes all the social activities where mirrorActivityId = ? and classNameId = ? and classPK = ? from the database. 1484 * 1485 * @param mirrorActivityId the mirror activity ID 1486 * @param classNameId the class name ID 1487 * @param classPK the class p k 1488 */ 1489 public static void removeByM_C_C(long mirrorActivityId, long classNameId, 1490 long classPK) { 1491 getPersistence().removeByM_C_C(mirrorActivityId, classNameId, classPK); 1492 } 1493 1494 /** 1495 * Returns the number of social activities where mirrorActivityId = ? and classNameId = ? and classPK = ?. 1496 * 1497 * @param mirrorActivityId the mirror activity ID 1498 * @param classNameId the class name ID 1499 * @param classPK the class p k 1500 * @return the number of matching social activities 1501 */ 1502 public static int countByM_C_C(long mirrorActivityId, long classNameId, 1503 long classPK) { 1504 return getPersistence() 1505 .countByM_C_C(mirrorActivityId, classNameId, classPK); 1506 } 1507 1508 /** 1509 * Returns all the social activities where classNameId = ? and classPK = ? and type = ?. 1510 * 1511 * @param classNameId the class name ID 1512 * @param classPK the class p k 1513 * @param type the type 1514 * @return the matching social activities 1515 */ 1516 public static List<SocialActivity> findByC_C_T(long classNameId, 1517 long classPK, int type) { 1518 return getPersistence().findByC_C_T(classNameId, classPK, type); 1519 } 1520 1521 /** 1522 * Returns a range of all the social activities where classNameId = ? and classPK = ? and type = ?. 1523 * 1524 * <p> 1525 * 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. 1526 * </p> 1527 * 1528 * @param classNameId the class name ID 1529 * @param classPK the class p k 1530 * @param type the type 1531 * @param start the lower bound of the range of social activities 1532 * @param end the upper bound of the range of social activities (not inclusive) 1533 * @return the range of matching social activities 1534 */ 1535 public static List<SocialActivity> findByC_C_T(long classNameId, 1536 long classPK, int type, int start, int end) { 1537 return getPersistence() 1538 .findByC_C_T(classNameId, classPK, type, start, end); 1539 } 1540 1541 /** 1542 * Returns an ordered range of all the social activities where classNameId = ? and classPK = ? and type = ?. 1543 * 1544 * <p> 1545 * 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. 1546 * </p> 1547 * 1548 * @param classNameId the class name ID 1549 * @param classPK the class p k 1550 * @param type the type 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> findByC_C_T(long classNameId, 1557 long classPK, int type, int start, int end, 1558 OrderByComparator<SocialActivity> orderByComparator) { 1559 return getPersistence() 1560 .findByC_C_T(classNameId, classPK, type, start, end, 1561 orderByComparator); 1562 } 1563 1564 /** 1565 * Returns an ordered range of all the social activities where classNameId = ? and classPK = ? and type = ?. 1566 * 1567 * <p> 1568 * 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. 1569 * </p> 1570 * 1571 * @param classNameId the class name ID 1572 * @param classPK the class p k 1573 * @param type the type 1574 * @param start the lower bound of the range of social activities 1575 * @param end the upper bound of the range of social activities (not inclusive) 1576 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1577 * @param retrieveFromCache whether to retrieve from the finder cache 1578 * @return the ordered range of matching social activities 1579 */ 1580 public static List<SocialActivity> findByC_C_T(long classNameId, 1581 long classPK, int type, int start, int end, 1582 OrderByComparator<SocialActivity> orderByComparator, 1583 boolean retrieveFromCache) { 1584 return getPersistence() 1585 .findByC_C_T(classNameId, classPK, type, start, end, 1586 orderByComparator, retrieveFromCache); 1587 } 1588 1589 /** 1590 * Returns the first social activity in the ordered set where classNameId = ? and classPK = ? and type = ?. 1591 * 1592 * @param classNameId the class name ID 1593 * @param classPK the class p k 1594 * @param type the type 1595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1596 * @return the first matching social activity 1597 * @throws NoSuchActivityException if a matching social activity could not be found 1598 */ 1599 public static SocialActivity findByC_C_T_First(long classNameId, 1600 long classPK, int type, 1601 OrderByComparator<SocialActivity> orderByComparator) 1602 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1603 return getPersistence() 1604 .findByC_C_T_First(classNameId, classPK, type, 1605 orderByComparator); 1606 } 1607 1608 /** 1609 * Returns the first social activity in the ordered set where classNameId = ? and classPK = ? and type = ?. 1610 * 1611 * @param classNameId the class name ID 1612 * @param classPK the class p k 1613 * @param type the type 1614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1615 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 1616 */ 1617 public static SocialActivity fetchByC_C_T_First(long classNameId, 1618 long classPK, int type, 1619 OrderByComparator<SocialActivity> orderByComparator) { 1620 return getPersistence() 1621 .fetchByC_C_T_First(classNameId, classPK, type, 1622 orderByComparator); 1623 } 1624 1625 /** 1626 * Returns the last social activity in the ordered set where classNameId = ? and classPK = ? and type = ?. 1627 * 1628 * @param classNameId the class name ID 1629 * @param classPK the class p k 1630 * @param type the type 1631 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1632 * @return the last matching social activity 1633 * @throws NoSuchActivityException if a matching social activity could not be found 1634 */ 1635 public static SocialActivity findByC_C_T_Last(long classNameId, 1636 long classPK, int type, 1637 OrderByComparator<SocialActivity> orderByComparator) 1638 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1639 return getPersistence() 1640 .findByC_C_T_Last(classNameId, classPK, type, 1641 orderByComparator); 1642 } 1643 1644 /** 1645 * Returns the last social activity in the ordered set where classNameId = ? and classPK = ? and type = ?. 1646 * 1647 * @param classNameId the class name ID 1648 * @param classPK the class p k 1649 * @param type the type 1650 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1651 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 1652 */ 1653 public static SocialActivity fetchByC_C_T_Last(long classNameId, 1654 long classPK, int type, 1655 OrderByComparator<SocialActivity> orderByComparator) { 1656 return getPersistence() 1657 .fetchByC_C_T_Last(classNameId, classPK, type, 1658 orderByComparator); 1659 } 1660 1661 /** 1662 * Returns the social activities before and after the current social activity in the ordered set where classNameId = ? and classPK = ? and type = ?. 1663 * 1664 * @param activityId the primary key of the current social activity 1665 * @param classNameId the class name ID 1666 * @param classPK the class p k 1667 * @param type the type 1668 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1669 * @return the previous, current, and next social activity 1670 * @throws NoSuchActivityException if a social activity with the primary key could not be found 1671 */ 1672 public static SocialActivity[] findByC_C_T_PrevAndNext(long activityId, 1673 long classNameId, long classPK, int type, 1674 OrderByComparator<SocialActivity> orderByComparator) 1675 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1676 return getPersistence() 1677 .findByC_C_T_PrevAndNext(activityId, classNameId, classPK, 1678 type, orderByComparator); 1679 } 1680 1681 /** 1682 * Removes all the social activities where classNameId = ? and classPK = ? and type = ? from the database. 1683 * 1684 * @param classNameId the class name ID 1685 * @param classPK the class p k 1686 * @param type the type 1687 */ 1688 public static void removeByC_C_T(long classNameId, long classPK, int type) { 1689 getPersistence().removeByC_C_T(classNameId, classPK, type); 1690 } 1691 1692 /** 1693 * Returns the number of social activities where classNameId = ? and classPK = ? and type = ?. 1694 * 1695 * @param classNameId the class name ID 1696 * @param classPK the class p k 1697 * @param type the type 1698 * @return the number of matching social activities 1699 */ 1700 public static int countByC_C_T(long classNameId, long classPK, int type) { 1701 return getPersistence().countByC_C_T(classNameId, classPK, type); 1702 } 1703 1704 /** 1705 * Returns all the social activities where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1706 * 1707 * @param groupId the group ID 1708 * @param userId the user ID 1709 * @param classNameId the class name ID 1710 * @param classPK the class p k 1711 * @param type the type 1712 * @param receiverUserId the receiver user ID 1713 * @return the matching social activities 1714 */ 1715 public static List<SocialActivity> findByG_U_C_C_T_R(long groupId, 1716 long userId, long classNameId, long classPK, int type, 1717 long receiverUserId) { 1718 return getPersistence() 1719 .findByG_U_C_C_T_R(groupId, userId, classNameId, classPK, 1720 type, receiverUserId); 1721 } 1722 1723 /** 1724 * Returns a range of all the social activities where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1725 * 1726 * <p> 1727 * 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. 1728 * </p> 1729 * 1730 * @param groupId the group ID 1731 * @param userId the user ID 1732 * @param classNameId the class name ID 1733 * @param classPK the class p k 1734 * @param type the type 1735 * @param receiverUserId the receiver user ID 1736 * @param start the lower bound of the range of social activities 1737 * @param end the upper bound of the range of social activities (not inclusive) 1738 * @return the range of matching social activities 1739 */ 1740 public static List<SocialActivity> findByG_U_C_C_T_R(long groupId, 1741 long userId, long classNameId, long classPK, int type, 1742 long receiverUserId, int start, int end) { 1743 return getPersistence() 1744 .findByG_U_C_C_T_R(groupId, userId, classNameId, classPK, 1745 type, receiverUserId, start, end); 1746 } 1747 1748 /** 1749 * Returns an ordered range of all the social activities where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1750 * 1751 * <p> 1752 * 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. 1753 * </p> 1754 * 1755 * @param groupId the group ID 1756 * @param userId the user ID 1757 * @param classNameId the class name ID 1758 * @param classPK the class p k 1759 * @param type the type 1760 * @param receiverUserId the receiver user ID 1761 * @param start the lower bound of the range of social activities 1762 * @param end the upper bound of the range of social activities (not inclusive) 1763 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1764 * @return the ordered range of matching social activities 1765 */ 1766 public static List<SocialActivity> findByG_U_C_C_T_R(long groupId, 1767 long userId, long classNameId, long classPK, int type, 1768 long receiverUserId, int start, int end, 1769 OrderByComparator<SocialActivity> orderByComparator) { 1770 return getPersistence() 1771 .findByG_U_C_C_T_R(groupId, userId, classNameId, classPK, 1772 type, receiverUserId, start, end, orderByComparator); 1773 } 1774 1775 /** 1776 * Returns an ordered range of all the social activities where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1777 * 1778 * <p> 1779 * 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. 1780 * </p> 1781 * 1782 * @param groupId the group ID 1783 * @param userId the user ID 1784 * @param classNameId the class name ID 1785 * @param classPK the class p k 1786 * @param type the type 1787 * @param receiverUserId the receiver user ID 1788 * @param start the lower bound of the range of social activities 1789 * @param end the upper bound of the range of social activities (not inclusive) 1790 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1791 * @param retrieveFromCache whether to retrieve from the finder cache 1792 * @return the ordered range of matching social activities 1793 */ 1794 public static List<SocialActivity> findByG_U_C_C_T_R(long groupId, 1795 long userId, long classNameId, long classPK, int type, 1796 long receiverUserId, int start, int end, 1797 OrderByComparator<SocialActivity> orderByComparator, 1798 boolean retrieveFromCache) { 1799 return getPersistence() 1800 .findByG_U_C_C_T_R(groupId, userId, classNameId, classPK, 1801 type, receiverUserId, start, end, orderByComparator, 1802 retrieveFromCache); 1803 } 1804 1805 /** 1806 * Returns the first social activity in the ordered set where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1807 * 1808 * @param groupId the group ID 1809 * @param userId the user ID 1810 * @param classNameId the class name ID 1811 * @param classPK the class p k 1812 * @param type the type 1813 * @param receiverUserId the receiver user ID 1814 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1815 * @return the first matching social activity 1816 * @throws NoSuchActivityException if a matching social activity could not be found 1817 */ 1818 public static SocialActivity findByG_U_C_C_T_R_First(long groupId, 1819 long userId, long classNameId, long classPK, int type, 1820 long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) 1821 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1822 return getPersistence() 1823 .findByG_U_C_C_T_R_First(groupId, userId, classNameId, 1824 classPK, type, receiverUserId, orderByComparator); 1825 } 1826 1827 /** 1828 * Returns the first social activity in the ordered set where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1829 * 1830 * @param groupId the group ID 1831 * @param userId the user ID 1832 * @param classNameId the class name ID 1833 * @param classPK the class p k 1834 * @param type the type 1835 * @param receiverUserId the receiver user ID 1836 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1837 * @return the first matching social activity, or <code>null</code> if a matching social activity could not be found 1838 */ 1839 public static SocialActivity fetchByG_U_C_C_T_R_First(long groupId, 1840 long userId, long classNameId, long classPK, int type, 1841 long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) { 1842 return getPersistence() 1843 .fetchByG_U_C_C_T_R_First(groupId, userId, classNameId, 1844 classPK, type, receiverUserId, orderByComparator); 1845 } 1846 1847 /** 1848 * Returns the last social activity in the ordered set where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1849 * 1850 * @param groupId the group ID 1851 * @param userId the user ID 1852 * @param classNameId the class name ID 1853 * @param classPK the class p k 1854 * @param type the type 1855 * @param receiverUserId the receiver user ID 1856 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1857 * @return the last matching social activity 1858 * @throws NoSuchActivityException if a matching social activity could not be found 1859 */ 1860 public static SocialActivity findByG_U_C_C_T_R_Last(long groupId, 1861 long userId, long classNameId, long classPK, int type, 1862 long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) 1863 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1864 return getPersistence() 1865 .findByG_U_C_C_T_R_Last(groupId, userId, classNameId, 1866 classPK, type, receiverUserId, orderByComparator); 1867 } 1868 1869 /** 1870 * Returns the last social activity in the ordered set where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1871 * 1872 * @param groupId the group ID 1873 * @param userId the user ID 1874 * @param classNameId the class name ID 1875 * @param classPK the class p k 1876 * @param type the type 1877 * @param receiverUserId the receiver user ID 1878 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1879 * @return the last matching social activity, or <code>null</code> if a matching social activity could not be found 1880 */ 1881 public static SocialActivity fetchByG_U_C_C_T_R_Last(long groupId, 1882 long userId, long classNameId, long classPK, int type, 1883 long receiverUserId, OrderByComparator<SocialActivity> orderByComparator) { 1884 return getPersistence() 1885 .fetchByG_U_C_C_T_R_Last(groupId, userId, classNameId, 1886 classPK, type, receiverUserId, orderByComparator); 1887 } 1888 1889 /** 1890 * 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 = ?. 1891 * 1892 * @param activityId the primary key of the current social activity 1893 * @param groupId the group ID 1894 * @param userId the user ID 1895 * @param classNameId the class name ID 1896 * @param classPK the class p k 1897 * @param type the type 1898 * @param receiverUserId the receiver user ID 1899 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1900 * @return the previous, current, and next social activity 1901 * @throws NoSuchActivityException if a social activity with the primary key could not be found 1902 */ 1903 public static SocialActivity[] findByG_U_C_C_T_R_PrevAndNext( 1904 long activityId, long groupId, long userId, long classNameId, 1905 long classPK, int type, long receiverUserId, 1906 OrderByComparator<SocialActivity> orderByComparator) 1907 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1908 return getPersistence() 1909 .findByG_U_C_C_T_R_PrevAndNext(activityId, groupId, userId, 1910 classNameId, classPK, type, receiverUserId, orderByComparator); 1911 } 1912 1913 /** 1914 * Removes all the social activities where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ? from the database. 1915 * 1916 * @param groupId the group ID 1917 * @param userId the user ID 1918 * @param classNameId the class name ID 1919 * @param classPK the class p k 1920 * @param type the type 1921 * @param receiverUserId the receiver user ID 1922 */ 1923 public static void removeByG_U_C_C_T_R(long groupId, long userId, 1924 long classNameId, long classPK, int type, long receiverUserId) { 1925 getPersistence() 1926 .removeByG_U_C_C_T_R(groupId, userId, classNameId, classPK, type, 1927 receiverUserId); 1928 } 1929 1930 /** 1931 * Returns the number of social activities where groupId = ? and userId = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 1932 * 1933 * @param groupId the group ID 1934 * @param userId the user ID 1935 * @param classNameId the class name ID 1936 * @param classPK the class p k 1937 * @param type the type 1938 * @param receiverUserId the receiver user ID 1939 * @return the number of matching social activities 1940 */ 1941 public static int countByG_U_C_C_T_R(long groupId, long userId, 1942 long classNameId, long classPK, int type, long receiverUserId) { 1943 return getPersistence() 1944 .countByG_U_C_C_T_R(groupId, userId, classNameId, classPK, 1945 type, receiverUserId); 1946 } 1947 1948 /** 1949 * 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. 1950 * 1951 * @param groupId the group ID 1952 * @param userId the user ID 1953 * @param createDate the create date 1954 * @param classNameId the class name ID 1955 * @param classPK the class p k 1956 * @param type the type 1957 * @param receiverUserId the receiver user ID 1958 * @return the matching social activity 1959 * @throws NoSuchActivityException if a matching social activity could not be found 1960 */ 1961 public static SocialActivity findByG_U_CD_C_C_T_R(long groupId, 1962 long userId, long createDate, long classNameId, long classPK, int type, 1963 long receiverUserId) 1964 throws com.liferay.portlet.social.exception.NoSuchActivityException { 1965 return getPersistence() 1966 .findByG_U_CD_C_C_T_R(groupId, userId, createDate, 1967 classNameId, classPK, type, receiverUserId); 1968 } 1969 1970 /** 1971 * 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. 1972 * 1973 * @param groupId the group ID 1974 * @param userId the user ID 1975 * @param createDate the create date 1976 * @param classNameId the class name ID 1977 * @param classPK the class p k 1978 * @param type the type 1979 * @param receiverUserId the receiver user ID 1980 * @return the matching social activity, or <code>null</code> if a matching social activity could not be found 1981 */ 1982 public static SocialActivity fetchByG_U_CD_C_C_T_R(long groupId, 1983 long userId, long createDate, long classNameId, long classPK, int type, 1984 long receiverUserId) { 1985 return getPersistence() 1986 .fetchByG_U_CD_C_C_T_R(groupId, userId, createDate, 1987 classNameId, classPK, type, receiverUserId); 1988 } 1989 1990 /** 1991 * 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. 1992 * 1993 * @param groupId the group ID 1994 * @param userId the user ID 1995 * @param createDate the create date 1996 * @param classNameId the class name ID 1997 * @param classPK the class p k 1998 * @param type the type 1999 * @param receiverUserId the receiver user ID 2000 * @param retrieveFromCache whether to retrieve from the finder cache 2001 * @return the matching social activity, or <code>null</code> if a matching social activity could not be found 2002 */ 2003 public static SocialActivity fetchByG_U_CD_C_C_T_R(long groupId, 2004 long userId, long createDate, long classNameId, long classPK, int type, 2005 long receiverUserId, boolean retrieveFromCache) { 2006 return getPersistence() 2007 .fetchByG_U_CD_C_C_T_R(groupId, userId, createDate, 2008 classNameId, classPK, type, receiverUserId, retrieveFromCache); 2009 } 2010 2011 /** 2012 * Removes the social activity where groupId = ? and userId = ? and createDate = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ? from the database. 2013 * 2014 * @param groupId the group ID 2015 * @param userId the user ID 2016 * @param createDate the create date 2017 * @param classNameId the class name ID 2018 * @param classPK the class p k 2019 * @param type the type 2020 * @param receiverUserId the receiver user ID 2021 * @return the social activity that was removed 2022 */ 2023 public static SocialActivity removeByG_U_CD_C_C_T_R(long groupId, 2024 long userId, long createDate, long classNameId, long classPK, int type, 2025 long receiverUserId) 2026 throws com.liferay.portlet.social.exception.NoSuchActivityException { 2027 return getPersistence() 2028 .removeByG_U_CD_C_C_T_R(groupId, userId, createDate, 2029 classNameId, classPK, type, receiverUserId); 2030 } 2031 2032 /** 2033 * Returns the number of social activities where groupId = ? and userId = ? and createDate = ? and classNameId = ? and classPK = ? and type = ? and receiverUserId = ?. 2034 * 2035 * @param groupId the group ID 2036 * @param userId the user ID 2037 * @param createDate the create date 2038 * @param classNameId the class name ID 2039 * @param classPK the class p k 2040 * @param type the type 2041 * @param receiverUserId the receiver user ID 2042 * @return the number of matching social activities 2043 */ 2044 public static int countByG_U_CD_C_C_T_R(long groupId, long userId, 2045 long createDate, long classNameId, long classPK, int type, 2046 long receiverUserId) { 2047 return getPersistence() 2048 .countByG_U_CD_C_C_T_R(groupId, userId, createDate, 2049 classNameId, classPK, type, receiverUserId); 2050 } 2051 2052 /** 2053 * Caches the social activity in the entity cache if it is enabled. 2054 * 2055 * @param socialActivity the social activity 2056 */ 2057 public static void cacheResult(SocialActivity socialActivity) { 2058 getPersistence().cacheResult(socialActivity); 2059 } 2060 2061 /** 2062 * Caches the social activities in the entity cache if it is enabled. 2063 * 2064 * @param socialActivities the social activities 2065 */ 2066 public static void cacheResult(List<SocialActivity> socialActivities) { 2067 getPersistence().cacheResult(socialActivities); 2068 } 2069 2070 /** 2071 * Creates a new social activity with the primary key. Does not add the social activity to the database. 2072 * 2073 * @param activityId the primary key for the new social activity 2074 * @return the new social activity 2075 */ 2076 public static SocialActivity create(long activityId) { 2077 return getPersistence().create(activityId); 2078 } 2079 2080 /** 2081 * Removes the social activity with the primary key from the database. Also notifies the appropriate model listeners. 2082 * 2083 * @param activityId the primary key of the social activity 2084 * @return the social activity that was removed 2085 * @throws NoSuchActivityException if a social activity with the primary key could not be found 2086 */ 2087 public static SocialActivity remove(long activityId) 2088 throws com.liferay.portlet.social.exception.NoSuchActivityException { 2089 return getPersistence().remove(activityId); 2090 } 2091 2092 public static SocialActivity updateImpl(SocialActivity socialActivity) { 2093 return getPersistence().updateImpl(socialActivity); 2094 } 2095 2096 /** 2097 * Returns the social activity with the primary key or throws a {@link NoSuchActivityException} if it could not be found. 2098 * 2099 * @param activityId the primary key of the social activity 2100 * @return the social activity 2101 * @throws NoSuchActivityException if a social activity with the primary key could not be found 2102 */ 2103 public static SocialActivity findByPrimaryKey(long activityId) 2104 throws com.liferay.portlet.social.exception.NoSuchActivityException { 2105 return getPersistence().findByPrimaryKey(activityId); 2106 } 2107 2108 /** 2109 * Returns the social activity with the primary key or returns <code>null</code> if it could not be found. 2110 * 2111 * @param activityId the primary key of the social activity 2112 * @return the social activity, or <code>null</code> if a social activity with the primary key could not be found 2113 */ 2114 public static SocialActivity fetchByPrimaryKey(long activityId) { 2115 return getPersistence().fetchByPrimaryKey(activityId); 2116 } 2117 2118 public static java.util.Map<java.io.Serializable, SocialActivity> fetchByPrimaryKeys( 2119 java.util.Set<java.io.Serializable> primaryKeys) { 2120 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2121 } 2122 2123 /** 2124 * Returns all the social activities. 2125 * 2126 * @return the social activities 2127 */ 2128 public static List<SocialActivity> findAll() { 2129 return getPersistence().findAll(); 2130 } 2131 2132 /** 2133 * Returns a range of all the social activities. 2134 * 2135 * <p> 2136 * 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. 2137 * </p> 2138 * 2139 * @param start the lower bound of the range of social activities 2140 * @param end the upper bound of the range of social activities (not inclusive) 2141 * @return the range of social activities 2142 */ 2143 public static List<SocialActivity> findAll(int start, int end) { 2144 return getPersistence().findAll(start, end); 2145 } 2146 2147 /** 2148 * Returns an ordered range of all the social activities. 2149 * 2150 * <p> 2151 * 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. 2152 * </p> 2153 * 2154 * @param start the lower bound of the range of social activities 2155 * @param end the upper bound of the range of social activities (not inclusive) 2156 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2157 * @return the ordered range of social activities 2158 */ 2159 public static List<SocialActivity> findAll(int start, int end, 2160 OrderByComparator<SocialActivity> orderByComparator) { 2161 return getPersistence().findAll(start, end, orderByComparator); 2162 } 2163 2164 /** 2165 * Returns an ordered range of all the social activities. 2166 * 2167 * <p> 2168 * 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. 2169 * </p> 2170 * 2171 * @param start the lower bound of the range of social activities 2172 * @param end the upper bound of the range of social activities (not inclusive) 2173 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2174 * @param retrieveFromCache whether to retrieve from the finder cache 2175 * @return the ordered range of social activities 2176 */ 2177 public static List<SocialActivity> findAll(int start, int end, 2178 OrderByComparator<SocialActivity> orderByComparator, 2179 boolean retrieveFromCache) { 2180 return getPersistence() 2181 .findAll(start, end, orderByComparator, retrieveFromCache); 2182 } 2183 2184 /** 2185 * Removes all the social activities from the database. 2186 */ 2187 public static void removeAll() { 2188 getPersistence().removeAll(); 2189 } 2190 2191 /** 2192 * Returns the number of social activities. 2193 * 2194 * @return the number of social activities 2195 */ 2196 public static int countAll() { 2197 return getPersistence().countAll(); 2198 } 2199 2200 public static java.util.Set<java.lang.String> getBadColumnNames() { 2201 return getPersistence().getBadColumnNames(); 2202 } 2203 2204 public static SocialActivityPersistence getPersistence() { 2205 if (_persistence == null) { 2206 _persistence = (SocialActivityPersistence)PortalBeanLocatorUtil.locate(SocialActivityPersistence.class.getName()); 2207 2208 ReferenceRegistry.registerReference(SocialActivityUtil.class, 2209 "_persistence"); 2210 } 2211 2212 return _persistence; 2213 } 2214 2215 private static SocialActivityPersistence _persistence; 2216 }