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