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.shopping.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.shopping.model.ShoppingOrder; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the shopping order service. This utility wraps {@link com.liferay.portlet.shopping.service.persistence.impl.ShoppingOrderPersistenceImpl} 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 ShoppingOrderPersistence 038 * @see com.liferay.portlet.shopping.service.persistence.impl.ShoppingOrderPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class ShoppingOrderUtil { 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(ShoppingOrder shoppingOrder) { 060 getPersistence().clearCache(shoppingOrder); 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<ShoppingOrder> 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<ShoppingOrder> 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<ShoppingOrder> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<ShoppingOrder> 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 ShoppingOrder update(ShoppingOrder shoppingOrder) { 101 return getPersistence().update(shoppingOrder); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static ShoppingOrder update(ShoppingOrder shoppingOrder, 108 ServiceContext serviceContext) { 109 return getPersistence().update(shoppingOrder, serviceContext); 110 } 111 112 /** 113 * Returns all the shopping orders where groupId = ?. 114 * 115 * @param groupId the group ID 116 * @return the matching shopping orders 117 */ 118 public static List<ShoppingOrder> findByGroupId(long groupId) { 119 return getPersistence().findByGroupId(groupId); 120 } 121 122 /** 123 * Returns a range of all the shopping orders where groupId = ?. 124 * 125 * <p> 126 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShoppingOrderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 127 * </p> 128 * 129 * @param groupId the group ID 130 * @param start the lower bound of the range of shopping orders 131 * @param end the upper bound of the range of shopping orders (not inclusive) 132 * @return the range of matching shopping orders 133 */ 134 public static List<ShoppingOrder> findByGroupId(long groupId, int start, 135 int end) { 136 return getPersistence().findByGroupId(groupId, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the shopping orders where groupId = ?. 141 * 142 * <p> 143 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShoppingOrderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 144 * </p> 145 * 146 * @param groupId the group ID 147 * @param start the lower bound of the range of shopping orders 148 * @param end the upper bound of the range of shopping orders (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching shopping orders 151 */ 152 public static List<ShoppingOrder> findByGroupId(long groupId, int start, 153 int end, OrderByComparator<ShoppingOrder> orderByComparator) { 154 return getPersistence() 155 .findByGroupId(groupId, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns the first shopping order in the ordered set where groupId = ?. 160 * 161 * @param groupId the group ID 162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 163 * @return the first matching shopping order 164 * @throws NoSuchOrderException if a matching shopping order could not be found 165 */ 166 public static ShoppingOrder findByGroupId_First(long groupId, 167 OrderByComparator<ShoppingOrder> orderByComparator) 168 throws com.liferay.portlet.shopping.NoSuchOrderException { 169 return getPersistence().findByGroupId_First(groupId, orderByComparator); 170 } 171 172 /** 173 * Returns the first shopping order in the ordered set where groupId = ?. 174 * 175 * @param groupId the group ID 176 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 177 * @return the first matching shopping order, or <code>null</code> if a matching shopping order could not be found 178 */ 179 public static ShoppingOrder fetchByGroupId_First(long groupId, 180 OrderByComparator<ShoppingOrder> orderByComparator) { 181 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 182 } 183 184 /** 185 * Returns the last shopping order in the ordered set where groupId = ?. 186 * 187 * @param groupId the group ID 188 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 189 * @return the last matching shopping order 190 * @throws NoSuchOrderException if a matching shopping order could not be found 191 */ 192 public static ShoppingOrder findByGroupId_Last(long groupId, 193 OrderByComparator<ShoppingOrder> orderByComparator) 194 throws com.liferay.portlet.shopping.NoSuchOrderException { 195 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 196 } 197 198 /** 199 * Returns the last shopping order in the ordered set where groupId = ?. 200 * 201 * @param groupId the group ID 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching shopping order, or <code>null</code> if a matching shopping order could not be found 204 */ 205 public static ShoppingOrder fetchByGroupId_Last(long groupId, 206 OrderByComparator<ShoppingOrder> orderByComparator) { 207 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 208 } 209 210 /** 211 * Returns the shopping orders before and after the current shopping order in the ordered set where groupId = ?. 212 * 213 * @param orderId the primary key of the current shopping order 214 * @param groupId the group ID 215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 216 * @return the previous, current, and next shopping order 217 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 218 */ 219 public static ShoppingOrder[] findByGroupId_PrevAndNext(long orderId, 220 long groupId, OrderByComparator<ShoppingOrder> orderByComparator) 221 throws com.liferay.portlet.shopping.NoSuchOrderException { 222 return getPersistence() 223 .findByGroupId_PrevAndNext(orderId, groupId, 224 orderByComparator); 225 } 226 227 /** 228 * Returns all the shopping orders that the user has permission to view where groupId = ?. 229 * 230 * @param groupId the group ID 231 * @return the matching shopping orders that the user has permission to view 232 */ 233 public static List<ShoppingOrder> filterFindByGroupId(long groupId) { 234 return getPersistence().filterFindByGroupId(groupId); 235 } 236 237 /** 238 * Returns a range of all the shopping orders that the user has permission to view where groupId = ?. 239 * 240 * <p> 241 * 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 ShoppingOrderModelImpl}. 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. 242 * </p> 243 * 244 * @param groupId the group ID 245 * @param start the lower bound of the range of shopping orders 246 * @param end the upper bound of the range of shopping orders (not inclusive) 247 * @return the range of matching shopping orders that the user has permission to view 248 */ 249 public static List<ShoppingOrder> filterFindByGroupId(long groupId, 250 int start, int end) { 251 return getPersistence().filterFindByGroupId(groupId, start, end); 252 } 253 254 /** 255 * Returns an ordered range of all the shopping orders that the user has permissions to view where groupId = ?. 256 * 257 * <p> 258 * 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 ShoppingOrderModelImpl}. 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. 259 * </p> 260 * 261 * @param groupId the group ID 262 * @param start the lower bound of the range of shopping orders 263 * @param end the upper bound of the range of shopping orders (not inclusive) 264 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 265 * @return the ordered range of matching shopping orders that the user has permission to view 266 */ 267 public static List<ShoppingOrder> filterFindByGroupId(long groupId, 268 int start, int end, OrderByComparator<ShoppingOrder> orderByComparator) { 269 return getPersistence() 270 .filterFindByGroupId(groupId, start, end, orderByComparator); 271 } 272 273 /** 274 * Returns the shopping orders before and after the current shopping order in the ordered set of shopping orders that the user has permission to view where groupId = ?. 275 * 276 * @param orderId the primary key of the current shopping order 277 * @param groupId the group ID 278 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 279 * @return the previous, current, and next shopping order 280 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 281 */ 282 public static ShoppingOrder[] filterFindByGroupId_PrevAndNext( 283 long orderId, long groupId, 284 OrderByComparator<ShoppingOrder> orderByComparator) 285 throws com.liferay.portlet.shopping.NoSuchOrderException { 286 return getPersistence() 287 .filterFindByGroupId_PrevAndNext(orderId, groupId, 288 orderByComparator); 289 } 290 291 /** 292 * Removes all the shopping orders where groupId = ? from the database. 293 * 294 * @param groupId the group ID 295 */ 296 public static void removeByGroupId(long groupId) { 297 getPersistence().removeByGroupId(groupId); 298 } 299 300 /** 301 * Returns the number of shopping orders where groupId = ?. 302 * 303 * @param groupId the group ID 304 * @return the number of matching shopping orders 305 */ 306 public static int countByGroupId(long groupId) { 307 return getPersistence().countByGroupId(groupId); 308 } 309 310 /** 311 * Returns the number of shopping orders that the user has permission to view where groupId = ?. 312 * 313 * @param groupId the group ID 314 * @return the number of matching shopping orders that the user has permission to view 315 */ 316 public static int filterCountByGroupId(long groupId) { 317 return getPersistence().filterCountByGroupId(groupId); 318 } 319 320 /** 321 * Returns the shopping order where number = ? or throws a {@link NoSuchOrderException} if it could not be found. 322 * 323 * @param number the number 324 * @return the matching shopping order 325 * @throws NoSuchOrderException if a matching shopping order could not be found 326 */ 327 public static ShoppingOrder findByNumber(java.lang.String number) 328 throws com.liferay.portlet.shopping.NoSuchOrderException { 329 return getPersistence().findByNumber(number); 330 } 331 332 /** 333 * Returns the shopping order where number = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 334 * 335 * @param number the number 336 * @return the matching shopping order, or <code>null</code> if a matching shopping order could not be found 337 */ 338 public static ShoppingOrder fetchByNumber(java.lang.String number) { 339 return getPersistence().fetchByNumber(number); 340 } 341 342 /** 343 * Returns the shopping order where number = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 344 * 345 * @param number the number 346 * @param retrieveFromCache whether to use the finder cache 347 * @return the matching shopping order, or <code>null</code> if a matching shopping order could not be found 348 */ 349 public static ShoppingOrder fetchByNumber(java.lang.String number, 350 boolean retrieveFromCache) { 351 return getPersistence().fetchByNumber(number, retrieveFromCache); 352 } 353 354 /** 355 * Removes the shopping order where number = ? from the database. 356 * 357 * @param number the number 358 * @return the shopping order that was removed 359 */ 360 public static ShoppingOrder removeByNumber(java.lang.String number) 361 throws com.liferay.portlet.shopping.NoSuchOrderException { 362 return getPersistence().removeByNumber(number); 363 } 364 365 /** 366 * Returns the number of shopping orders where number = ?. 367 * 368 * @param number the number 369 * @return the number of matching shopping orders 370 */ 371 public static int countByNumber(java.lang.String number) { 372 return getPersistence().countByNumber(number); 373 } 374 375 /** 376 * Returns the shopping order where ppTxnId = ? or throws a {@link NoSuchOrderException} if it could not be found. 377 * 378 * @param ppTxnId the pp txn ID 379 * @return the matching shopping order 380 * @throws NoSuchOrderException if a matching shopping order could not be found 381 */ 382 public static ShoppingOrder findByPPTxnId(java.lang.String ppTxnId) 383 throws com.liferay.portlet.shopping.NoSuchOrderException { 384 return getPersistence().findByPPTxnId(ppTxnId); 385 } 386 387 /** 388 * Returns the shopping order where ppTxnId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 389 * 390 * @param ppTxnId the pp txn ID 391 * @return the matching shopping order, or <code>null</code> if a matching shopping order could not be found 392 */ 393 public static ShoppingOrder fetchByPPTxnId(java.lang.String ppTxnId) { 394 return getPersistence().fetchByPPTxnId(ppTxnId); 395 } 396 397 /** 398 * Returns the shopping order where ppTxnId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 399 * 400 * @param ppTxnId the pp txn ID 401 * @param retrieveFromCache whether to use the finder cache 402 * @return the matching shopping order, or <code>null</code> if a matching shopping order could not be found 403 */ 404 public static ShoppingOrder fetchByPPTxnId(java.lang.String ppTxnId, 405 boolean retrieveFromCache) { 406 return getPersistence().fetchByPPTxnId(ppTxnId, retrieveFromCache); 407 } 408 409 /** 410 * Removes the shopping order where ppTxnId = ? from the database. 411 * 412 * @param ppTxnId the pp txn ID 413 * @return the shopping order that was removed 414 */ 415 public static ShoppingOrder removeByPPTxnId(java.lang.String ppTxnId) 416 throws com.liferay.portlet.shopping.NoSuchOrderException { 417 return getPersistence().removeByPPTxnId(ppTxnId); 418 } 419 420 /** 421 * Returns the number of shopping orders where ppTxnId = ?. 422 * 423 * @param ppTxnId the pp txn ID 424 * @return the number of matching shopping orders 425 */ 426 public static int countByPPTxnId(java.lang.String ppTxnId) { 427 return getPersistence().countByPPTxnId(ppTxnId); 428 } 429 430 /** 431 * Returns all the shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ?. 432 * 433 * @param groupId the group ID 434 * @param userId the user ID 435 * @param ppPaymentStatus the pp payment status 436 * @return the matching shopping orders 437 */ 438 public static List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId, 439 java.lang.String ppPaymentStatus) { 440 return getPersistence().findByG_U_PPPS(groupId, userId, ppPaymentStatus); 441 } 442 443 /** 444 * Returns a range of all the shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ?. 445 * 446 * <p> 447 * 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 ShoppingOrderModelImpl}. 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. 448 * </p> 449 * 450 * @param groupId the group ID 451 * @param userId the user ID 452 * @param ppPaymentStatus the pp payment status 453 * @param start the lower bound of the range of shopping orders 454 * @param end the upper bound of the range of shopping orders (not inclusive) 455 * @return the range of matching shopping orders 456 */ 457 public static List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId, 458 java.lang.String ppPaymentStatus, int start, int end) { 459 return getPersistence() 460 .findByG_U_PPPS(groupId, userId, ppPaymentStatus, start, end); 461 } 462 463 /** 464 * Returns an ordered range of all the shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ?. 465 * 466 * <p> 467 * 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 ShoppingOrderModelImpl}. 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. 468 * </p> 469 * 470 * @param groupId the group ID 471 * @param userId the user ID 472 * @param ppPaymentStatus the pp payment status 473 * @param start the lower bound of the range of shopping orders 474 * @param end the upper bound of the range of shopping orders (not inclusive) 475 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 476 * @return the ordered range of matching shopping orders 477 */ 478 public static List<ShoppingOrder> findByG_U_PPPS(long groupId, long userId, 479 java.lang.String ppPaymentStatus, int start, int end, 480 OrderByComparator<ShoppingOrder> orderByComparator) { 481 return getPersistence() 482 .findByG_U_PPPS(groupId, userId, ppPaymentStatus, start, 483 end, orderByComparator); 484 } 485 486 /** 487 * Returns the first shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 488 * 489 * @param groupId the group ID 490 * @param userId the user ID 491 * @param ppPaymentStatus the pp payment status 492 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 493 * @return the first matching shopping order 494 * @throws NoSuchOrderException if a matching shopping order could not be found 495 */ 496 public static ShoppingOrder findByG_U_PPPS_First(long groupId, long userId, 497 java.lang.String ppPaymentStatus, 498 OrderByComparator<ShoppingOrder> orderByComparator) 499 throws com.liferay.portlet.shopping.NoSuchOrderException { 500 return getPersistence() 501 .findByG_U_PPPS_First(groupId, userId, ppPaymentStatus, 502 orderByComparator); 503 } 504 505 /** 506 * Returns the first shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 507 * 508 * @param groupId the group ID 509 * @param userId the user ID 510 * @param ppPaymentStatus the pp payment status 511 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 512 * @return the first matching shopping order, or <code>null</code> if a matching shopping order could not be found 513 */ 514 public static ShoppingOrder fetchByG_U_PPPS_First(long groupId, 515 long userId, java.lang.String ppPaymentStatus, 516 OrderByComparator<ShoppingOrder> orderByComparator) { 517 return getPersistence() 518 .fetchByG_U_PPPS_First(groupId, userId, ppPaymentStatus, 519 orderByComparator); 520 } 521 522 /** 523 * Returns the last shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 524 * 525 * @param groupId the group ID 526 * @param userId the user ID 527 * @param ppPaymentStatus the pp payment status 528 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 529 * @return the last matching shopping order 530 * @throws NoSuchOrderException if a matching shopping order could not be found 531 */ 532 public static ShoppingOrder findByG_U_PPPS_Last(long groupId, long userId, 533 java.lang.String ppPaymentStatus, 534 OrderByComparator<ShoppingOrder> orderByComparator) 535 throws com.liferay.portlet.shopping.NoSuchOrderException { 536 return getPersistence() 537 .findByG_U_PPPS_Last(groupId, userId, ppPaymentStatus, 538 orderByComparator); 539 } 540 541 /** 542 * Returns the last shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 543 * 544 * @param groupId the group ID 545 * @param userId the user ID 546 * @param ppPaymentStatus the pp payment status 547 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 548 * @return the last matching shopping order, or <code>null</code> if a matching shopping order could not be found 549 */ 550 public static ShoppingOrder fetchByG_U_PPPS_Last(long groupId, long userId, 551 java.lang.String ppPaymentStatus, 552 OrderByComparator<ShoppingOrder> orderByComparator) { 553 return getPersistence() 554 .fetchByG_U_PPPS_Last(groupId, userId, ppPaymentStatus, 555 orderByComparator); 556 } 557 558 /** 559 * Returns the shopping orders before and after the current shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 560 * 561 * @param orderId the primary key of the current shopping order 562 * @param groupId the group ID 563 * @param userId the user ID 564 * @param ppPaymentStatus the pp payment status 565 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 566 * @return the previous, current, and next shopping order 567 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 568 */ 569 public static ShoppingOrder[] findByG_U_PPPS_PrevAndNext(long orderId, 570 long groupId, long userId, java.lang.String ppPaymentStatus, 571 OrderByComparator<ShoppingOrder> orderByComparator) 572 throws com.liferay.portlet.shopping.NoSuchOrderException { 573 return getPersistence() 574 .findByG_U_PPPS_PrevAndNext(orderId, groupId, userId, 575 ppPaymentStatus, orderByComparator); 576 } 577 578 /** 579 * Returns all the shopping orders that the user has permission to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 580 * 581 * @param groupId the group ID 582 * @param userId the user ID 583 * @param ppPaymentStatus the pp payment status 584 * @return the matching shopping orders that the user has permission to view 585 */ 586 public static List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, 587 long userId, java.lang.String ppPaymentStatus) { 588 return getPersistence() 589 .filterFindByG_U_PPPS(groupId, userId, ppPaymentStatus); 590 } 591 592 /** 593 * Returns a range of all the shopping orders that the user has permission to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 594 * 595 * <p> 596 * 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 ShoppingOrderModelImpl}. 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. 597 * </p> 598 * 599 * @param groupId the group ID 600 * @param userId the user ID 601 * @param ppPaymentStatus the pp payment status 602 * @param start the lower bound of the range of shopping orders 603 * @param end the upper bound of the range of shopping orders (not inclusive) 604 * @return the range of matching shopping orders that the user has permission to view 605 */ 606 public static List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, 607 long userId, java.lang.String ppPaymentStatus, int start, int end) { 608 return getPersistence() 609 .filterFindByG_U_PPPS(groupId, userId, ppPaymentStatus, 610 start, end); 611 } 612 613 /** 614 * Returns an ordered range of all the shopping orders that the user has permissions to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 615 * 616 * <p> 617 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link ShoppingOrderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 618 * </p> 619 * 620 * @param groupId the group ID 621 * @param userId the user ID 622 * @param ppPaymentStatus the pp payment status 623 * @param start the lower bound of the range of shopping orders 624 * @param end the upper bound of the range of shopping orders (not inclusive) 625 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 626 * @return the ordered range of matching shopping orders that the user has permission to view 627 */ 628 public static List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, 629 long userId, java.lang.String ppPaymentStatus, int start, int end, 630 OrderByComparator<ShoppingOrder> orderByComparator) { 631 return getPersistence() 632 .filterFindByG_U_PPPS(groupId, userId, ppPaymentStatus, 633 start, end, orderByComparator); 634 } 635 636 /** 637 * Returns the shopping orders before and after the current shopping order in the ordered set of shopping orders that the user has permission to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 638 * 639 * @param orderId the primary key of the current shopping order 640 * @param groupId the group ID 641 * @param userId the user ID 642 * @param ppPaymentStatus the pp payment status 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the previous, current, and next shopping order 645 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 646 */ 647 public static ShoppingOrder[] filterFindByG_U_PPPS_PrevAndNext( 648 long orderId, long groupId, long userId, 649 java.lang.String ppPaymentStatus, 650 OrderByComparator<ShoppingOrder> orderByComparator) 651 throws com.liferay.portlet.shopping.NoSuchOrderException { 652 return getPersistence() 653 .filterFindByG_U_PPPS_PrevAndNext(orderId, groupId, userId, 654 ppPaymentStatus, orderByComparator); 655 } 656 657 /** 658 * Removes all the shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ? from the database. 659 * 660 * @param groupId the group ID 661 * @param userId the user ID 662 * @param ppPaymentStatus the pp payment status 663 */ 664 public static void removeByG_U_PPPS(long groupId, long userId, 665 java.lang.String ppPaymentStatus) { 666 getPersistence().removeByG_U_PPPS(groupId, userId, ppPaymentStatus); 667 } 668 669 /** 670 * Returns the number of shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ?. 671 * 672 * @param groupId the group ID 673 * @param userId the user ID 674 * @param ppPaymentStatus the pp payment status 675 * @return the number of matching shopping orders 676 */ 677 public static int countByG_U_PPPS(long groupId, long userId, 678 java.lang.String ppPaymentStatus) { 679 return getPersistence().countByG_U_PPPS(groupId, userId, ppPaymentStatus); 680 } 681 682 /** 683 * Returns the number of shopping orders that the user has permission to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 684 * 685 * @param groupId the group ID 686 * @param userId the user ID 687 * @param ppPaymentStatus the pp payment status 688 * @return the number of matching shopping orders that the user has permission to view 689 */ 690 public static int filterCountByG_U_PPPS(long groupId, long userId, 691 java.lang.String ppPaymentStatus) { 692 return getPersistence() 693 .filterCountByG_U_PPPS(groupId, userId, ppPaymentStatus); 694 } 695 696 /** 697 * Caches the shopping order in the entity cache if it is enabled. 698 * 699 * @param shoppingOrder the shopping order 700 */ 701 public static void cacheResult(ShoppingOrder shoppingOrder) { 702 getPersistence().cacheResult(shoppingOrder); 703 } 704 705 /** 706 * Caches the shopping orders in the entity cache if it is enabled. 707 * 708 * @param shoppingOrders the shopping orders 709 */ 710 public static void cacheResult(List<ShoppingOrder> shoppingOrders) { 711 getPersistence().cacheResult(shoppingOrders); 712 } 713 714 /** 715 * Creates a new shopping order with the primary key. Does not add the shopping order to the database. 716 * 717 * @param orderId the primary key for the new shopping order 718 * @return the new shopping order 719 */ 720 public static ShoppingOrder create(long orderId) { 721 return getPersistence().create(orderId); 722 } 723 724 /** 725 * Removes the shopping order with the primary key from the database. Also notifies the appropriate model listeners. 726 * 727 * @param orderId the primary key of the shopping order 728 * @return the shopping order that was removed 729 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 730 */ 731 public static ShoppingOrder remove(long orderId) 732 throws com.liferay.portlet.shopping.NoSuchOrderException { 733 return getPersistence().remove(orderId); 734 } 735 736 public static ShoppingOrder updateImpl(ShoppingOrder shoppingOrder) { 737 return getPersistence().updateImpl(shoppingOrder); 738 } 739 740 /** 741 * Returns the shopping order with the primary key or throws a {@link NoSuchOrderException} if it could not be found. 742 * 743 * @param orderId the primary key of the shopping order 744 * @return the shopping order 745 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 746 */ 747 public static ShoppingOrder findByPrimaryKey(long orderId) 748 throws com.liferay.portlet.shopping.NoSuchOrderException { 749 return getPersistence().findByPrimaryKey(orderId); 750 } 751 752 /** 753 * Returns the shopping order with the primary key or returns <code>null</code> if it could not be found. 754 * 755 * @param orderId the primary key of the shopping order 756 * @return the shopping order, or <code>null</code> if a shopping order with the primary key could not be found 757 */ 758 public static ShoppingOrder fetchByPrimaryKey(long orderId) { 759 return getPersistence().fetchByPrimaryKey(orderId); 760 } 761 762 public static java.util.Map<java.io.Serializable, ShoppingOrder> fetchByPrimaryKeys( 763 java.util.Set<java.io.Serializable> primaryKeys) { 764 return getPersistence().fetchByPrimaryKeys(primaryKeys); 765 } 766 767 /** 768 * Returns all the shopping orders. 769 * 770 * @return the shopping orders 771 */ 772 public static List<ShoppingOrder> findAll() { 773 return getPersistence().findAll(); 774 } 775 776 /** 777 * Returns a range of all the shopping orders. 778 * 779 * <p> 780 * 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 ShoppingOrderModelImpl}. 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. 781 * </p> 782 * 783 * @param start the lower bound of the range of shopping orders 784 * @param end the upper bound of the range of shopping orders (not inclusive) 785 * @return the range of shopping orders 786 */ 787 public static List<ShoppingOrder> findAll(int start, int end) { 788 return getPersistence().findAll(start, end); 789 } 790 791 /** 792 * Returns an ordered range of all the shopping orders. 793 * 794 * <p> 795 * 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 ShoppingOrderModelImpl}. 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. 796 * </p> 797 * 798 * @param start the lower bound of the range of shopping orders 799 * @param end the upper bound of the range of shopping orders (not inclusive) 800 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 801 * @return the ordered range of shopping orders 802 */ 803 public static List<ShoppingOrder> findAll(int start, int end, 804 OrderByComparator<ShoppingOrder> orderByComparator) { 805 return getPersistence().findAll(start, end, orderByComparator); 806 } 807 808 /** 809 * Removes all the shopping orders from the database. 810 */ 811 public static void removeAll() { 812 getPersistence().removeAll(); 813 } 814 815 /** 816 * Returns the number of shopping orders. 817 * 818 * @return the number of shopping orders 819 */ 820 public static int countAll() { 821 return getPersistence().countAll(); 822 } 823 824 public static ShoppingOrderPersistence getPersistence() { 825 if (_persistence == null) { 826 _persistence = (ShoppingOrderPersistence)PortalBeanLocatorUtil.locate(ShoppingOrderPersistence.class.getName()); 827 828 ReferenceRegistry.registerReference(ShoppingOrderUtil.class, 829 "_persistence"); 830 } 831 832 return _persistence; 833 } 834 835 /** 836 * @deprecated As of 6.2.0 837 */ 838 @Deprecated 839 public void setPersistence(ShoppingOrderPersistence persistence) { 840 } 841 842 private static ShoppingOrderPersistence _persistence; 843 }