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