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