001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.bookmarks.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.bookmarks.model.BookmarksFolder; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the bookmarks folder service. This utility wraps {@link BookmarksFolderPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see BookmarksFolderPersistence 037 * @see BookmarksFolderPersistenceImpl 038 * @generated 039 */ 040 public class BookmarksFolderUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(BookmarksFolder bookmarksFolder) { 058 getPersistence().clearCache(bookmarksFolder); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<BookmarksFolder> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<BookmarksFolder> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<BookmarksFolder> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static BookmarksFolder update(BookmarksFolder bookmarksFolder) 101 throws SystemException { 102 return getPersistence().update(bookmarksFolder); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static BookmarksFolder update(BookmarksFolder bookmarksFolder, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(bookmarksFolder, serviceContext); 111 } 112 113 /** 114 * Returns all the bookmarks folders where resourceBlockId = ?. 115 * 116 * @param resourceBlockId the resource block ID 117 * @return the matching bookmarks folders 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 121 long resourceBlockId) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByResourceBlockId(resourceBlockId); 124 } 125 126 /** 127 * Returns a range of all the bookmarks folders where resourceBlockId = ?. 128 * 129 * <p> 130 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 131 * </p> 132 * 133 * @param resourceBlockId the resource block ID 134 * @param start the lower bound of the range of bookmarks folders 135 * @param end the upper bound of the range of bookmarks folders (not inclusive) 136 * @return the range of matching bookmarks folders 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 140 long resourceBlockId, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence() 143 .findByResourceBlockId(resourceBlockId, start, end); 144 } 145 146 /** 147 * Returns an ordered range of all the bookmarks folders where resourceBlockId = ?. 148 * 149 * <p> 150 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 151 * </p> 152 * 153 * @param resourceBlockId the resource block ID 154 * @param start the lower bound of the range of bookmarks folders 155 * @param end the upper bound of the range of bookmarks folders (not inclusive) 156 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 157 * @return the ordered range of matching bookmarks folders 158 * @throws SystemException if a system exception occurred 159 */ 160 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByResourceBlockId( 161 long resourceBlockId, int start, int end, 162 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence() 165 .findByResourceBlockId(resourceBlockId, start, end, 166 orderByComparator); 167 } 168 169 /** 170 * Returns the first bookmarks folder in the ordered set where resourceBlockId = ?. 171 * 172 * @param resourceBlockId the resource block ID 173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 174 * @return the first matching bookmarks folder 175 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 176 * @throws SystemException if a system exception occurred 177 */ 178 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_First( 179 long resourceBlockId, 180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.bookmarks.NoSuchFolderException { 183 return getPersistence() 184 .findByResourceBlockId_First(resourceBlockId, 185 orderByComparator); 186 } 187 188 /** 189 * Returns the first bookmarks folder in the ordered set where resourceBlockId = ?. 190 * 191 * @param resourceBlockId the resource block ID 192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 193 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 194 * @throws SystemException if a system exception occurred 195 */ 196 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByResourceBlockId_First( 197 long resourceBlockId, 198 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 199 throws com.liferay.portal.kernel.exception.SystemException { 200 return getPersistence() 201 .fetchByResourceBlockId_First(resourceBlockId, 202 orderByComparator); 203 } 204 205 /** 206 * Returns the last bookmarks folder in the ordered set where resourceBlockId = ?. 207 * 208 * @param resourceBlockId the resource block ID 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching bookmarks folder 211 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 212 * @throws SystemException if a system exception occurred 213 */ 214 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByResourceBlockId_Last( 215 long resourceBlockId, 216 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 217 throws com.liferay.portal.kernel.exception.SystemException, 218 com.liferay.portlet.bookmarks.NoSuchFolderException { 219 return getPersistence() 220 .findByResourceBlockId_Last(resourceBlockId, 221 orderByComparator); 222 } 223 224 /** 225 * Returns the last bookmarks folder in the ordered set where resourceBlockId = ?. 226 * 227 * @param resourceBlockId the resource block ID 228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 229 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 230 * @throws SystemException if a system exception occurred 231 */ 232 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByResourceBlockId_Last( 233 long resourceBlockId, 234 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 235 throws com.liferay.portal.kernel.exception.SystemException { 236 return getPersistence() 237 .fetchByResourceBlockId_Last(resourceBlockId, 238 orderByComparator); 239 } 240 241 /** 242 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where resourceBlockId = ?. 243 * 244 * @param folderId the primary key of the current bookmarks folder 245 * @param resourceBlockId the resource block ID 246 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 247 * @return the previous, current, and next bookmarks folder 248 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 249 * @throws SystemException if a system exception occurred 250 */ 251 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByResourceBlockId_PrevAndNext( 252 long folderId, long resourceBlockId, 253 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 254 throws com.liferay.portal.kernel.exception.SystemException, 255 com.liferay.portlet.bookmarks.NoSuchFolderException { 256 return getPersistence() 257 .findByResourceBlockId_PrevAndNext(folderId, 258 resourceBlockId, orderByComparator); 259 } 260 261 /** 262 * Removes all the bookmarks folders where resourceBlockId = ? from the database. 263 * 264 * @param resourceBlockId the resource block ID 265 * @throws SystemException if a system exception occurred 266 */ 267 public static void removeByResourceBlockId(long resourceBlockId) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 getPersistence().removeByResourceBlockId(resourceBlockId); 270 } 271 272 /** 273 * Returns the number of bookmarks folders where resourceBlockId = ?. 274 * 275 * @param resourceBlockId the resource block ID 276 * @return the number of matching bookmarks folders 277 * @throws SystemException if a system exception occurred 278 */ 279 public static int countByResourceBlockId(long resourceBlockId) 280 throws com.liferay.portal.kernel.exception.SystemException { 281 return getPersistence().countByResourceBlockId(resourceBlockId); 282 } 283 284 /** 285 * Returns all the bookmarks folders where uuid = ?. 286 * 287 * @param uuid the uuid 288 * @return the matching bookmarks folders 289 * @throws SystemException if a system exception occurred 290 */ 291 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 292 java.lang.String uuid) 293 throws com.liferay.portal.kernel.exception.SystemException { 294 return getPersistence().findByUuid(uuid); 295 } 296 297 /** 298 * Returns a range of all the bookmarks folders where uuid = ?. 299 * 300 * <p> 301 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 302 * </p> 303 * 304 * @param uuid the uuid 305 * @param start the lower bound of the range of bookmarks folders 306 * @param end the upper bound of the range of bookmarks folders (not inclusive) 307 * @return the range of matching bookmarks folders 308 * @throws SystemException if a system exception occurred 309 */ 310 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 311 java.lang.String uuid, int start, int end) 312 throws com.liferay.portal.kernel.exception.SystemException { 313 return getPersistence().findByUuid(uuid, start, end); 314 } 315 316 /** 317 * Returns an ordered range of all the bookmarks folders where uuid = ?. 318 * 319 * <p> 320 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 321 * </p> 322 * 323 * @param uuid the uuid 324 * @param start the lower bound of the range of bookmarks folders 325 * @param end the upper bound of the range of bookmarks folders (not inclusive) 326 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 327 * @return the ordered range of matching bookmarks folders 328 * @throws SystemException if a system exception occurred 329 */ 330 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid( 331 java.lang.String uuid, int start, int end, 332 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 333 throws com.liferay.portal.kernel.exception.SystemException { 334 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 335 } 336 337 /** 338 * Returns the first bookmarks folder in the ordered set where uuid = ?. 339 * 340 * @param uuid the uuid 341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 342 * @return the first matching bookmarks folder 343 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 344 * @throws SystemException if a system exception occurred 345 */ 346 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_First( 347 java.lang.String uuid, 348 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 349 throws com.liferay.portal.kernel.exception.SystemException, 350 com.liferay.portlet.bookmarks.NoSuchFolderException { 351 return getPersistence().findByUuid_First(uuid, orderByComparator); 352 } 353 354 /** 355 * Returns the first bookmarks folder in the ordered set where uuid = ?. 356 * 357 * @param uuid the uuid 358 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 359 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 360 * @throws SystemException if a system exception occurred 361 */ 362 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_First( 363 java.lang.String uuid, 364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 365 throws com.liferay.portal.kernel.exception.SystemException { 366 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 367 } 368 369 /** 370 * Returns the last bookmarks folder in the ordered set where uuid = ?. 371 * 372 * @param uuid the uuid 373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 374 * @return the last matching bookmarks folder 375 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 376 * @throws SystemException if a system exception occurred 377 */ 378 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_Last( 379 java.lang.String uuid, 380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 381 throws com.liferay.portal.kernel.exception.SystemException, 382 com.liferay.portlet.bookmarks.NoSuchFolderException { 383 return getPersistence().findByUuid_Last(uuid, orderByComparator); 384 } 385 386 /** 387 * Returns the last bookmarks folder in the ordered set where uuid = ?. 388 * 389 * @param uuid the uuid 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 392 * @throws SystemException if a system exception occurred 393 */ 394 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_Last( 395 java.lang.String uuid, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 399 } 400 401 /** 402 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = ?. 403 * 404 * @param folderId the primary key of the current bookmarks folder 405 * @param uuid the uuid 406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 407 * @return the previous, current, and next bookmarks folder 408 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 409 * @throws SystemException if a system exception occurred 410 */ 411 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_PrevAndNext( 412 long folderId, java.lang.String uuid, 413 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 414 throws com.liferay.portal.kernel.exception.SystemException, 415 com.liferay.portlet.bookmarks.NoSuchFolderException { 416 return getPersistence() 417 .findByUuid_PrevAndNext(folderId, uuid, orderByComparator); 418 } 419 420 /** 421 * Removes all the bookmarks folders where uuid = ? from the database. 422 * 423 * @param uuid the uuid 424 * @throws SystemException if a system exception occurred 425 */ 426 public static void removeByUuid(java.lang.String uuid) 427 throws com.liferay.portal.kernel.exception.SystemException { 428 getPersistence().removeByUuid(uuid); 429 } 430 431 /** 432 * Returns the number of bookmarks folders where uuid = ?. 433 * 434 * @param uuid the uuid 435 * @return the number of matching bookmarks folders 436 * @throws SystemException if a system exception occurred 437 */ 438 public static int countByUuid(java.lang.String uuid) 439 throws com.liferay.portal.kernel.exception.SystemException { 440 return getPersistence().countByUuid(uuid); 441 } 442 443 /** 444 * Returns the bookmarks folder where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 445 * 446 * @param uuid the uuid 447 * @param groupId the group ID 448 * @return the matching bookmarks folder 449 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 450 * @throws SystemException if a system exception occurred 451 */ 452 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUUID_G( 453 java.lang.String uuid, long groupId) 454 throws com.liferay.portal.kernel.exception.SystemException, 455 com.liferay.portlet.bookmarks.NoSuchFolderException { 456 return getPersistence().findByUUID_G(uuid, groupId); 457 } 458 459 /** 460 * Returns the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 461 * 462 * @param uuid the uuid 463 * @param groupId the group ID 464 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 465 * @throws SystemException if a system exception occurred 466 */ 467 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 468 java.lang.String uuid, long groupId) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence().fetchByUUID_G(uuid, groupId); 471 } 472 473 /** 474 * Returns the bookmarks folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 475 * 476 * @param uuid the uuid 477 * @param groupId the group ID 478 * @param retrieveFromCache whether to use the finder cache 479 * @return the matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 480 * @throws SystemException if a system exception occurred 481 */ 482 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUUID_G( 483 java.lang.String uuid, long groupId, boolean retrieveFromCache) 484 throws com.liferay.portal.kernel.exception.SystemException { 485 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 486 } 487 488 /** 489 * Removes the bookmarks folder where uuid = ? and groupId = ? from the database. 490 * 491 * @param uuid the uuid 492 * @param groupId the group ID 493 * @return the bookmarks folder that was removed 494 * @throws SystemException if a system exception occurred 495 */ 496 public static com.liferay.portlet.bookmarks.model.BookmarksFolder removeByUUID_G( 497 java.lang.String uuid, long groupId) 498 throws com.liferay.portal.kernel.exception.SystemException, 499 com.liferay.portlet.bookmarks.NoSuchFolderException { 500 return getPersistence().removeByUUID_G(uuid, groupId); 501 } 502 503 /** 504 * Returns the number of bookmarks folders where uuid = ? and groupId = ?. 505 * 506 * @param uuid the uuid 507 * @param groupId the group ID 508 * @return the number of matching bookmarks folders 509 * @throws SystemException if a system exception occurred 510 */ 511 public static int countByUUID_G(java.lang.String uuid, long groupId) 512 throws com.liferay.portal.kernel.exception.SystemException { 513 return getPersistence().countByUUID_G(uuid, groupId); 514 } 515 516 /** 517 * Returns all the bookmarks folders where uuid = ? and companyId = ?. 518 * 519 * @param uuid the uuid 520 * @param companyId the company ID 521 * @return the matching bookmarks folders 522 * @throws SystemException if a system exception occurred 523 */ 524 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C( 525 java.lang.String uuid, long companyId) 526 throws com.liferay.portal.kernel.exception.SystemException { 527 return getPersistence().findByUuid_C(uuid, companyId); 528 } 529 530 /** 531 * Returns a range of all the bookmarks folders where uuid = ? and companyId = ?. 532 * 533 * <p> 534 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 535 * </p> 536 * 537 * @param uuid the uuid 538 * @param companyId the company ID 539 * @param start the lower bound of the range of bookmarks folders 540 * @param end the upper bound of the range of bookmarks folders (not inclusive) 541 * @return the range of matching bookmarks folders 542 * @throws SystemException if a system exception occurred 543 */ 544 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C( 545 java.lang.String uuid, long companyId, int start, int end) 546 throws com.liferay.portal.kernel.exception.SystemException { 547 return getPersistence().findByUuid_C(uuid, companyId, start, end); 548 } 549 550 /** 551 * Returns an ordered range of all the bookmarks folders where uuid = ? and companyId = ?. 552 * 553 * <p> 554 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 555 * </p> 556 * 557 * @param uuid the uuid 558 * @param companyId the company ID 559 * @param start the lower bound of the range of bookmarks folders 560 * @param end the upper bound of the range of bookmarks folders (not inclusive) 561 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 562 * @return the ordered range of matching bookmarks folders 563 * @throws SystemException if a system exception occurred 564 */ 565 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByUuid_C( 566 java.lang.String uuid, long companyId, int start, int end, 567 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 568 throws com.liferay.portal.kernel.exception.SystemException { 569 return getPersistence() 570 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 571 } 572 573 /** 574 * Returns the first bookmarks folder in the ordered set where uuid = ? and companyId = ?. 575 * 576 * @param uuid the uuid 577 * @param companyId the company ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching bookmarks folder 580 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_C_First( 584 java.lang.String uuid, long companyId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.bookmarks.NoSuchFolderException { 588 return getPersistence() 589 .findByUuid_C_First(uuid, companyId, orderByComparator); 590 } 591 592 /** 593 * Returns the first bookmarks folder in the ordered set where uuid = ? and companyId = ?. 594 * 595 * @param uuid the uuid 596 * @param companyId the company ID 597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 598 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 599 * @throws SystemException if a system exception occurred 600 */ 601 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_C_First( 602 java.lang.String uuid, long companyId, 603 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 604 throws com.liferay.portal.kernel.exception.SystemException { 605 return getPersistence() 606 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 607 } 608 609 /** 610 * Returns the last bookmarks folder in the ordered set where uuid = ? and companyId = ?. 611 * 612 * @param uuid the uuid 613 * @param companyId the company ID 614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 615 * @return the last matching bookmarks folder 616 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 617 * @throws SystemException if a system exception occurred 618 */ 619 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByUuid_C_Last( 620 java.lang.String uuid, long companyId, 621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 622 throws com.liferay.portal.kernel.exception.SystemException, 623 com.liferay.portlet.bookmarks.NoSuchFolderException { 624 return getPersistence() 625 .findByUuid_C_Last(uuid, companyId, orderByComparator); 626 } 627 628 /** 629 * Returns the last bookmarks folder in the ordered set where uuid = ? and companyId = ?. 630 * 631 * @param uuid the uuid 632 * @param companyId the company ID 633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 634 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 635 * @throws SystemException if a system exception occurred 636 */ 637 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByUuid_C_Last( 638 java.lang.String uuid, long companyId, 639 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 640 throws com.liferay.portal.kernel.exception.SystemException { 641 return getPersistence() 642 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 643 } 644 645 /** 646 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where uuid = ? and companyId = ?. 647 * 648 * @param folderId the primary key of the current bookmarks folder 649 * @param uuid the uuid 650 * @param companyId the company ID 651 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 652 * @return the previous, current, and next bookmarks folder 653 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 654 * @throws SystemException if a system exception occurred 655 */ 656 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByUuid_C_PrevAndNext( 657 long folderId, java.lang.String uuid, long companyId, 658 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 659 throws com.liferay.portal.kernel.exception.SystemException, 660 com.liferay.portlet.bookmarks.NoSuchFolderException { 661 return getPersistence() 662 .findByUuid_C_PrevAndNext(folderId, uuid, companyId, 663 orderByComparator); 664 } 665 666 /** 667 * Removes all the bookmarks folders where uuid = ? and companyId = ? from the database. 668 * 669 * @param uuid the uuid 670 * @param companyId the company ID 671 * @throws SystemException if a system exception occurred 672 */ 673 public static void removeByUuid_C(java.lang.String uuid, long companyId) 674 throws com.liferay.portal.kernel.exception.SystemException { 675 getPersistence().removeByUuid_C(uuid, companyId); 676 } 677 678 /** 679 * Returns the number of bookmarks folders where uuid = ? and companyId = ?. 680 * 681 * @param uuid the uuid 682 * @param companyId the company ID 683 * @return the number of matching bookmarks folders 684 * @throws SystemException if a system exception occurred 685 */ 686 public static int countByUuid_C(java.lang.String uuid, long companyId) 687 throws com.liferay.portal.kernel.exception.SystemException { 688 return getPersistence().countByUuid_C(uuid, companyId); 689 } 690 691 /** 692 * Returns all the bookmarks folders where groupId = ?. 693 * 694 * @param groupId the group ID 695 * @return the matching bookmarks folders 696 * @throws SystemException if a system exception occurred 697 */ 698 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 699 long groupId) 700 throws com.liferay.portal.kernel.exception.SystemException { 701 return getPersistence().findByGroupId(groupId); 702 } 703 704 /** 705 * Returns a range of all the bookmarks folders where groupId = ?. 706 * 707 * <p> 708 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.bookmarks.model.impl.BookmarksFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 709 * </p> 710 * 711 * @param groupId the group ID 712 * @param start the lower bound of the range of bookmarks folders 713 * @param end the upper bound of the range of bookmarks folders (not inclusive) 714 * @return the range of matching bookmarks folders 715 * @throws SystemException if a system exception occurred 716 */ 717 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 718 long groupId, int start, int end) 719 throws com.liferay.portal.kernel.exception.SystemException { 720 return getPersistence().findByGroupId(groupId, start, end); 721 } 722 723 /** 724 * Returns an ordered range of all the bookmarks folders where groupId = ?. 725 * 726 * <p> 727 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 728 * </p> 729 * 730 * @param groupId the group ID 731 * @param start the lower bound of the range of bookmarks folders 732 * @param end the upper bound of the range of bookmarks folders (not inclusive) 733 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 734 * @return the ordered range of matching bookmarks folders 735 * @throws SystemException if a system exception occurred 736 */ 737 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByGroupId( 738 long groupId, int start, int end, 739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 740 throws com.liferay.portal.kernel.exception.SystemException { 741 return getPersistence() 742 .findByGroupId(groupId, start, end, orderByComparator); 743 } 744 745 /** 746 * Returns the first bookmarks folder in the ordered set where groupId = ?. 747 * 748 * @param groupId the group ID 749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 750 * @return the first matching bookmarks folder 751 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 752 * @throws SystemException if a system exception occurred 753 */ 754 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_First( 755 long groupId, 756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 757 throws com.liferay.portal.kernel.exception.SystemException, 758 com.liferay.portlet.bookmarks.NoSuchFolderException { 759 return getPersistence().findByGroupId_First(groupId, orderByComparator); 760 } 761 762 /** 763 * Returns the first bookmarks folder in the ordered set where groupId = ?. 764 * 765 * @param groupId the group ID 766 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 767 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 768 * @throws SystemException if a system exception occurred 769 */ 770 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByGroupId_First( 771 long groupId, 772 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 775 } 776 777 /** 778 * Returns the last bookmarks folder in the ordered set where groupId = ?. 779 * 780 * @param groupId the group ID 781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 782 * @return the last matching bookmarks folder 783 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 784 * @throws SystemException if a system exception occurred 785 */ 786 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByGroupId_Last( 787 long groupId, 788 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 789 throws com.liferay.portal.kernel.exception.SystemException, 790 com.liferay.portlet.bookmarks.NoSuchFolderException { 791 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 792 } 793 794 /** 795 * Returns the last bookmarks folder in the ordered set where groupId = ?. 796 * 797 * @param groupId the group ID 798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 799 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 800 * @throws SystemException if a system exception occurred 801 */ 802 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByGroupId_Last( 803 long groupId, 804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 805 throws com.liferay.portal.kernel.exception.SystemException { 806 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 807 } 808 809 /** 810 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ?. 811 * 812 * @param folderId the primary key of the current bookmarks folder 813 * @param groupId the group ID 814 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 815 * @return the previous, current, and next bookmarks folder 816 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 817 * @throws SystemException if a system exception occurred 818 */ 819 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByGroupId_PrevAndNext( 820 long folderId, long groupId, 821 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 822 throws com.liferay.portal.kernel.exception.SystemException, 823 com.liferay.portlet.bookmarks.NoSuchFolderException { 824 return getPersistence() 825 .findByGroupId_PrevAndNext(folderId, groupId, 826 orderByComparator); 827 } 828 829 /** 830 * Returns all the bookmarks folders that the user has permission to view where groupId = ?. 831 * 832 * @param groupId the group ID 833 * @return the matching bookmarks folders that the user has permission to view 834 * @throws SystemException if a system exception occurred 835 */ 836 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 837 long groupId) 838 throws com.liferay.portal.kernel.exception.SystemException { 839 return getPersistence().filterFindByGroupId(groupId); 840 } 841 842 /** 843 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ?. 844 * 845 * <p> 846 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 847 * </p> 848 * 849 * @param groupId the group ID 850 * @param start the lower bound of the range of bookmarks folders 851 * @param end the upper bound of the range of bookmarks folders (not inclusive) 852 * @return the range of matching bookmarks folders that the user has permission to view 853 * @throws SystemException if a system exception occurred 854 */ 855 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 856 long groupId, int start, int end) 857 throws com.liferay.portal.kernel.exception.SystemException { 858 return getPersistence().filterFindByGroupId(groupId, start, end); 859 } 860 861 /** 862 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ?. 863 * 864 * <p> 865 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 866 * </p> 867 * 868 * @param groupId the group ID 869 * @param start the lower bound of the range of bookmarks folders 870 * @param end the upper bound of the range of bookmarks folders (not inclusive) 871 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 872 * @return the ordered range of matching bookmarks folders that the user has permission to view 873 * @throws SystemException if a system exception occurred 874 */ 875 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByGroupId( 876 long groupId, int start, int end, 877 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 878 throws com.liferay.portal.kernel.exception.SystemException { 879 return getPersistence() 880 .filterFindByGroupId(groupId, start, end, orderByComparator); 881 } 882 883 /** 884 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set of bookmarks folders that the user has permission to view where groupId = ?. 885 * 886 * @param folderId the primary key of the current bookmarks folder 887 * @param groupId the group ID 888 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 889 * @return the previous, current, and next bookmarks folder 890 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 891 * @throws SystemException if a system exception occurred 892 */ 893 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByGroupId_PrevAndNext( 894 long folderId, long groupId, 895 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 896 throws com.liferay.portal.kernel.exception.SystemException, 897 com.liferay.portlet.bookmarks.NoSuchFolderException { 898 return getPersistence() 899 .filterFindByGroupId_PrevAndNext(folderId, groupId, 900 orderByComparator); 901 } 902 903 /** 904 * Removes all the bookmarks folders where groupId = ? from the database. 905 * 906 * @param groupId the group ID 907 * @throws SystemException if a system exception occurred 908 */ 909 public static void removeByGroupId(long groupId) 910 throws com.liferay.portal.kernel.exception.SystemException { 911 getPersistence().removeByGroupId(groupId); 912 } 913 914 /** 915 * Returns the number of bookmarks folders where groupId = ?. 916 * 917 * @param groupId the group ID 918 * @return the number of matching bookmarks folders 919 * @throws SystemException if a system exception occurred 920 */ 921 public static int countByGroupId(long groupId) 922 throws com.liferay.portal.kernel.exception.SystemException { 923 return getPersistence().countByGroupId(groupId); 924 } 925 926 /** 927 * Returns the number of bookmarks folders that the user has permission to view where groupId = ?. 928 * 929 * @param groupId the group ID 930 * @return the number of matching bookmarks folders that the user has permission to view 931 * @throws SystemException if a system exception occurred 932 */ 933 public static int filterCountByGroupId(long groupId) 934 throws com.liferay.portal.kernel.exception.SystemException { 935 return getPersistence().filterCountByGroupId(groupId); 936 } 937 938 /** 939 * Returns all the bookmarks folders where companyId = ?. 940 * 941 * @param companyId the company ID 942 * @return the matching bookmarks folders 943 * @throws SystemException if a system exception occurred 944 */ 945 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 946 long companyId) 947 throws com.liferay.portal.kernel.exception.SystemException { 948 return getPersistence().findByCompanyId(companyId); 949 } 950 951 /** 952 * Returns a range of all the bookmarks folders where companyId = ?. 953 * 954 * <p> 955 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 956 * </p> 957 * 958 * @param companyId the company ID 959 * @param start the lower bound of the range of bookmarks folders 960 * @param end the upper bound of the range of bookmarks folders (not inclusive) 961 * @return the range of matching bookmarks folders 962 * @throws SystemException if a system exception occurred 963 */ 964 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 965 long companyId, int start, int end) 966 throws com.liferay.portal.kernel.exception.SystemException { 967 return getPersistence().findByCompanyId(companyId, start, end); 968 } 969 970 /** 971 * Returns an ordered range of all the bookmarks folders where companyId = ?. 972 * 973 * <p> 974 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 975 * </p> 976 * 977 * @param companyId the company ID 978 * @param start the lower bound of the range of bookmarks folders 979 * @param end the upper bound of the range of bookmarks folders (not inclusive) 980 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 981 * @return the ordered range of matching bookmarks folders 982 * @throws SystemException if a system exception occurred 983 */ 984 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByCompanyId( 985 long companyId, int start, int end, 986 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 987 throws com.liferay.portal.kernel.exception.SystemException { 988 return getPersistence() 989 .findByCompanyId(companyId, start, end, orderByComparator); 990 } 991 992 /** 993 * Returns the first bookmarks folder in the ordered set where companyId = ?. 994 * 995 * @param companyId the company ID 996 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 997 * @return the first matching bookmarks folder 998 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 999 * @throws SystemException if a system exception occurred 1000 */ 1001 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_First( 1002 long companyId, 1003 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1004 throws com.liferay.portal.kernel.exception.SystemException, 1005 com.liferay.portlet.bookmarks.NoSuchFolderException { 1006 return getPersistence() 1007 .findByCompanyId_First(companyId, orderByComparator); 1008 } 1009 1010 /** 1011 * Returns the first bookmarks folder in the ordered set where companyId = ?. 1012 * 1013 * @param companyId the company ID 1014 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1015 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1016 * @throws SystemException if a system exception occurred 1017 */ 1018 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByCompanyId_First( 1019 long companyId, 1020 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1021 throws com.liferay.portal.kernel.exception.SystemException { 1022 return getPersistence() 1023 .fetchByCompanyId_First(companyId, orderByComparator); 1024 } 1025 1026 /** 1027 * Returns the last bookmarks folder in the ordered set where companyId = ?. 1028 * 1029 * @param companyId the company ID 1030 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1031 * @return the last matching bookmarks folder 1032 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1033 * @throws SystemException if a system exception occurred 1034 */ 1035 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByCompanyId_Last( 1036 long companyId, 1037 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1038 throws com.liferay.portal.kernel.exception.SystemException, 1039 com.liferay.portlet.bookmarks.NoSuchFolderException { 1040 return getPersistence() 1041 .findByCompanyId_Last(companyId, orderByComparator); 1042 } 1043 1044 /** 1045 * Returns the last bookmarks folder in the ordered set where companyId = ?. 1046 * 1047 * @param companyId the company ID 1048 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1049 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1050 * @throws SystemException if a system exception occurred 1051 */ 1052 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByCompanyId_Last( 1053 long companyId, 1054 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1055 throws com.liferay.portal.kernel.exception.SystemException { 1056 return getPersistence() 1057 .fetchByCompanyId_Last(companyId, orderByComparator); 1058 } 1059 1060 /** 1061 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where companyId = ?. 1062 * 1063 * @param folderId the primary key of the current bookmarks folder 1064 * @param companyId the company ID 1065 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1066 * @return the previous, current, and next bookmarks folder 1067 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1068 * @throws SystemException if a system exception occurred 1069 */ 1070 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByCompanyId_PrevAndNext( 1071 long folderId, long companyId, 1072 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1073 throws com.liferay.portal.kernel.exception.SystemException, 1074 com.liferay.portlet.bookmarks.NoSuchFolderException { 1075 return getPersistence() 1076 .findByCompanyId_PrevAndNext(folderId, companyId, 1077 orderByComparator); 1078 } 1079 1080 /** 1081 * Removes all the bookmarks folders where companyId = ? from the database. 1082 * 1083 * @param companyId the company ID 1084 * @throws SystemException if a system exception occurred 1085 */ 1086 public static void removeByCompanyId(long companyId) 1087 throws com.liferay.portal.kernel.exception.SystemException { 1088 getPersistence().removeByCompanyId(companyId); 1089 } 1090 1091 /** 1092 * Returns the number of bookmarks folders where companyId = ?. 1093 * 1094 * @param companyId the company ID 1095 * @return the number of matching bookmarks folders 1096 * @throws SystemException if a system exception occurred 1097 */ 1098 public static int countByCompanyId(long companyId) 1099 throws com.liferay.portal.kernel.exception.SystemException { 1100 return getPersistence().countByCompanyId(companyId); 1101 } 1102 1103 /** 1104 * Returns all the bookmarks folders where groupId = ? and parentFolderId = ?. 1105 * 1106 * @param groupId the group ID 1107 * @param parentFolderId the parent folder ID 1108 * @return the matching bookmarks folders 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 1112 long groupId, long parentFolderId) 1113 throws com.liferay.portal.kernel.exception.SystemException { 1114 return getPersistence().findByG_P(groupId, parentFolderId); 1115 } 1116 1117 /** 1118 * Returns a range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 1119 * 1120 * <p> 1121 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1122 * </p> 1123 * 1124 * @param groupId the group ID 1125 * @param parentFolderId the parent folder ID 1126 * @param start the lower bound of the range of bookmarks folders 1127 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1128 * @return the range of matching bookmarks folders 1129 * @throws SystemException if a system exception occurred 1130 */ 1131 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 1132 long groupId, long parentFolderId, int start, int end) 1133 throws com.liferay.portal.kernel.exception.SystemException { 1134 return getPersistence().findByG_P(groupId, parentFolderId, start, end); 1135 } 1136 1137 /** 1138 * Returns an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ?. 1139 * 1140 * <p> 1141 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1142 * </p> 1143 * 1144 * @param groupId the group ID 1145 * @param parentFolderId the parent folder ID 1146 * @param start the lower bound of the range of bookmarks folders 1147 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1149 * @return the ordered range of matching bookmarks folders 1150 * @throws SystemException if a system exception occurred 1151 */ 1152 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P( 1153 long groupId, long parentFolderId, int start, int end, 1154 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1155 throws com.liferay.portal.kernel.exception.SystemException { 1156 return getPersistence() 1157 .findByG_P(groupId, parentFolderId, start, end, 1158 orderByComparator); 1159 } 1160 1161 /** 1162 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1163 * 1164 * @param groupId the group ID 1165 * @param parentFolderId the parent folder ID 1166 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1167 * @return the first matching bookmarks folder 1168 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1169 * @throws SystemException if a system exception occurred 1170 */ 1171 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_First( 1172 long groupId, long parentFolderId, 1173 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1174 throws com.liferay.portal.kernel.exception.SystemException, 1175 com.liferay.portlet.bookmarks.NoSuchFolderException { 1176 return getPersistence() 1177 .findByG_P_First(groupId, parentFolderId, orderByComparator); 1178 } 1179 1180 /** 1181 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1182 * 1183 * @param groupId the group ID 1184 * @param parentFolderId the parent folder ID 1185 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1186 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1187 * @throws SystemException if a system exception occurred 1188 */ 1189 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_First( 1190 long groupId, long parentFolderId, 1191 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1192 throws com.liferay.portal.kernel.exception.SystemException { 1193 return getPersistence() 1194 .fetchByG_P_First(groupId, parentFolderId, orderByComparator); 1195 } 1196 1197 /** 1198 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1199 * 1200 * @param groupId the group ID 1201 * @param parentFolderId the parent folder ID 1202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1203 * @return the last matching bookmarks folder 1204 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1205 * @throws SystemException if a system exception occurred 1206 */ 1207 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_Last( 1208 long groupId, long parentFolderId, 1209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1210 throws com.liferay.portal.kernel.exception.SystemException, 1211 com.liferay.portlet.bookmarks.NoSuchFolderException { 1212 return getPersistence() 1213 .findByG_P_Last(groupId, parentFolderId, orderByComparator); 1214 } 1215 1216 /** 1217 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1218 * 1219 * @param groupId the group ID 1220 * @param parentFolderId the parent folder ID 1221 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1222 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1223 * @throws SystemException if a system exception occurred 1224 */ 1225 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_Last( 1226 long groupId, long parentFolderId, 1227 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1228 throws com.liferay.portal.kernel.exception.SystemException { 1229 return getPersistence() 1230 .fetchByG_P_Last(groupId, parentFolderId, orderByComparator); 1231 } 1232 1233 /** 1234 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ?. 1235 * 1236 * @param folderId the primary key of the current bookmarks folder 1237 * @param groupId the group ID 1238 * @param parentFolderId the parent folder ID 1239 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1240 * @return the previous, current, and next bookmarks folder 1241 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1242 * @throws SystemException if a system exception occurred 1243 */ 1244 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_PrevAndNext( 1245 long folderId, long groupId, long parentFolderId, 1246 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1247 throws com.liferay.portal.kernel.exception.SystemException, 1248 com.liferay.portlet.bookmarks.NoSuchFolderException { 1249 return getPersistence() 1250 .findByG_P_PrevAndNext(folderId, groupId, parentFolderId, 1251 orderByComparator); 1252 } 1253 1254 /** 1255 * Returns all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1256 * 1257 * @param groupId the group ID 1258 * @param parentFolderId the parent folder ID 1259 * @return the matching bookmarks folders that the user has permission to view 1260 * @throws SystemException if a system exception occurred 1261 */ 1262 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1263 long groupId, long parentFolderId) 1264 throws com.liferay.portal.kernel.exception.SystemException { 1265 return getPersistence().filterFindByG_P(groupId, parentFolderId); 1266 } 1267 1268 /** 1269 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1270 * 1271 * <p> 1272 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1273 * </p> 1274 * 1275 * @param groupId the group ID 1276 * @param parentFolderId the parent folder ID 1277 * @param start the lower bound of the range of bookmarks folders 1278 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1279 * @return the range of matching bookmarks folders that the user has permission to view 1280 * @throws SystemException if a system exception occurred 1281 */ 1282 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1283 long groupId, long parentFolderId, int start, int end) 1284 throws com.liferay.portal.kernel.exception.SystemException { 1285 return getPersistence() 1286 .filterFindByG_P(groupId, parentFolderId, start, end); 1287 } 1288 1289 /** 1290 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ? and parentFolderId = ?. 1291 * 1292 * <p> 1293 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1294 * </p> 1295 * 1296 * @param groupId the group ID 1297 * @param parentFolderId the parent folder ID 1298 * @param start the lower bound of the range of bookmarks folders 1299 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1300 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1301 * @return the ordered range of matching bookmarks folders that the user has permission to view 1302 * @throws SystemException if a system exception occurred 1303 */ 1304 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P( 1305 long groupId, long parentFolderId, int start, int end, 1306 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1307 throws com.liferay.portal.kernel.exception.SystemException { 1308 return getPersistence() 1309 .filterFindByG_P(groupId, parentFolderId, start, end, 1310 orderByComparator); 1311 } 1312 1313 /** 1314 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1315 * 1316 * @param folderId the primary key of the current bookmarks folder 1317 * @param groupId the group ID 1318 * @param parentFolderId the parent folder ID 1319 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1320 * @return the previous, current, and next bookmarks folder 1321 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1322 * @throws SystemException if a system exception occurred 1323 */ 1324 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_PrevAndNext( 1325 long folderId, long groupId, long parentFolderId, 1326 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1327 throws com.liferay.portal.kernel.exception.SystemException, 1328 com.liferay.portlet.bookmarks.NoSuchFolderException { 1329 return getPersistence() 1330 .filterFindByG_P_PrevAndNext(folderId, groupId, 1331 parentFolderId, orderByComparator); 1332 } 1333 1334 /** 1335 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? from the database. 1336 * 1337 * @param groupId the group ID 1338 * @param parentFolderId the parent folder ID 1339 * @throws SystemException if a system exception occurred 1340 */ 1341 public static void removeByG_P(long groupId, long parentFolderId) 1342 throws com.liferay.portal.kernel.exception.SystemException { 1343 getPersistence().removeByG_P(groupId, parentFolderId); 1344 } 1345 1346 /** 1347 * Returns the number of bookmarks folders where groupId = ? and parentFolderId = ?. 1348 * 1349 * @param groupId the group ID 1350 * @param parentFolderId the parent folder ID 1351 * @return the number of matching bookmarks folders 1352 * @throws SystemException if a system exception occurred 1353 */ 1354 public static int countByG_P(long groupId, long parentFolderId) 1355 throws com.liferay.portal.kernel.exception.SystemException { 1356 return getPersistence().countByG_P(groupId, parentFolderId); 1357 } 1358 1359 /** 1360 * Returns the number of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1361 * 1362 * @param groupId the group ID 1363 * @param parentFolderId the parent folder ID 1364 * @return the number of matching bookmarks folders that the user has permission to view 1365 * @throws SystemException if a system exception occurred 1366 */ 1367 public static int filterCountByG_P(long groupId, long parentFolderId) 1368 throws com.liferay.portal.kernel.exception.SystemException { 1369 return getPersistence().filterCountByG_P(groupId, parentFolderId); 1370 } 1371 1372 /** 1373 * Returns all the bookmarks folders where groupId = ? and parentFolderId = ? and status = ?. 1374 * 1375 * @param groupId the group ID 1376 * @param parentFolderId the parent folder ID 1377 * @param status the status 1378 * @return the matching bookmarks folders 1379 * @throws SystemException if a system exception occurred 1380 */ 1381 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S( 1382 long groupId, long parentFolderId, int status) 1383 throws com.liferay.portal.kernel.exception.SystemException { 1384 return getPersistence().findByG_P_S(groupId, parentFolderId, status); 1385 } 1386 1387 /** 1388 * Returns a range of all the bookmarks folders where groupId = ? and parentFolderId = ? and status = ?. 1389 * 1390 * <p> 1391 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1392 * </p> 1393 * 1394 * @param groupId the group ID 1395 * @param parentFolderId the parent folder ID 1396 * @param status the status 1397 * @param start the lower bound of the range of bookmarks folders 1398 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1399 * @return the range of matching bookmarks folders 1400 * @throws SystemException if a system exception occurred 1401 */ 1402 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S( 1403 long groupId, long parentFolderId, int status, int start, int end) 1404 throws com.liferay.portal.kernel.exception.SystemException { 1405 return getPersistence() 1406 .findByG_P_S(groupId, parentFolderId, status, start, end); 1407 } 1408 1409 /** 1410 * Returns an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ? and status = ?. 1411 * 1412 * <p> 1413 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1414 * </p> 1415 * 1416 * @param groupId the group ID 1417 * @param parentFolderId the parent folder ID 1418 * @param status the status 1419 * @param start the lower bound of the range of bookmarks folders 1420 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1421 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1422 * @return the ordered range of matching bookmarks folders 1423 * @throws SystemException if a system exception occurred 1424 */ 1425 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_S( 1426 long groupId, long parentFolderId, int status, int start, int end, 1427 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1428 throws com.liferay.portal.kernel.exception.SystemException { 1429 return getPersistence() 1430 .findByG_P_S(groupId, parentFolderId, status, start, end, 1431 orderByComparator); 1432 } 1433 1434 /** 1435 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1436 * 1437 * @param groupId the group ID 1438 * @param parentFolderId the parent folder ID 1439 * @param status the status 1440 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1441 * @return the first matching bookmarks folder 1442 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1443 * @throws SystemException if a system exception occurred 1444 */ 1445 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_S_First( 1446 long groupId, long parentFolderId, int status, 1447 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1448 throws com.liferay.portal.kernel.exception.SystemException, 1449 com.liferay.portlet.bookmarks.NoSuchFolderException { 1450 return getPersistence() 1451 .findByG_P_S_First(groupId, parentFolderId, status, 1452 orderByComparator); 1453 } 1454 1455 /** 1456 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1457 * 1458 * @param groupId the group ID 1459 * @param parentFolderId the parent folder ID 1460 * @param status the status 1461 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1462 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1463 * @throws SystemException if a system exception occurred 1464 */ 1465 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_S_First( 1466 long groupId, long parentFolderId, int status, 1467 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1468 throws com.liferay.portal.kernel.exception.SystemException { 1469 return getPersistence() 1470 .fetchByG_P_S_First(groupId, parentFolderId, status, 1471 orderByComparator); 1472 } 1473 1474 /** 1475 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1476 * 1477 * @param groupId the group ID 1478 * @param parentFolderId the parent folder ID 1479 * @param status the status 1480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1481 * @return the last matching bookmarks folder 1482 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1483 * @throws SystemException if a system exception occurred 1484 */ 1485 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_S_Last( 1486 long groupId, long parentFolderId, int status, 1487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1488 throws com.liferay.portal.kernel.exception.SystemException, 1489 com.liferay.portlet.bookmarks.NoSuchFolderException { 1490 return getPersistence() 1491 .findByG_P_S_Last(groupId, parentFolderId, status, 1492 orderByComparator); 1493 } 1494 1495 /** 1496 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1497 * 1498 * @param groupId the group ID 1499 * @param parentFolderId the parent folder ID 1500 * @param status the status 1501 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1502 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1503 * @throws SystemException if a system exception occurred 1504 */ 1505 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_S_Last( 1506 long groupId, long parentFolderId, int status, 1507 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1508 throws com.liferay.portal.kernel.exception.SystemException { 1509 return getPersistence() 1510 .fetchByG_P_S_Last(groupId, parentFolderId, status, 1511 orderByComparator); 1512 } 1513 1514 /** 1515 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1516 * 1517 * @param folderId the primary key of the current bookmarks folder 1518 * @param groupId the group ID 1519 * @param parentFolderId the parent folder ID 1520 * @param status the status 1521 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1522 * @return the previous, current, and next bookmarks folder 1523 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1524 * @throws SystemException if a system exception occurred 1525 */ 1526 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_S_PrevAndNext( 1527 long folderId, long groupId, long parentFolderId, int status, 1528 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1529 throws com.liferay.portal.kernel.exception.SystemException, 1530 com.liferay.portlet.bookmarks.NoSuchFolderException { 1531 return getPersistence() 1532 .findByG_P_S_PrevAndNext(folderId, groupId, parentFolderId, 1533 status, orderByComparator); 1534 } 1535 1536 /** 1537 * Returns all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1538 * 1539 * @param groupId the group ID 1540 * @param parentFolderId the parent folder ID 1541 * @param status the status 1542 * @return the matching bookmarks folders that the user has permission to view 1543 * @throws SystemException if a system exception occurred 1544 */ 1545 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S( 1546 long groupId, long parentFolderId, int status) 1547 throws com.liferay.portal.kernel.exception.SystemException { 1548 return getPersistence() 1549 .filterFindByG_P_S(groupId, parentFolderId, status); 1550 } 1551 1552 /** 1553 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1554 * 1555 * <p> 1556 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1557 * </p> 1558 * 1559 * @param groupId the group ID 1560 * @param parentFolderId the parent folder ID 1561 * @param status the status 1562 * @param start the lower bound of the range of bookmarks folders 1563 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1564 * @return the range of matching bookmarks folders that the user has permission to view 1565 * @throws SystemException if a system exception occurred 1566 */ 1567 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S( 1568 long groupId, long parentFolderId, int status, int start, int end) 1569 throws com.liferay.portal.kernel.exception.SystemException { 1570 return getPersistence() 1571 .filterFindByG_P_S(groupId, parentFolderId, status, start, 1572 end); 1573 } 1574 1575 /** 1576 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status = ?. 1577 * 1578 * <p> 1579 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1580 * </p> 1581 * 1582 * @param groupId the group ID 1583 * @param parentFolderId the parent folder ID 1584 * @param status the status 1585 * @param start the lower bound of the range of bookmarks folders 1586 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1587 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1588 * @return the ordered range of matching bookmarks folders that the user has permission to view 1589 * @throws SystemException if a system exception occurred 1590 */ 1591 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_S( 1592 long groupId, long parentFolderId, int status, int start, int end, 1593 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1594 throws com.liferay.portal.kernel.exception.SystemException { 1595 return getPersistence() 1596 .filterFindByG_P_S(groupId, parentFolderId, status, start, 1597 end, orderByComparator); 1598 } 1599 1600 /** 1601 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1602 * 1603 * @param folderId the primary key of the current bookmarks folder 1604 * @param groupId the group ID 1605 * @param parentFolderId the parent folder ID 1606 * @param status the status 1607 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1608 * @return the previous, current, and next bookmarks folder 1609 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1610 * @throws SystemException if a system exception occurred 1611 */ 1612 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_S_PrevAndNext( 1613 long folderId, long groupId, long parentFolderId, int status, 1614 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1615 throws com.liferay.portal.kernel.exception.SystemException, 1616 com.liferay.portlet.bookmarks.NoSuchFolderException { 1617 return getPersistence() 1618 .filterFindByG_P_S_PrevAndNext(folderId, groupId, 1619 parentFolderId, status, orderByComparator); 1620 } 1621 1622 /** 1623 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? and status = ? from the database. 1624 * 1625 * @param groupId the group ID 1626 * @param parentFolderId the parent folder ID 1627 * @param status the status 1628 * @throws SystemException if a system exception occurred 1629 */ 1630 public static void removeByG_P_S(long groupId, long parentFolderId, 1631 int status) throws com.liferay.portal.kernel.exception.SystemException { 1632 getPersistence().removeByG_P_S(groupId, parentFolderId, status); 1633 } 1634 1635 /** 1636 * Returns the number of bookmarks folders where groupId = ? and parentFolderId = ? and status = ?. 1637 * 1638 * @param groupId the group ID 1639 * @param parentFolderId the parent folder ID 1640 * @param status the status 1641 * @return the number of matching bookmarks folders 1642 * @throws SystemException if a system exception occurred 1643 */ 1644 public static int countByG_P_S(long groupId, long parentFolderId, int status) 1645 throws com.liferay.portal.kernel.exception.SystemException { 1646 return getPersistence().countByG_P_S(groupId, parentFolderId, status); 1647 } 1648 1649 /** 1650 * Returns the number of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1651 * 1652 * @param groupId the group ID 1653 * @param parentFolderId the parent folder ID 1654 * @param status the status 1655 * @return the number of matching bookmarks folders that the user has permission to view 1656 * @throws SystemException if a system exception occurred 1657 */ 1658 public static int filterCountByG_P_S(long groupId, long parentFolderId, 1659 int status) throws com.liferay.portal.kernel.exception.SystemException { 1660 return getPersistence() 1661 .filterCountByG_P_S(groupId, parentFolderId, status); 1662 } 1663 1664 /** 1665 * Returns all the bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1666 * 1667 * @param groupId the group ID 1668 * @param parentFolderId the parent folder ID 1669 * @param status the status 1670 * @return the matching bookmarks folders 1671 * @throws SystemException if a system exception occurred 1672 */ 1673 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS( 1674 long groupId, long parentFolderId, int status) 1675 throws com.liferay.portal.kernel.exception.SystemException { 1676 return getPersistence().findByG_P_NotS(groupId, parentFolderId, status); 1677 } 1678 1679 /** 1680 * Returns a range of all the bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1681 * 1682 * <p> 1683 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1684 * </p> 1685 * 1686 * @param groupId the group ID 1687 * @param parentFolderId the parent folder ID 1688 * @param status the status 1689 * @param start the lower bound of the range of bookmarks folders 1690 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1691 * @return the range of matching bookmarks folders 1692 * @throws SystemException if a system exception occurred 1693 */ 1694 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS( 1695 long groupId, long parentFolderId, int status, int start, int end) 1696 throws com.liferay.portal.kernel.exception.SystemException { 1697 return getPersistence() 1698 .findByG_P_NotS(groupId, parentFolderId, status, start, end); 1699 } 1700 1701 /** 1702 * Returns an ordered range of all the bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1703 * 1704 * <p> 1705 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1706 * </p> 1707 * 1708 * @param groupId the group ID 1709 * @param parentFolderId the parent folder ID 1710 * @param status the status 1711 * @param start the lower bound of the range of bookmarks folders 1712 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1713 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1714 * @return the ordered range of matching bookmarks folders 1715 * @throws SystemException if a system exception occurred 1716 */ 1717 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findByG_P_NotS( 1718 long groupId, long parentFolderId, int status, int start, int end, 1719 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1720 throws com.liferay.portal.kernel.exception.SystemException { 1721 return getPersistence() 1722 .findByG_P_NotS(groupId, parentFolderId, status, start, end, 1723 orderByComparator); 1724 } 1725 1726 /** 1727 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1728 * 1729 * @param groupId the group ID 1730 * @param parentFolderId the parent folder ID 1731 * @param status the status 1732 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1733 * @return the first matching bookmarks folder 1734 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1735 * @throws SystemException if a system exception occurred 1736 */ 1737 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_NotS_First( 1738 long groupId, long parentFolderId, int status, 1739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1740 throws com.liferay.portal.kernel.exception.SystemException, 1741 com.liferay.portlet.bookmarks.NoSuchFolderException { 1742 return getPersistence() 1743 .findByG_P_NotS_First(groupId, parentFolderId, status, 1744 orderByComparator); 1745 } 1746 1747 /** 1748 * Returns the first bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1749 * 1750 * @param groupId the group ID 1751 * @param parentFolderId the parent folder ID 1752 * @param status the status 1753 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1754 * @return the first matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1755 * @throws SystemException if a system exception occurred 1756 */ 1757 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_NotS_First( 1758 long groupId, long parentFolderId, int status, 1759 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1760 throws com.liferay.portal.kernel.exception.SystemException { 1761 return getPersistence() 1762 .fetchByG_P_NotS_First(groupId, parentFolderId, status, 1763 orderByComparator); 1764 } 1765 1766 /** 1767 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1768 * 1769 * @param groupId the group ID 1770 * @param parentFolderId the parent folder ID 1771 * @param status the status 1772 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1773 * @return the last matching bookmarks folder 1774 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a matching bookmarks folder could not be found 1775 * @throws SystemException if a system exception occurred 1776 */ 1777 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByG_P_NotS_Last( 1778 long groupId, long parentFolderId, int status, 1779 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1780 throws com.liferay.portal.kernel.exception.SystemException, 1781 com.liferay.portlet.bookmarks.NoSuchFolderException { 1782 return getPersistence() 1783 .findByG_P_NotS_Last(groupId, parentFolderId, status, 1784 orderByComparator); 1785 } 1786 1787 /** 1788 * Returns the last bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1789 * 1790 * @param groupId the group ID 1791 * @param parentFolderId the parent folder ID 1792 * @param status the status 1793 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1794 * @return the last matching bookmarks folder, or <code>null</code> if a matching bookmarks folder could not be found 1795 * @throws SystemException if a system exception occurred 1796 */ 1797 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByG_P_NotS_Last( 1798 long groupId, long parentFolderId, int status, 1799 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1800 throws com.liferay.portal.kernel.exception.SystemException { 1801 return getPersistence() 1802 .fetchByG_P_NotS_Last(groupId, parentFolderId, status, 1803 orderByComparator); 1804 } 1805 1806 /** 1807 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1808 * 1809 * @param folderId the primary key of the current bookmarks folder 1810 * @param groupId the group ID 1811 * @param parentFolderId the parent folder ID 1812 * @param status the status 1813 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1814 * @return the previous, current, and next bookmarks folder 1815 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1816 * @throws SystemException if a system exception occurred 1817 */ 1818 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] findByG_P_NotS_PrevAndNext( 1819 long folderId, long groupId, long parentFolderId, int status, 1820 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1821 throws com.liferay.portal.kernel.exception.SystemException, 1822 com.liferay.portlet.bookmarks.NoSuchFolderException { 1823 return getPersistence() 1824 .findByG_P_NotS_PrevAndNext(folderId, groupId, 1825 parentFolderId, status, orderByComparator); 1826 } 1827 1828 /** 1829 * Returns all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1830 * 1831 * @param groupId the group ID 1832 * @param parentFolderId the parent folder ID 1833 * @param status the status 1834 * @return the matching bookmarks folders that the user has permission to view 1835 * @throws SystemException if a system exception occurred 1836 */ 1837 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS( 1838 long groupId, long parentFolderId, int status) 1839 throws com.liferay.portal.kernel.exception.SystemException { 1840 return getPersistence() 1841 .filterFindByG_P_NotS(groupId, parentFolderId, status); 1842 } 1843 1844 /** 1845 * Returns a range of all the bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1846 * 1847 * <p> 1848 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1849 * </p> 1850 * 1851 * @param groupId the group ID 1852 * @param parentFolderId the parent folder ID 1853 * @param status the status 1854 * @param start the lower bound of the range of bookmarks folders 1855 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1856 * @return the range of matching bookmarks folders that the user has permission to view 1857 * @throws SystemException if a system exception occurred 1858 */ 1859 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS( 1860 long groupId, long parentFolderId, int status, int start, int end) 1861 throws com.liferay.portal.kernel.exception.SystemException { 1862 return getPersistence() 1863 .filterFindByG_P_NotS(groupId, parentFolderId, status, 1864 start, end); 1865 } 1866 1867 /** 1868 * Returns an ordered range of all the bookmarks folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1869 * 1870 * <p> 1871 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 1872 * </p> 1873 * 1874 * @param groupId the group ID 1875 * @param parentFolderId the parent folder ID 1876 * @param status the status 1877 * @param start the lower bound of the range of bookmarks folders 1878 * @param end the upper bound of the range of bookmarks folders (not inclusive) 1879 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1880 * @return the ordered range of matching bookmarks folders that the user has permission to view 1881 * @throws SystemException if a system exception occurred 1882 */ 1883 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> filterFindByG_P_NotS( 1884 long groupId, long parentFolderId, int status, int start, int end, 1885 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1886 throws com.liferay.portal.kernel.exception.SystemException { 1887 return getPersistence() 1888 .filterFindByG_P_NotS(groupId, parentFolderId, status, 1889 start, end, orderByComparator); 1890 } 1891 1892 /** 1893 * Returns the bookmarks folders before and after the current bookmarks folder in the ordered set of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1894 * 1895 * @param folderId the primary key of the current bookmarks folder 1896 * @param groupId the group ID 1897 * @param parentFolderId the parent folder ID 1898 * @param status the status 1899 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1900 * @return the previous, current, and next bookmarks folder 1901 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1902 * @throws SystemException if a system exception occurred 1903 */ 1904 public static com.liferay.portlet.bookmarks.model.BookmarksFolder[] filterFindByG_P_NotS_PrevAndNext( 1905 long folderId, long groupId, long parentFolderId, int status, 1906 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1907 throws com.liferay.portal.kernel.exception.SystemException, 1908 com.liferay.portlet.bookmarks.NoSuchFolderException { 1909 return getPersistence() 1910 .filterFindByG_P_NotS_PrevAndNext(folderId, groupId, 1911 parentFolderId, status, orderByComparator); 1912 } 1913 1914 /** 1915 * Removes all the bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ? from the database. 1916 * 1917 * @param groupId the group ID 1918 * @param parentFolderId the parent folder ID 1919 * @param status the status 1920 * @throws SystemException if a system exception occurred 1921 */ 1922 public static void removeByG_P_NotS(long groupId, long parentFolderId, 1923 int status) throws com.liferay.portal.kernel.exception.SystemException { 1924 getPersistence().removeByG_P_NotS(groupId, parentFolderId, status); 1925 } 1926 1927 /** 1928 * Returns the number of bookmarks folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1929 * 1930 * @param groupId the group ID 1931 * @param parentFolderId the parent folder ID 1932 * @param status the status 1933 * @return the number of matching bookmarks folders 1934 * @throws SystemException if a system exception occurred 1935 */ 1936 public static int countByG_P_NotS(long groupId, long parentFolderId, 1937 int status) throws com.liferay.portal.kernel.exception.SystemException { 1938 return getPersistence().countByG_P_NotS(groupId, parentFolderId, status); 1939 } 1940 1941 /** 1942 * Returns the number of bookmarks folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1943 * 1944 * @param groupId the group ID 1945 * @param parentFolderId the parent folder ID 1946 * @param status the status 1947 * @return the number of matching bookmarks folders that the user has permission to view 1948 * @throws SystemException if a system exception occurred 1949 */ 1950 public static int filterCountByG_P_NotS(long groupId, long parentFolderId, 1951 int status) throws com.liferay.portal.kernel.exception.SystemException { 1952 return getPersistence() 1953 .filterCountByG_P_NotS(groupId, parentFolderId, status); 1954 } 1955 1956 /** 1957 * Caches the bookmarks folder in the entity cache if it is enabled. 1958 * 1959 * @param bookmarksFolder the bookmarks folder 1960 */ 1961 public static void cacheResult( 1962 com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) { 1963 getPersistence().cacheResult(bookmarksFolder); 1964 } 1965 1966 /** 1967 * Caches the bookmarks folders in the entity cache if it is enabled. 1968 * 1969 * @param bookmarksFolders the bookmarks folders 1970 */ 1971 public static void cacheResult( 1972 java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> bookmarksFolders) { 1973 getPersistence().cacheResult(bookmarksFolders); 1974 } 1975 1976 /** 1977 * Creates a new bookmarks folder with the primary key. Does not add the bookmarks folder to the database. 1978 * 1979 * @param folderId the primary key for the new bookmarks folder 1980 * @return the new bookmarks folder 1981 */ 1982 public static com.liferay.portlet.bookmarks.model.BookmarksFolder create( 1983 long folderId) { 1984 return getPersistence().create(folderId); 1985 } 1986 1987 /** 1988 * Removes the bookmarks folder with the primary key from the database. Also notifies the appropriate model listeners. 1989 * 1990 * @param folderId the primary key of the bookmarks folder 1991 * @return the bookmarks folder that was removed 1992 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 1993 * @throws SystemException if a system exception occurred 1994 */ 1995 public static com.liferay.portlet.bookmarks.model.BookmarksFolder remove( 1996 long folderId) 1997 throws com.liferay.portal.kernel.exception.SystemException, 1998 com.liferay.portlet.bookmarks.NoSuchFolderException { 1999 return getPersistence().remove(folderId); 2000 } 2001 2002 public static com.liferay.portlet.bookmarks.model.BookmarksFolder updateImpl( 2003 com.liferay.portlet.bookmarks.model.BookmarksFolder bookmarksFolder) 2004 throws com.liferay.portal.kernel.exception.SystemException { 2005 return getPersistence().updateImpl(bookmarksFolder); 2006 } 2007 2008 /** 2009 * Returns the bookmarks folder with the primary key or throws a {@link com.liferay.portlet.bookmarks.NoSuchFolderException} if it could not be found. 2010 * 2011 * @param folderId the primary key of the bookmarks folder 2012 * @return the bookmarks folder 2013 * @throws com.liferay.portlet.bookmarks.NoSuchFolderException if a bookmarks folder with the primary key could not be found 2014 * @throws SystemException if a system exception occurred 2015 */ 2016 public static com.liferay.portlet.bookmarks.model.BookmarksFolder findByPrimaryKey( 2017 long folderId) 2018 throws com.liferay.portal.kernel.exception.SystemException, 2019 com.liferay.portlet.bookmarks.NoSuchFolderException { 2020 return getPersistence().findByPrimaryKey(folderId); 2021 } 2022 2023 /** 2024 * Returns the bookmarks folder with the primary key or returns <code>null</code> if it could not be found. 2025 * 2026 * @param folderId the primary key of the bookmarks folder 2027 * @return the bookmarks folder, or <code>null</code> if a bookmarks folder with the primary key could not be found 2028 * @throws SystemException if a system exception occurred 2029 */ 2030 public static com.liferay.portlet.bookmarks.model.BookmarksFolder fetchByPrimaryKey( 2031 long folderId) 2032 throws com.liferay.portal.kernel.exception.SystemException { 2033 return getPersistence().fetchByPrimaryKey(folderId); 2034 } 2035 2036 /** 2037 * Returns all the bookmarks folders. 2038 * 2039 * @return the bookmarks folders 2040 * @throws SystemException if a system exception occurred 2041 */ 2042 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll() 2043 throws com.liferay.portal.kernel.exception.SystemException { 2044 return getPersistence().findAll(); 2045 } 2046 2047 /** 2048 * Returns a range of all the bookmarks folders. 2049 * 2050 * <p> 2051 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 2052 * </p> 2053 * 2054 * @param start the lower bound of the range of bookmarks folders 2055 * @param end the upper bound of the range of bookmarks folders (not inclusive) 2056 * @return the range of bookmarks folders 2057 * @throws SystemException if a system exception occurred 2058 */ 2059 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 2060 int start, int end) 2061 throws com.liferay.portal.kernel.exception.SystemException { 2062 return getPersistence().findAll(start, end); 2063 } 2064 2065 /** 2066 * Returns an ordered range of all the bookmarks folders. 2067 * 2068 * <p> 2069 * 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.bookmarks.model.impl.BookmarksFolderModelImpl}. 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. 2070 * </p> 2071 * 2072 * @param start the lower bound of the range of bookmarks folders 2073 * @param end the upper bound of the range of bookmarks folders (not inclusive) 2074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2075 * @return the ordered range of bookmarks folders 2076 * @throws SystemException if a system exception occurred 2077 */ 2078 public static java.util.List<com.liferay.portlet.bookmarks.model.BookmarksFolder> findAll( 2079 int start, int end, 2080 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2081 throws com.liferay.portal.kernel.exception.SystemException { 2082 return getPersistence().findAll(start, end, orderByComparator); 2083 } 2084 2085 /** 2086 * Removes all the bookmarks folders from the database. 2087 * 2088 * @throws SystemException if a system exception occurred 2089 */ 2090 public static void removeAll() 2091 throws com.liferay.portal.kernel.exception.SystemException { 2092 getPersistence().removeAll(); 2093 } 2094 2095 /** 2096 * Returns the number of bookmarks folders. 2097 * 2098 * @return the number of bookmarks folders 2099 * @throws SystemException if a system exception occurred 2100 */ 2101 public static int countAll() 2102 throws com.liferay.portal.kernel.exception.SystemException { 2103 return getPersistence().countAll(); 2104 } 2105 2106 public static BookmarksFolderPersistence getPersistence() { 2107 if (_persistence == null) { 2108 _persistence = (BookmarksFolderPersistence)PortalBeanLocatorUtil.locate(BookmarksFolderPersistence.class.getName()); 2109 2110 ReferenceRegistry.registerReference(BookmarksFolderUtil.class, 2111 "_persistence"); 2112 } 2113 2114 return _persistence; 2115 } 2116 2117 /** 2118 * @deprecated As of 6.2.0 2119 */ 2120 public void setPersistence(BookmarksFolderPersistence persistence) { 2121 } 2122 2123 private static BookmarksFolderPersistence _persistence; 2124 }