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