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