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.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.shopping.model.ShoppingOrder; 022 023 /** 024 * The persistence interface for the shopping order service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.shopping.service.persistence.impl.ShoppingOrderPersistenceImpl 032 * @see ShoppingOrderUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface ShoppingOrderPersistence extends BasePersistence<ShoppingOrder> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link ShoppingOrderUtil} to access the shopping order persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the shopping orders where groupId = ?. 045 * 046 * @param groupId the group ID 047 * @return the matching shopping orders 048 */ 049 public java.util.List<ShoppingOrder> findByGroupId(long groupId); 050 051 /** 052 * Returns a range of all the shopping orders where groupId = ?. 053 * 054 * <p> 055 * 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. 056 * </p> 057 * 058 * @param groupId the group ID 059 * @param start the lower bound of the range of shopping orders 060 * @param end the upper bound of the range of shopping orders (not inclusive) 061 * @return the range of matching shopping orders 062 */ 063 public java.util.List<ShoppingOrder> findByGroupId(long groupId, int start, 064 int end); 065 066 /** 067 * Returns an ordered range of all the shopping orders where groupId = ?. 068 * 069 * <p> 070 * 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. 071 * </p> 072 * 073 * @param groupId the group ID 074 * @param start the lower bound of the range of shopping orders 075 * @param end the upper bound of the range of shopping orders (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching shopping orders 078 */ 079 public java.util.List<ShoppingOrder> findByGroupId(long groupId, int start, 080 int end, 081 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 082 083 /** 084 * Returns the first shopping order in the ordered set where groupId = ?. 085 * 086 * @param groupId the group ID 087 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 088 * @return the first matching shopping order 089 * @throws NoSuchOrderException if a matching shopping order could not be found 090 */ 091 public ShoppingOrder findByGroupId_First(long groupId, 092 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator) 093 throws com.liferay.portlet.shopping.NoSuchOrderException; 094 095 /** 096 * Returns the first shopping order in the ordered set where groupId = ?. 097 * 098 * @param groupId the group ID 099 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 100 * @return the first matching shopping order, or <code>null</code> if a matching shopping order could not be found 101 */ 102 public ShoppingOrder fetchByGroupId_First(long groupId, 103 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 104 105 /** 106 * Returns the last shopping order in the ordered set where groupId = ?. 107 * 108 * @param groupId the group ID 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the last matching shopping order 111 * @throws NoSuchOrderException if a matching shopping order could not be found 112 */ 113 public ShoppingOrder findByGroupId_Last(long groupId, 114 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator) 115 throws com.liferay.portlet.shopping.NoSuchOrderException; 116 117 /** 118 * Returns the last shopping order in the ordered set where groupId = ?. 119 * 120 * @param groupId the group ID 121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 122 * @return the last matching shopping order, or <code>null</code> if a matching shopping order could not be found 123 */ 124 public ShoppingOrder fetchByGroupId_Last(long groupId, 125 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 126 127 /** 128 * Returns the shopping orders before and after the current shopping order in the ordered set where groupId = ?. 129 * 130 * @param orderId the primary key of the current shopping order 131 * @param groupId the group ID 132 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 133 * @return the previous, current, and next shopping order 134 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 135 */ 136 public ShoppingOrder[] findByGroupId_PrevAndNext(long orderId, 137 long groupId, 138 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator) 139 throws com.liferay.portlet.shopping.NoSuchOrderException; 140 141 /** 142 * Returns all the shopping orders that the user has permission to view where groupId = ?. 143 * 144 * @param groupId the group ID 145 * @return the matching shopping orders that the user has permission to view 146 */ 147 public java.util.List<ShoppingOrder> filterFindByGroupId(long groupId); 148 149 /** 150 * Returns a range of all the shopping orders that the user has permission to view where groupId = ?. 151 * 152 * <p> 153 * 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. 154 * </p> 155 * 156 * @param groupId the group ID 157 * @param start the lower bound of the range of shopping orders 158 * @param end the upper bound of the range of shopping orders (not inclusive) 159 * @return the range of matching shopping orders that the user has permission to view 160 */ 161 public java.util.List<ShoppingOrder> filterFindByGroupId(long groupId, 162 int start, int end); 163 164 /** 165 * Returns an ordered range of all the shopping orders that the user has permissions to view where groupId = ?. 166 * 167 * <p> 168 * 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. 169 * </p> 170 * 171 * @param groupId the group ID 172 * @param start the lower bound of the range of shopping orders 173 * @param end the upper bound of the range of shopping orders (not inclusive) 174 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 175 * @return the ordered range of matching shopping orders that the user has permission to view 176 */ 177 public java.util.List<ShoppingOrder> filterFindByGroupId(long groupId, 178 int start, int end, 179 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 180 181 /** 182 * 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 = ?. 183 * 184 * @param orderId the primary key of the current shopping order 185 * @param groupId the group ID 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the previous, current, and next shopping order 188 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 189 */ 190 public ShoppingOrder[] filterFindByGroupId_PrevAndNext(long orderId, 191 long groupId, 192 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator) 193 throws com.liferay.portlet.shopping.NoSuchOrderException; 194 195 /** 196 * Removes all the shopping orders where groupId = ? from the database. 197 * 198 * @param groupId the group ID 199 */ 200 public void removeByGroupId(long groupId); 201 202 /** 203 * Returns the number of shopping orders where groupId = ?. 204 * 205 * @param groupId the group ID 206 * @return the number of matching shopping orders 207 */ 208 public int countByGroupId(long groupId); 209 210 /** 211 * Returns the number of shopping orders that the user has permission to view where groupId = ?. 212 * 213 * @param groupId the group ID 214 * @return the number of matching shopping orders that the user has permission to view 215 */ 216 public int filterCountByGroupId(long groupId); 217 218 /** 219 * Returns the shopping order where number = ? or throws a {@link NoSuchOrderException} if it could not be found. 220 * 221 * @param number the number 222 * @return the matching shopping order 223 * @throws NoSuchOrderException if a matching shopping order could not be found 224 */ 225 public ShoppingOrder findByNumber(java.lang.String number) 226 throws com.liferay.portlet.shopping.NoSuchOrderException; 227 228 /** 229 * Returns the shopping order where number = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 230 * 231 * @param number the number 232 * @return the matching shopping order, or <code>null</code> if a matching shopping order could not be found 233 */ 234 public ShoppingOrder fetchByNumber(java.lang.String number); 235 236 /** 237 * Returns the shopping order where number = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 238 * 239 * @param number the number 240 * @param retrieveFromCache whether to use the finder cache 241 * @return the matching shopping order, or <code>null</code> if a matching shopping order could not be found 242 */ 243 public ShoppingOrder fetchByNumber(java.lang.String number, 244 boolean retrieveFromCache); 245 246 /** 247 * Removes the shopping order where number = ? from the database. 248 * 249 * @param number the number 250 * @return the shopping order that was removed 251 */ 252 public ShoppingOrder removeByNumber(java.lang.String number) 253 throws com.liferay.portlet.shopping.NoSuchOrderException; 254 255 /** 256 * Returns the number of shopping orders where number = ?. 257 * 258 * @param number the number 259 * @return the number of matching shopping orders 260 */ 261 public int countByNumber(java.lang.String number); 262 263 /** 264 * Returns the shopping order where ppTxnId = ? or throws a {@link NoSuchOrderException} if it could not be found. 265 * 266 * @param ppTxnId the pp txn ID 267 * @return the matching shopping order 268 * @throws NoSuchOrderException if a matching shopping order could not be found 269 */ 270 public ShoppingOrder findByPPTxnId(java.lang.String ppTxnId) 271 throws com.liferay.portlet.shopping.NoSuchOrderException; 272 273 /** 274 * Returns the shopping order where ppTxnId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 275 * 276 * @param ppTxnId the pp txn ID 277 * @return the matching shopping order, or <code>null</code> if a matching shopping order could not be found 278 */ 279 public ShoppingOrder fetchByPPTxnId(java.lang.String ppTxnId); 280 281 /** 282 * Returns the shopping order where ppTxnId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 283 * 284 * @param ppTxnId the pp txn ID 285 * @param retrieveFromCache whether to use the finder cache 286 * @return the matching shopping order, or <code>null</code> if a matching shopping order could not be found 287 */ 288 public ShoppingOrder fetchByPPTxnId(java.lang.String ppTxnId, 289 boolean retrieveFromCache); 290 291 /** 292 * Removes the shopping order where ppTxnId = ? from the database. 293 * 294 * @param ppTxnId the pp txn ID 295 * @return the shopping order that was removed 296 */ 297 public ShoppingOrder removeByPPTxnId(java.lang.String ppTxnId) 298 throws com.liferay.portlet.shopping.NoSuchOrderException; 299 300 /** 301 * Returns the number of shopping orders where ppTxnId = ?. 302 * 303 * @param ppTxnId the pp txn ID 304 * @return the number of matching shopping orders 305 */ 306 public int countByPPTxnId(java.lang.String ppTxnId); 307 308 /** 309 * Returns all the shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ?. 310 * 311 * @param groupId the group ID 312 * @param userId the user ID 313 * @param ppPaymentStatus the pp payment status 314 * @return the matching shopping orders 315 */ 316 public java.util.List<ShoppingOrder> findByG_U_PPPS(long groupId, 317 long userId, java.lang.String ppPaymentStatus); 318 319 /** 320 * Returns a range of all the shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ?. 321 * 322 * <p> 323 * 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. 324 * </p> 325 * 326 * @param groupId the group ID 327 * @param userId the user ID 328 * @param ppPaymentStatus the pp payment status 329 * @param start the lower bound of the range of shopping orders 330 * @param end the upper bound of the range of shopping orders (not inclusive) 331 * @return the range of matching shopping orders 332 */ 333 public java.util.List<ShoppingOrder> findByG_U_PPPS(long groupId, 334 long userId, java.lang.String ppPaymentStatus, int start, int end); 335 336 /** 337 * Returns an ordered range of all the shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ?. 338 * 339 * <p> 340 * 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. 341 * </p> 342 * 343 * @param groupId the group ID 344 * @param userId the user ID 345 * @param ppPaymentStatus the pp payment status 346 * @param start the lower bound of the range of shopping orders 347 * @param end the upper bound of the range of shopping orders (not inclusive) 348 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 349 * @return the ordered range of matching shopping orders 350 */ 351 public java.util.List<ShoppingOrder> findByG_U_PPPS(long groupId, 352 long userId, java.lang.String ppPaymentStatus, int start, int end, 353 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 354 355 /** 356 * Returns the first shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 357 * 358 * @param groupId the group ID 359 * @param userId the user ID 360 * @param ppPaymentStatus the pp payment status 361 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 362 * @return the first matching shopping order 363 * @throws NoSuchOrderException if a matching shopping order could not be found 364 */ 365 public ShoppingOrder findByG_U_PPPS_First(long groupId, long userId, 366 java.lang.String ppPaymentStatus, 367 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator) 368 throws com.liferay.portlet.shopping.NoSuchOrderException; 369 370 /** 371 * Returns the first shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 372 * 373 * @param groupId the group ID 374 * @param userId the user ID 375 * @param ppPaymentStatus the pp payment status 376 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 377 * @return the first matching shopping order, or <code>null</code> if a matching shopping order could not be found 378 */ 379 public ShoppingOrder fetchByG_U_PPPS_First(long groupId, long userId, 380 java.lang.String ppPaymentStatus, 381 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 382 383 /** 384 * Returns the last shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 385 * 386 * @param groupId the group ID 387 * @param userId the user ID 388 * @param ppPaymentStatus the pp payment status 389 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 390 * @return the last matching shopping order 391 * @throws NoSuchOrderException if a matching shopping order could not be found 392 */ 393 public ShoppingOrder findByG_U_PPPS_Last(long groupId, long userId, 394 java.lang.String ppPaymentStatus, 395 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator) 396 throws com.liferay.portlet.shopping.NoSuchOrderException; 397 398 /** 399 * Returns the last shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 400 * 401 * @param groupId the group ID 402 * @param userId the user ID 403 * @param ppPaymentStatus the pp payment status 404 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 405 * @return the last matching shopping order, or <code>null</code> if a matching shopping order could not be found 406 */ 407 public ShoppingOrder fetchByG_U_PPPS_Last(long groupId, long userId, 408 java.lang.String ppPaymentStatus, 409 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 410 411 /** 412 * Returns the shopping orders before and after the current shopping order in the ordered set where groupId = ? and userId = ? and ppPaymentStatus = ?. 413 * 414 * @param orderId the primary key of the current shopping order 415 * @param groupId the group ID 416 * @param userId the user ID 417 * @param ppPaymentStatus the pp payment status 418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 419 * @return the previous, current, and next shopping order 420 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 421 */ 422 public ShoppingOrder[] findByG_U_PPPS_PrevAndNext(long orderId, 423 long groupId, long userId, java.lang.String ppPaymentStatus, 424 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator) 425 throws com.liferay.portlet.shopping.NoSuchOrderException; 426 427 /** 428 * Returns all the shopping orders that the user has permission to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 429 * 430 * @param groupId the group ID 431 * @param userId the user ID 432 * @param ppPaymentStatus the pp payment status 433 * @return the matching shopping orders that the user has permission to view 434 */ 435 public java.util.List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, 436 long userId, java.lang.String ppPaymentStatus); 437 438 /** 439 * Returns a range of all the shopping orders that the user has permission to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 440 * 441 * <p> 442 * 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. 443 * </p> 444 * 445 * @param groupId the group ID 446 * @param userId the user ID 447 * @param ppPaymentStatus the pp payment status 448 * @param start the lower bound of the range of shopping orders 449 * @param end the upper bound of the range of shopping orders (not inclusive) 450 * @return the range of matching shopping orders that the user has permission to view 451 */ 452 public java.util.List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, 453 long userId, java.lang.String ppPaymentStatus, int start, int end); 454 455 /** 456 * Returns an ordered range of all the shopping orders that the user has permissions to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 457 * 458 * <p> 459 * 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. 460 * </p> 461 * 462 * @param groupId the group ID 463 * @param userId the user ID 464 * @param ppPaymentStatus the pp payment status 465 * @param start the lower bound of the range of shopping orders 466 * @param end the upper bound of the range of shopping orders (not inclusive) 467 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 468 * @return the ordered range of matching shopping orders that the user has permission to view 469 */ 470 public java.util.List<ShoppingOrder> filterFindByG_U_PPPS(long groupId, 471 long userId, java.lang.String ppPaymentStatus, int start, int end, 472 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 473 474 /** 475 * 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 = ?. 476 * 477 * @param orderId the primary key of the current shopping order 478 * @param groupId the group ID 479 * @param userId the user ID 480 * @param ppPaymentStatus the pp payment status 481 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 482 * @return the previous, current, and next shopping order 483 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 484 */ 485 public ShoppingOrder[] filterFindByG_U_PPPS_PrevAndNext(long orderId, 486 long groupId, long userId, java.lang.String ppPaymentStatus, 487 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator) 488 throws com.liferay.portlet.shopping.NoSuchOrderException; 489 490 /** 491 * Removes all the shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ? from the database. 492 * 493 * @param groupId the group ID 494 * @param userId the user ID 495 * @param ppPaymentStatus the pp payment status 496 */ 497 public void removeByG_U_PPPS(long groupId, long userId, 498 java.lang.String ppPaymentStatus); 499 500 /** 501 * Returns the number of shopping orders where groupId = ? and userId = ? and ppPaymentStatus = ?. 502 * 503 * @param groupId the group ID 504 * @param userId the user ID 505 * @param ppPaymentStatus the pp payment status 506 * @return the number of matching shopping orders 507 */ 508 public int countByG_U_PPPS(long groupId, long userId, 509 java.lang.String ppPaymentStatus); 510 511 /** 512 * Returns the number of shopping orders that the user has permission to view where groupId = ? and userId = ? and ppPaymentStatus = ?. 513 * 514 * @param groupId the group ID 515 * @param userId the user ID 516 * @param ppPaymentStatus the pp payment status 517 * @return the number of matching shopping orders that the user has permission to view 518 */ 519 public int filterCountByG_U_PPPS(long groupId, long userId, 520 java.lang.String ppPaymentStatus); 521 522 /** 523 * Caches the shopping order in the entity cache if it is enabled. 524 * 525 * @param shoppingOrder the shopping order 526 */ 527 public void cacheResult(ShoppingOrder shoppingOrder); 528 529 /** 530 * Caches the shopping orders in the entity cache if it is enabled. 531 * 532 * @param shoppingOrders the shopping orders 533 */ 534 public void cacheResult(java.util.List<ShoppingOrder> shoppingOrders); 535 536 /** 537 * Creates a new shopping order with the primary key. Does not add the shopping order to the database. 538 * 539 * @param orderId the primary key for the new shopping order 540 * @return the new shopping order 541 */ 542 public ShoppingOrder create(long orderId); 543 544 /** 545 * Removes the shopping order with the primary key from the database. Also notifies the appropriate model listeners. 546 * 547 * @param orderId the primary key of the shopping order 548 * @return the shopping order that was removed 549 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 550 */ 551 public ShoppingOrder remove(long orderId) 552 throws com.liferay.portlet.shopping.NoSuchOrderException; 553 554 public ShoppingOrder updateImpl(ShoppingOrder shoppingOrder); 555 556 /** 557 * Returns the shopping order with the primary key or throws a {@link NoSuchOrderException} if it could not be found. 558 * 559 * @param orderId the primary key of the shopping order 560 * @return the shopping order 561 * @throws NoSuchOrderException if a shopping order with the primary key could not be found 562 */ 563 public ShoppingOrder findByPrimaryKey(long orderId) 564 throws com.liferay.portlet.shopping.NoSuchOrderException; 565 566 /** 567 * Returns the shopping order with the primary key or returns <code>null</code> if it could not be found. 568 * 569 * @param orderId the primary key of the shopping order 570 * @return the shopping order, or <code>null</code> if a shopping order with the primary key could not be found 571 */ 572 public ShoppingOrder fetchByPrimaryKey(long orderId); 573 574 @Override 575 public java.util.Map<java.io.Serializable, ShoppingOrder> fetchByPrimaryKeys( 576 java.util.Set<java.io.Serializable> primaryKeys); 577 578 /** 579 * Returns all the shopping orders. 580 * 581 * @return the shopping orders 582 */ 583 public java.util.List<ShoppingOrder> findAll(); 584 585 /** 586 * Returns a range of all the shopping orders. 587 * 588 * <p> 589 * 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. 590 * </p> 591 * 592 * @param start the lower bound of the range of shopping orders 593 * @param end the upper bound of the range of shopping orders (not inclusive) 594 * @return the range of shopping orders 595 */ 596 public java.util.List<ShoppingOrder> findAll(int start, int end); 597 598 /** 599 * Returns an ordered range of all the shopping orders. 600 * 601 * <p> 602 * 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. 603 * </p> 604 * 605 * @param start the lower bound of the range of shopping orders 606 * @param end the upper bound of the range of shopping orders (not inclusive) 607 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 608 * @return the ordered range of shopping orders 609 */ 610 public java.util.List<ShoppingOrder> findAll(int start, int end, 611 com.liferay.portal.kernel.util.OrderByComparator<ShoppingOrder> orderByComparator); 612 613 /** 614 * Removes all the shopping orders from the database. 615 */ 616 public void removeAll(); 617 618 /** 619 * Returns the number of shopping orders. 620 * 621 * @return the number of shopping orders 622 */ 623 public int countAll(); 624 }