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