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