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.portal.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.model.MembershipRequest; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the membership request service. This utility wraps {@link com.liferay.portal.service.persistence.impl.MembershipRequestPersistenceImpl} 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. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see MembershipRequestPersistence 037 * @see com.liferay.portal.service.persistence.impl.MembershipRequestPersistenceImpl 038 * @generated 039 */ 040 @ProviderType 041 public class MembershipRequestUtil { 042 /* 043 * NOTE FOR DEVELOPERS: 044 * 045 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 046 */ 047 048 /** 049 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 050 */ 051 public static void clearCache() { 052 getPersistence().clearCache(); 053 } 054 055 /** 056 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 057 */ 058 public static void clearCache(MembershipRequest membershipRequest) { 059 getPersistence().clearCache(membershipRequest); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 064 */ 065 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<MembershipRequest> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<MembershipRequest> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<MembershipRequest> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator<MembershipRequest> orderByComparator) { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static MembershipRequest update(MembershipRequest membershipRequest) { 100 return getPersistence().update(membershipRequest); 101 } 102 103 /** 104 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 105 */ 106 public static MembershipRequest update( 107 MembershipRequest membershipRequest, ServiceContext serviceContext) { 108 return getPersistence().update(membershipRequest, serviceContext); 109 } 110 111 /** 112 * Returns all the membership requests where groupId = ?. 113 * 114 * @param groupId the group ID 115 * @return the matching membership requests 116 */ 117 public static List<MembershipRequest> findByGroupId(long groupId) { 118 return getPersistence().findByGroupId(groupId); 119 } 120 121 /** 122 * Returns a range of all the membership requests where groupId = ?. 123 * 124 * <p> 125 * 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 MembershipRequestModelImpl}. 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. 126 * </p> 127 * 128 * @param groupId the group ID 129 * @param start the lower bound of the range of membership requests 130 * @param end the upper bound of the range of membership requests (not inclusive) 131 * @return the range of matching membership requests 132 */ 133 public static List<MembershipRequest> findByGroupId(long groupId, 134 int start, int end) { 135 return getPersistence().findByGroupId(groupId, start, end); 136 } 137 138 /** 139 * Returns an ordered range of all the membership requests where groupId = ?. 140 * 141 * <p> 142 * 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 MembershipRequestModelImpl}. 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. 143 * </p> 144 * 145 * @param groupId the group ID 146 * @param start the lower bound of the range of membership requests 147 * @param end the upper bound of the range of membership requests (not inclusive) 148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 149 * @return the ordered range of matching membership requests 150 */ 151 public static List<MembershipRequest> findByGroupId(long groupId, 152 int start, int end, 153 OrderByComparator<MembershipRequest> orderByComparator) { 154 return getPersistence() 155 .findByGroupId(groupId, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns an ordered range of all the membership requests where groupId = ?. 160 * 161 * <p> 162 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link MembershipRequestModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 163 * </p> 164 * 165 * @param groupId the group ID 166 * @param start the lower bound of the range of membership requests 167 * @param end the upper bound of the range of membership requests (not inclusive) 168 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 169 * @param retrieveFromCache whether to retrieve from the finder cache 170 * @return the ordered range of matching membership requests 171 */ 172 public static List<MembershipRequest> findByGroupId(long groupId, 173 int start, int end, 174 OrderByComparator<MembershipRequest> orderByComparator, 175 boolean retrieveFromCache) { 176 return getPersistence() 177 .findByGroupId(groupId, start, end, orderByComparator, 178 retrieveFromCache); 179 } 180 181 /** 182 * Returns the first membership request in the ordered set where groupId = ?. 183 * 184 * @param groupId the group ID 185 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 186 * @return the first matching membership request 187 * @throws NoSuchMembershipRequestException if a matching membership request could not be found 188 */ 189 public static MembershipRequest findByGroupId_First(long groupId, 190 OrderByComparator<MembershipRequest> orderByComparator) 191 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 192 return getPersistence().findByGroupId_First(groupId, orderByComparator); 193 } 194 195 /** 196 * Returns the first membership request in the ordered set where groupId = ?. 197 * 198 * @param groupId the group ID 199 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 200 * @return the first matching membership request, or <code>null</code> if a matching membership request could not be found 201 */ 202 public static MembershipRequest fetchByGroupId_First(long groupId, 203 OrderByComparator<MembershipRequest> orderByComparator) { 204 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 205 } 206 207 /** 208 * Returns the last membership request in the ordered set where groupId = ?. 209 * 210 * @param groupId the group ID 211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 212 * @return the last matching membership request 213 * @throws NoSuchMembershipRequestException if a matching membership request could not be found 214 */ 215 public static MembershipRequest findByGroupId_Last(long groupId, 216 OrderByComparator<MembershipRequest> orderByComparator) 217 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 218 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 219 } 220 221 /** 222 * Returns the last membership request in the ordered set where groupId = ?. 223 * 224 * @param groupId the group ID 225 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 226 * @return the last matching membership request, or <code>null</code> if a matching membership request could not be found 227 */ 228 public static MembershipRequest fetchByGroupId_Last(long groupId, 229 OrderByComparator<MembershipRequest> orderByComparator) { 230 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 231 } 232 233 /** 234 * Returns the membership requests before and after the current membership request in the ordered set where groupId = ?. 235 * 236 * @param membershipRequestId the primary key of the current membership request 237 * @param groupId the group ID 238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 239 * @return the previous, current, and next membership request 240 * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found 241 */ 242 public static MembershipRequest[] findByGroupId_PrevAndNext( 243 long membershipRequestId, long groupId, 244 OrderByComparator<MembershipRequest> orderByComparator) 245 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 246 return getPersistence() 247 .findByGroupId_PrevAndNext(membershipRequestId, groupId, 248 orderByComparator); 249 } 250 251 /** 252 * Removes all the membership requests where groupId = ? from the database. 253 * 254 * @param groupId the group ID 255 */ 256 public static void removeByGroupId(long groupId) { 257 getPersistence().removeByGroupId(groupId); 258 } 259 260 /** 261 * Returns the number of membership requests where groupId = ?. 262 * 263 * @param groupId the group ID 264 * @return the number of matching membership requests 265 */ 266 public static int countByGroupId(long groupId) { 267 return getPersistence().countByGroupId(groupId); 268 } 269 270 /** 271 * Returns all the membership requests where userId = ?. 272 * 273 * @param userId the user ID 274 * @return the matching membership requests 275 */ 276 public static List<MembershipRequest> findByUserId(long userId) { 277 return getPersistence().findByUserId(userId); 278 } 279 280 /** 281 * Returns a range of all the membership requests where userId = ?. 282 * 283 * <p> 284 * 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 MembershipRequestModelImpl}. 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. 285 * </p> 286 * 287 * @param userId the user ID 288 * @param start the lower bound of the range of membership requests 289 * @param end the upper bound of the range of membership requests (not inclusive) 290 * @return the range of matching membership requests 291 */ 292 public static List<MembershipRequest> findByUserId(long userId, int start, 293 int end) { 294 return getPersistence().findByUserId(userId, start, end); 295 } 296 297 /** 298 * Returns an ordered range of all the membership requests where userId = ?. 299 * 300 * <p> 301 * 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 MembershipRequestModelImpl}. 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. 302 * </p> 303 * 304 * @param userId the user ID 305 * @param start the lower bound of the range of membership requests 306 * @param end the upper bound of the range of membership requests (not inclusive) 307 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 308 * @return the ordered range of matching membership requests 309 */ 310 public static List<MembershipRequest> findByUserId(long userId, int start, 311 int end, OrderByComparator<MembershipRequest> orderByComparator) { 312 return getPersistence() 313 .findByUserId(userId, start, end, orderByComparator); 314 } 315 316 /** 317 * Returns an ordered range of all the membership requests where userId = ?. 318 * 319 * <p> 320 * 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 MembershipRequestModelImpl}. 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. 321 * </p> 322 * 323 * @param userId the user ID 324 * @param start the lower bound of the range of membership requests 325 * @param end the upper bound of the range of membership requests (not inclusive) 326 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 327 * @param retrieveFromCache whether to retrieve from the finder cache 328 * @return the ordered range of matching membership requests 329 */ 330 public static List<MembershipRequest> findByUserId(long userId, int start, 331 int end, OrderByComparator<MembershipRequest> orderByComparator, 332 boolean retrieveFromCache) { 333 return getPersistence() 334 .findByUserId(userId, start, end, orderByComparator, 335 retrieveFromCache); 336 } 337 338 /** 339 * Returns the first membership request in the ordered set where userId = ?. 340 * 341 * @param userId the user ID 342 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 343 * @return the first matching membership request 344 * @throws NoSuchMembershipRequestException if a matching membership request could not be found 345 */ 346 public static MembershipRequest findByUserId_First(long userId, 347 OrderByComparator<MembershipRequest> orderByComparator) 348 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 349 return getPersistence().findByUserId_First(userId, orderByComparator); 350 } 351 352 /** 353 * Returns the first membership request in the ordered set where userId = ?. 354 * 355 * @param userId the user ID 356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 357 * @return the first matching membership request, or <code>null</code> if a matching membership request could not be found 358 */ 359 public static MembershipRequest fetchByUserId_First(long userId, 360 OrderByComparator<MembershipRequest> orderByComparator) { 361 return getPersistence().fetchByUserId_First(userId, orderByComparator); 362 } 363 364 /** 365 * Returns the last membership request in the ordered set where userId = ?. 366 * 367 * @param userId the user ID 368 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 369 * @return the last matching membership request 370 * @throws NoSuchMembershipRequestException if a matching membership request could not be found 371 */ 372 public static MembershipRequest findByUserId_Last(long userId, 373 OrderByComparator<MembershipRequest> orderByComparator) 374 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 375 return getPersistence().findByUserId_Last(userId, orderByComparator); 376 } 377 378 /** 379 * Returns the last membership request in the ordered set where userId = ?. 380 * 381 * @param userId the user ID 382 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 383 * @return the last matching membership request, or <code>null</code> if a matching membership request could not be found 384 */ 385 public static MembershipRequest fetchByUserId_Last(long userId, 386 OrderByComparator<MembershipRequest> orderByComparator) { 387 return getPersistence().fetchByUserId_Last(userId, orderByComparator); 388 } 389 390 /** 391 * Returns the membership requests before and after the current membership request in the ordered set where userId = ?. 392 * 393 * @param membershipRequestId the primary key of the current membership request 394 * @param userId the user ID 395 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 396 * @return the previous, current, and next membership request 397 * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found 398 */ 399 public static MembershipRequest[] findByUserId_PrevAndNext( 400 long membershipRequestId, long userId, 401 OrderByComparator<MembershipRequest> orderByComparator) 402 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 403 return getPersistence() 404 .findByUserId_PrevAndNext(membershipRequestId, userId, 405 orderByComparator); 406 } 407 408 /** 409 * Removes all the membership requests where userId = ? from the database. 410 * 411 * @param userId the user ID 412 */ 413 public static void removeByUserId(long userId) { 414 getPersistence().removeByUserId(userId); 415 } 416 417 /** 418 * Returns the number of membership requests where userId = ?. 419 * 420 * @param userId the user ID 421 * @return the number of matching membership requests 422 */ 423 public static int countByUserId(long userId) { 424 return getPersistence().countByUserId(userId); 425 } 426 427 /** 428 * Returns all the membership requests where groupId = ? and statusId = ?. 429 * 430 * @param groupId the group ID 431 * @param statusId the status ID 432 * @return the matching membership requests 433 */ 434 public static List<MembershipRequest> findByG_S(long groupId, long statusId) { 435 return getPersistence().findByG_S(groupId, statusId); 436 } 437 438 /** 439 * Returns a range of all the membership requests where groupId = ? and statusId = ?. 440 * 441 * <p> 442 * 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 MembershipRequestModelImpl}. 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. 443 * </p> 444 * 445 * @param groupId the group ID 446 * @param statusId the status ID 447 * @param start the lower bound of the range of membership requests 448 * @param end the upper bound of the range of membership requests (not inclusive) 449 * @return the range of matching membership requests 450 */ 451 public static List<MembershipRequest> findByG_S(long groupId, 452 long statusId, int start, int end) { 453 return getPersistence().findByG_S(groupId, statusId, start, end); 454 } 455 456 /** 457 * Returns an ordered range of all the membership requests where groupId = ? and statusId = ?. 458 * 459 * <p> 460 * 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 MembershipRequestModelImpl}. 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. 461 * </p> 462 * 463 * @param groupId the group ID 464 * @param statusId the status ID 465 * @param start the lower bound of the range of membership requests 466 * @param end the upper bound of the range of membership requests (not inclusive) 467 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 468 * @return the ordered range of matching membership requests 469 */ 470 public static List<MembershipRequest> findByG_S(long groupId, 471 long statusId, int start, int end, 472 OrderByComparator<MembershipRequest> orderByComparator) { 473 return getPersistence() 474 .findByG_S(groupId, statusId, start, end, orderByComparator); 475 } 476 477 /** 478 * Returns an ordered range of all the membership requests where groupId = ? and statusId = ?. 479 * 480 * <p> 481 * 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 MembershipRequestModelImpl}. 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. 482 * </p> 483 * 484 * @param groupId the group ID 485 * @param statusId the status ID 486 * @param start the lower bound of the range of membership requests 487 * @param end the upper bound of the range of membership requests (not inclusive) 488 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 489 * @param retrieveFromCache whether to retrieve from the finder cache 490 * @return the ordered range of matching membership requests 491 */ 492 public static List<MembershipRequest> findByG_S(long groupId, 493 long statusId, int start, int end, 494 OrderByComparator<MembershipRequest> orderByComparator, 495 boolean retrieveFromCache) { 496 return getPersistence() 497 .findByG_S(groupId, statusId, start, end, orderByComparator, 498 retrieveFromCache); 499 } 500 501 /** 502 * Returns the first membership request in the ordered set where groupId = ? and statusId = ?. 503 * 504 * @param groupId the group ID 505 * @param statusId the status ID 506 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 507 * @return the first matching membership request 508 * @throws NoSuchMembershipRequestException if a matching membership request could not be found 509 */ 510 public static MembershipRequest findByG_S_First(long groupId, 511 long statusId, OrderByComparator<MembershipRequest> orderByComparator) 512 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 513 return getPersistence() 514 .findByG_S_First(groupId, statusId, orderByComparator); 515 } 516 517 /** 518 * Returns the first membership request in the ordered set where groupId = ? and statusId = ?. 519 * 520 * @param groupId the group ID 521 * @param statusId the status ID 522 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 523 * @return the first matching membership request, or <code>null</code> if a matching membership request could not be found 524 */ 525 public static MembershipRequest fetchByG_S_First(long groupId, 526 long statusId, OrderByComparator<MembershipRequest> orderByComparator) { 527 return getPersistence() 528 .fetchByG_S_First(groupId, statusId, orderByComparator); 529 } 530 531 /** 532 * Returns the last membership request in the ordered set where groupId = ? and statusId = ?. 533 * 534 * @param groupId the group ID 535 * @param statusId the status ID 536 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 537 * @return the last matching membership request 538 * @throws NoSuchMembershipRequestException if a matching membership request could not be found 539 */ 540 public static MembershipRequest findByG_S_Last(long groupId, long statusId, 541 OrderByComparator<MembershipRequest> orderByComparator) 542 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 543 return getPersistence() 544 .findByG_S_Last(groupId, statusId, orderByComparator); 545 } 546 547 /** 548 * Returns the last membership request in the ordered set where groupId = ? and statusId = ?. 549 * 550 * @param groupId the group ID 551 * @param statusId the status ID 552 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 553 * @return the last matching membership request, or <code>null</code> if a matching membership request could not be found 554 */ 555 public static MembershipRequest fetchByG_S_Last(long groupId, 556 long statusId, OrderByComparator<MembershipRequest> orderByComparator) { 557 return getPersistence() 558 .fetchByG_S_Last(groupId, statusId, orderByComparator); 559 } 560 561 /** 562 * Returns the membership requests before and after the current membership request in the ordered set where groupId = ? and statusId = ?. 563 * 564 * @param membershipRequestId the primary key of the current membership request 565 * @param groupId the group ID 566 * @param statusId the status ID 567 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 568 * @return the previous, current, and next membership request 569 * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found 570 */ 571 public static MembershipRequest[] findByG_S_PrevAndNext( 572 long membershipRequestId, long groupId, long statusId, 573 OrderByComparator<MembershipRequest> orderByComparator) 574 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 575 return getPersistence() 576 .findByG_S_PrevAndNext(membershipRequestId, groupId, 577 statusId, orderByComparator); 578 } 579 580 /** 581 * Removes all the membership requests where groupId = ? and statusId = ? from the database. 582 * 583 * @param groupId the group ID 584 * @param statusId the status ID 585 */ 586 public static void removeByG_S(long groupId, long statusId) { 587 getPersistence().removeByG_S(groupId, statusId); 588 } 589 590 /** 591 * Returns the number of membership requests where groupId = ? and statusId = ?. 592 * 593 * @param groupId the group ID 594 * @param statusId the status ID 595 * @return the number of matching membership requests 596 */ 597 public static int countByG_S(long groupId, long statusId) { 598 return getPersistence().countByG_S(groupId, statusId); 599 } 600 601 /** 602 * Returns all the membership requests where groupId = ? and userId = ? and statusId = ?. 603 * 604 * @param groupId the group ID 605 * @param userId the user ID 606 * @param statusId the status ID 607 * @return the matching membership requests 608 */ 609 public static List<MembershipRequest> findByG_U_S(long groupId, 610 long userId, long statusId) { 611 return getPersistence().findByG_U_S(groupId, userId, statusId); 612 } 613 614 /** 615 * Returns a range of all the membership requests where groupId = ? and userId = ? and statusId = ?. 616 * 617 * <p> 618 * 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 MembershipRequestModelImpl}. 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. 619 * </p> 620 * 621 * @param groupId the group ID 622 * @param userId the user ID 623 * @param statusId the status ID 624 * @param start the lower bound of the range of membership requests 625 * @param end the upper bound of the range of membership requests (not inclusive) 626 * @return the range of matching membership requests 627 */ 628 public static List<MembershipRequest> findByG_U_S(long groupId, 629 long userId, long statusId, int start, int end) { 630 return getPersistence() 631 .findByG_U_S(groupId, userId, statusId, start, end); 632 } 633 634 /** 635 * Returns an ordered range of all the membership requests where groupId = ? and userId = ? and statusId = ?. 636 * 637 * <p> 638 * 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 MembershipRequestModelImpl}. 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. 639 * </p> 640 * 641 * @param groupId the group ID 642 * @param userId the user ID 643 * @param statusId the status ID 644 * @param start the lower bound of the range of membership requests 645 * @param end the upper bound of the range of membership requests (not inclusive) 646 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 647 * @return the ordered range of matching membership requests 648 */ 649 public static List<MembershipRequest> findByG_U_S(long groupId, 650 long userId, long statusId, int start, int end, 651 OrderByComparator<MembershipRequest> orderByComparator) { 652 return getPersistence() 653 .findByG_U_S(groupId, userId, statusId, start, end, 654 orderByComparator); 655 } 656 657 /** 658 * Returns an ordered range of all the membership requests where groupId = ? and userId = ? and statusId = ?. 659 * 660 * <p> 661 * 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 MembershipRequestModelImpl}. 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. 662 * </p> 663 * 664 * @param groupId the group ID 665 * @param userId the user ID 666 * @param statusId the status ID 667 * @param start the lower bound of the range of membership requests 668 * @param end the upper bound of the range of membership requests (not inclusive) 669 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 670 * @param retrieveFromCache whether to retrieve from the finder cache 671 * @return the ordered range of matching membership requests 672 */ 673 public static List<MembershipRequest> findByG_U_S(long groupId, 674 long userId, long statusId, int start, int end, 675 OrderByComparator<MembershipRequest> orderByComparator, 676 boolean retrieveFromCache) { 677 return getPersistence() 678 .findByG_U_S(groupId, userId, statusId, start, end, 679 orderByComparator, retrieveFromCache); 680 } 681 682 /** 683 * Returns the first membership request in the ordered set where groupId = ? and userId = ? and statusId = ?. 684 * 685 * @param groupId the group ID 686 * @param userId the user ID 687 * @param statusId the status ID 688 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 689 * @return the first matching membership request 690 * @throws NoSuchMembershipRequestException if a matching membership request could not be found 691 */ 692 public static MembershipRequest findByG_U_S_First(long groupId, 693 long userId, long statusId, 694 OrderByComparator<MembershipRequest> orderByComparator) 695 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 696 return getPersistence() 697 .findByG_U_S_First(groupId, userId, statusId, 698 orderByComparator); 699 } 700 701 /** 702 * Returns the first membership request in the ordered set where groupId = ? and userId = ? and statusId = ?. 703 * 704 * @param groupId the group ID 705 * @param userId the user ID 706 * @param statusId the status ID 707 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 708 * @return the first matching membership request, or <code>null</code> if a matching membership request could not be found 709 */ 710 public static MembershipRequest fetchByG_U_S_First(long groupId, 711 long userId, long statusId, 712 OrderByComparator<MembershipRequest> orderByComparator) { 713 return getPersistence() 714 .fetchByG_U_S_First(groupId, userId, statusId, 715 orderByComparator); 716 } 717 718 /** 719 * Returns the last membership request in the ordered set where groupId = ? and userId = ? and statusId = ?. 720 * 721 * @param groupId the group ID 722 * @param userId the user ID 723 * @param statusId the status ID 724 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 725 * @return the last matching membership request 726 * @throws NoSuchMembershipRequestException if a matching membership request could not be found 727 */ 728 public static MembershipRequest findByG_U_S_Last(long groupId, long userId, 729 long statusId, OrderByComparator<MembershipRequest> orderByComparator) 730 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 731 return getPersistence() 732 .findByG_U_S_Last(groupId, userId, statusId, 733 orderByComparator); 734 } 735 736 /** 737 * Returns the last membership request in the ordered set where groupId = ? and userId = ? and statusId = ?. 738 * 739 * @param groupId the group ID 740 * @param userId the user ID 741 * @param statusId the status ID 742 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 743 * @return the last matching membership request, or <code>null</code> if a matching membership request could not be found 744 */ 745 public static MembershipRequest fetchByG_U_S_Last(long groupId, 746 long userId, long statusId, 747 OrderByComparator<MembershipRequest> orderByComparator) { 748 return getPersistence() 749 .fetchByG_U_S_Last(groupId, userId, statusId, 750 orderByComparator); 751 } 752 753 /** 754 * Returns the membership requests before and after the current membership request in the ordered set where groupId = ? and userId = ? and statusId = ?. 755 * 756 * @param membershipRequestId the primary key of the current membership request 757 * @param groupId the group ID 758 * @param userId the user ID 759 * @param statusId the status ID 760 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 761 * @return the previous, current, and next membership request 762 * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found 763 */ 764 public static MembershipRequest[] findByG_U_S_PrevAndNext( 765 long membershipRequestId, long groupId, long userId, long statusId, 766 OrderByComparator<MembershipRequest> orderByComparator) 767 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 768 return getPersistence() 769 .findByG_U_S_PrevAndNext(membershipRequestId, groupId, 770 userId, statusId, orderByComparator); 771 } 772 773 /** 774 * Removes all the membership requests where groupId = ? and userId = ? and statusId = ? from the database. 775 * 776 * @param groupId the group ID 777 * @param userId the user ID 778 * @param statusId the status ID 779 */ 780 public static void removeByG_U_S(long groupId, long userId, long statusId) { 781 getPersistence().removeByG_U_S(groupId, userId, statusId); 782 } 783 784 /** 785 * Returns the number of membership requests where groupId = ? and userId = ? and statusId = ?. 786 * 787 * @param groupId the group ID 788 * @param userId the user ID 789 * @param statusId the status ID 790 * @return the number of matching membership requests 791 */ 792 public static int countByG_U_S(long groupId, long userId, long statusId) { 793 return getPersistence().countByG_U_S(groupId, userId, statusId); 794 } 795 796 /** 797 * Caches the membership request in the entity cache if it is enabled. 798 * 799 * @param membershipRequest the membership request 800 */ 801 public static void cacheResult(MembershipRequest membershipRequest) { 802 getPersistence().cacheResult(membershipRequest); 803 } 804 805 /** 806 * Caches the membership requests in the entity cache if it is enabled. 807 * 808 * @param membershipRequests the membership requests 809 */ 810 public static void cacheResult(List<MembershipRequest> membershipRequests) { 811 getPersistence().cacheResult(membershipRequests); 812 } 813 814 /** 815 * Creates a new membership request with the primary key. Does not add the membership request to the database. 816 * 817 * @param membershipRequestId the primary key for the new membership request 818 * @return the new membership request 819 */ 820 public static MembershipRequest create(long membershipRequestId) { 821 return getPersistence().create(membershipRequestId); 822 } 823 824 /** 825 * Removes the membership request with the primary key from the database. Also notifies the appropriate model listeners. 826 * 827 * @param membershipRequestId the primary key of the membership request 828 * @return the membership request that was removed 829 * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found 830 */ 831 public static MembershipRequest remove(long membershipRequestId) 832 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 833 return getPersistence().remove(membershipRequestId); 834 } 835 836 public static MembershipRequest updateImpl( 837 MembershipRequest membershipRequest) { 838 return getPersistence().updateImpl(membershipRequest); 839 } 840 841 /** 842 * Returns the membership request with the primary key or throws a {@link NoSuchMembershipRequestException} if it could not be found. 843 * 844 * @param membershipRequestId the primary key of the membership request 845 * @return the membership request 846 * @throws NoSuchMembershipRequestException if a membership request with the primary key could not be found 847 */ 848 public static MembershipRequest findByPrimaryKey(long membershipRequestId) 849 throws com.liferay.portal.exception.NoSuchMembershipRequestException { 850 return getPersistence().findByPrimaryKey(membershipRequestId); 851 } 852 853 /** 854 * Returns the membership request with the primary key or returns <code>null</code> if it could not be found. 855 * 856 * @param membershipRequestId the primary key of the membership request 857 * @return the membership request, or <code>null</code> if a membership request with the primary key could not be found 858 */ 859 public static MembershipRequest fetchByPrimaryKey(long membershipRequestId) { 860 return getPersistence().fetchByPrimaryKey(membershipRequestId); 861 } 862 863 public static java.util.Map<java.io.Serializable, MembershipRequest> fetchByPrimaryKeys( 864 java.util.Set<java.io.Serializable> primaryKeys) { 865 return getPersistence().fetchByPrimaryKeys(primaryKeys); 866 } 867 868 /** 869 * Returns all the membership requests. 870 * 871 * @return the membership requests 872 */ 873 public static List<MembershipRequest> findAll() { 874 return getPersistence().findAll(); 875 } 876 877 /** 878 * Returns a range of all the membership requests. 879 * 880 * <p> 881 * 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 MembershipRequestModelImpl}. 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. 882 * </p> 883 * 884 * @param start the lower bound of the range of membership requests 885 * @param end the upper bound of the range of membership requests (not inclusive) 886 * @return the range of membership requests 887 */ 888 public static List<MembershipRequest> findAll(int start, int end) { 889 return getPersistence().findAll(start, end); 890 } 891 892 /** 893 * Returns an ordered range of all the membership requests. 894 * 895 * <p> 896 * 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 MembershipRequestModelImpl}. 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. 897 * </p> 898 * 899 * @param start the lower bound of the range of membership requests 900 * @param end the upper bound of the range of membership requests (not inclusive) 901 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 902 * @return the ordered range of membership requests 903 */ 904 public static List<MembershipRequest> findAll(int start, int end, 905 OrderByComparator<MembershipRequest> orderByComparator) { 906 return getPersistence().findAll(start, end, orderByComparator); 907 } 908 909 /** 910 * Returns an ordered range of all the membership requests. 911 * 912 * <p> 913 * 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 MembershipRequestModelImpl}. 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. 914 * </p> 915 * 916 * @param start the lower bound of the range of membership requests 917 * @param end the upper bound of the range of membership requests (not inclusive) 918 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 919 * @param retrieveFromCache whether to retrieve from the finder cache 920 * @return the ordered range of membership requests 921 */ 922 public static List<MembershipRequest> findAll(int start, int end, 923 OrderByComparator<MembershipRequest> orderByComparator, 924 boolean retrieveFromCache) { 925 return getPersistence() 926 .findAll(start, end, orderByComparator, retrieveFromCache); 927 } 928 929 /** 930 * Removes all the membership requests from the database. 931 */ 932 public static void removeAll() { 933 getPersistence().removeAll(); 934 } 935 936 /** 937 * Returns the number of membership requests. 938 * 939 * @return the number of membership requests 940 */ 941 public static int countAll() { 942 return getPersistence().countAll(); 943 } 944 945 public static MembershipRequestPersistence getPersistence() { 946 if (_persistence == null) { 947 _persistence = (MembershipRequestPersistence)PortalBeanLocatorUtil.locate(MembershipRequestPersistence.class.getName()); 948 949 ReferenceRegistry.registerReference(MembershipRequestUtil.class, 950 "_persistence"); 951 } 952 953 return _persistence; 954 } 955 956 private static MembershipRequestPersistence _persistence; 957 }