001 /** 002 * Copyright (c) 2000-2010 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.messageboards.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.service.ServiceContext; 022 023 import com.liferay.portlet.messageboards.model.MBCategory; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the message boards category service. This utility wraps {@link MBCategoryPersistenceImpl} 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. 029 * 030 * <p> 031 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 032 * </p> 033 * 034 * <p> 035 * Caching information and settings can be found in <code>portal.properties</code> 036 * </p> 037 * 038 * @author Brian Wing Shun Chan 039 * @see MBCategoryPersistence 040 * @see MBCategoryPersistenceImpl 041 * @generated 042 */ 043 public class MBCategoryUtil { 044 /** 045 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 046 */ 047 public static void clearCache() { 048 getPersistence().clearCache(); 049 } 050 051 /** 052 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 053 */ 054 public static void clearCache(MBCategory mbCategory) { 055 getPersistence().clearCache(mbCategory); 056 } 057 058 /** 059 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 060 */ 061 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 062 throws SystemException { 063 return getPersistence().countWithDynamicQuery(dynamicQuery); 064 } 065 066 /** 067 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 068 */ 069 public static List<MBCategory> findWithDynamicQuery( 070 DynamicQuery dynamicQuery) throws SystemException { 071 return getPersistence().findWithDynamicQuery(dynamicQuery); 072 } 073 074 /** 075 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 076 */ 077 public static List<MBCategory> findWithDynamicQuery( 078 DynamicQuery dynamicQuery, int start, int end) 079 throws SystemException { 080 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 081 } 082 083 /** 084 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 085 */ 086 public static List<MBCategory> findWithDynamicQuery( 087 DynamicQuery dynamicQuery, int start, int end, 088 OrderByComparator orderByComparator) throws SystemException { 089 return getPersistence() 090 .findWithDynamicQuery(dynamicQuery, start, end, 091 orderByComparator); 092 } 093 094 /** 095 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 096 */ 097 public static MBCategory remove(MBCategory mbCategory) 098 throws SystemException { 099 return getPersistence().remove(mbCategory); 100 } 101 102 /** 103 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 104 */ 105 public static MBCategory update(MBCategory mbCategory, boolean merge) 106 throws SystemException { 107 return getPersistence().update(mbCategory, merge); 108 } 109 110 /** 111 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 112 */ 113 public static MBCategory update(MBCategory mbCategory, boolean merge, 114 ServiceContext serviceContext) throws SystemException { 115 return getPersistence().update(mbCategory, merge, serviceContext); 116 } 117 118 /** 119 * Caches the message boards category in the entity cache if it is enabled. 120 * 121 * @param mbCategory the message boards category to cache 122 */ 123 public static void cacheResult( 124 com.liferay.portlet.messageboards.model.MBCategory mbCategory) { 125 getPersistence().cacheResult(mbCategory); 126 } 127 128 /** 129 * Caches the message boards categories in the entity cache if it is enabled. 130 * 131 * @param mbCategories the message boards categories to cache 132 */ 133 public static void cacheResult( 134 java.util.List<com.liferay.portlet.messageboards.model.MBCategory> mbCategories) { 135 getPersistence().cacheResult(mbCategories); 136 } 137 138 /** 139 * Creates a new message boards category with the primary key. Does not add the message boards category to the database. 140 * 141 * @param categoryId the primary key for the new message boards category 142 * @return the new message boards category 143 */ 144 public static com.liferay.portlet.messageboards.model.MBCategory create( 145 long categoryId) { 146 return getPersistence().create(categoryId); 147 } 148 149 /** 150 * Removes the message boards category with the primary key from the database. Also notifies the appropriate model listeners. 151 * 152 * @param categoryId the primary key of the message boards category to remove 153 * @return the message boards category that was removed 154 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 155 * @throws SystemException if a system exception occurred 156 */ 157 public static com.liferay.portlet.messageboards.model.MBCategory remove( 158 long categoryId) 159 throws com.liferay.portal.kernel.exception.SystemException, 160 com.liferay.portlet.messageboards.NoSuchCategoryException { 161 return getPersistence().remove(categoryId); 162 } 163 164 public static com.liferay.portlet.messageboards.model.MBCategory updateImpl( 165 com.liferay.portlet.messageboards.model.MBCategory mbCategory, 166 boolean merge) 167 throws com.liferay.portal.kernel.exception.SystemException { 168 return getPersistence().updateImpl(mbCategory, merge); 169 } 170 171 /** 172 * Finds the message boards category with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found. 173 * 174 * @param categoryId the primary key of the message boards category to find 175 * @return the message boards category 176 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 177 * @throws SystemException if a system exception occurred 178 */ 179 public static com.liferay.portlet.messageboards.model.MBCategory findByPrimaryKey( 180 long categoryId) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.messageboards.NoSuchCategoryException { 183 return getPersistence().findByPrimaryKey(categoryId); 184 } 185 186 /** 187 * Finds the message boards category with the primary key or returns <code>null</code> if it could not be found. 188 * 189 * @param categoryId the primary key of the message boards category to find 190 * @return the message boards category, or <code>null</code> if a message boards category with the primary key could not be found 191 * @throws SystemException if a system exception occurred 192 */ 193 public static com.liferay.portlet.messageboards.model.MBCategory fetchByPrimaryKey( 194 long categoryId) 195 throws com.liferay.portal.kernel.exception.SystemException { 196 return getPersistence().fetchByPrimaryKey(categoryId); 197 } 198 199 /** 200 * Finds all the message boards categories where uuid = ?. 201 * 202 * @param uuid the uuid to search with 203 * @return the matching message boards categories 204 * @throws SystemException if a system exception occurred 205 */ 206 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 207 java.lang.String uuid) 208 throws com.liferay.portal.kernel.exception.SystemException { 209 return getPersistence().findByUuid(uuid); 210 } 211 212 /** 213 * Finds a range of all the message boards categories where uuid = ?. 214 * 215 * <p> 216 * 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. 217 * </p> 218 * 219 * @param uuid the uuid to search with 220 * @param start the lower bound of the range of message boards categories to return 221 * @param end the upper bound of the range of message boards categories to return (not inclusive) 222 * @return the range of matching message boards categories 223 * @throws SystemException if a system exception occurred 224 */ 225 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 226 java.lang.String uuid, int start, int end) 227 throws com.liferay.portal.kernel.exception.SystemException { 228 return getPersistence().findByUuid(uuid, start, end); 229 } 230 231 /** 232 * Finds an ordered range of all the message boards categories where uuid = ?. 233 * 234 * <p> 235 * 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. 236 * </p> 237 * 238 * @param uuid the uuid to search with 239 * @param start the lower bound of the range of message boards categories to return 240 * @param end the upper bound of the range of message boards categories to return (not inclusive) 241 * @param orderByComparator the comparator to order the results by 242 * @return the ordered range of matching message boards categories 243 * @throws SystemException if a system exception occurred 244 */ 245 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 246 java.lang.String uuid, int start, int end, 247 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 248 throws com.liferay.portal.kernel.exception.SystemException { 249 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 250 } 251 252 /** 253 * Finds the first message boards category in the ordered set where uuid = ?. 254 * 255 * <p> 256 * 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. 257 * </p> 258 * 259 * @param uuid the uuid to search with 260 * @param orderByComparator the comparator to order the set by 261 * @return the first matching message boards category 262 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 263 * @throws SystemException if a system exception occurred 264 */ 265 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_First( 266 java.lang.String uuid, 267 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 268 throws com.liferay.portal.kernel.exception.SystemException, 269 com.liferay.portlet.messageboards.NoSuchCategoryException { 270 return getPersistence().findByUuid_First(uuid, orderByComparator); 271 } 272 273 /** 274 * Finds the last message boards category in the ordered set where uuid = ?. 275 * 276 * <p> 277 * 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. 278 * </p> 279 * 280 * @param uuid the uuid to search with 281 * @param orderByComparator the comparator to order the set by 282 * @return the last matching message boards category 283 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 284 * @throws SystemException if a system exception occurred 285 */ 286 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_Last( 287 java.lang.String uuid, 288 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 289 throws com.liferay.portal.kernel.exception.SystemException, 290 com.liferay.portlet.messageboards.NoSuchCategoryException { 291 return getPersistence().findByUuid_Last(uuid, orderByComparator); 292 } 293 294 /** 295 * Finds the message boards categories before and after the current message boards category in the ordered set where uuid = ?. 296 * 297 * <p> 298 * 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. 299 * </p> 300 * 301 * @param categoryId the primary key of the current message boards category 302 * @param uuid the uuid to search with 303 * @param orderByComparator the comparator to order the set by 304 * @return the previous, current, and next message boards category 305 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 306 * @throws SystemException if a system exception occurred 307 */ 308 public static com.liferay.portlet.messageboards.model.MBCategory[] findByUuid_PrevAndNext( 309 long categoryId, java.lang.String uuid, 310 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 311 throws com.liferay.portal.kernel.exception.SystemException, 312 com.liferay.portlet.messageboards.NoSuchCategoryException { 313 return getPersistence() 314 .findByUuid_PrevAndNext(categoryId, uuid, orderByComparator); 315 } 316 317 /** 318 * Finds the message boards category where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found. 319 * 320 * @param uuid the uuid to search with 321 * @param groupId the group id to search with 322 * @return the matching message boards category 323 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 324 * @throws SystemException if a system exception occurred 325 */ 326 public static com.liferay.portlet.messageboards.model.MBCategory findByUUID_G( 327 java.lang.String uuid, long groupId) 328 throws com.liferay.portal.kernel.exception.SystemException, 329 com.liferay.portlet.messageboards.NoSuchCategoryException { 330 return getPersistence().findByUUID_G(uuid, groupId); 331 } 332 333 /** 334 * Finds the message boards category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 335 * 336 * @param uuid the uuid to search with 337 * @param groupId the group id to search with 338 * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found 339 * @throws SystemException if a system exception occurred 340 */ 341 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G( 342 java.lang.String uuid, long groupId) 343 throws com.liferay.portal.kernel.exception.SystemException { 344 return getPersistence().fetchByUUID_G(uuid, groupId); 345 } 346 347 /** 348 * Finds the message boards category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 349 * 350 * @param uuid the uuid to search with 351 * @param groupId the group id to search with 352 * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found 353 * @throws SystemException if a system exception occurred 354 */ 355 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G( 356 java.lang.String uuid, long groupId, boolean retrieveFromCache) 357 throws com.liferay.portal.kernel.exception.SystemException { 358 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 359 } 360 361 /** 362 * Finds all the message boards categories where groupId = ?. 363 * 364 * @param groupId the group id to search with 365 * @return the matching message boards categories 366 * @throws SystemException if a system exception occurred 367 */ 368 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 369 long groupId) 370 throws com.liferay.portal.kernel.exception.SystemException { 371 return getPersistence().findByGroupId(groupId); 372 } 373 374 /** 375 * Finds a range of all the message boards categories where groupId = ?. 376 * 377 * <p> 378 * 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. 379 * </p> 380 * 381 * @param groupId the group id to search with 382 * @param start the lower bound of the range of message boards categories to return 383 * @param end the upper bound of the range of message boards categories to return (not inclusive) 384 * @return the range of matching message boards categories 385 * @throws SystemException if a system exception occurred 386 */ 387 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 388 long groupId, int start, int end) 389 throws com.liferay.portal.kernel.exception.SystemException { 390 return getPersistence().findByGroupId(groupId, start, end); 391 } 392 393 /** 394 * Finds an ordered range of all the message boards categories where groupId = ?. 395 * 396 * <p> 397 * 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. 398 * </p> 399 * 400 * @param groupId the group id to search with 401 * @param start the lower bound of the range of message boards categories to return 402 * @param end the upper bound of the range of message boards categories to return (not inclusive) 403 * @param orderByComparator the comparator to order the results by 404 * @return the ordered range of matching message boards categories 405 * @throws SystemException if a system exception occurred 406 */ 407 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 408 long groupId, int start, int end, 409 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 410 throws com.liferay.portal.kernel.exception.SystemException { 411 return getPersistence() 412 .findByGroupId(groupId, start, end, orderByComparator); 413 } 414 415 /** 416 * Finds the first message boards category in the ordered set where groupId = ?. 417 * 418 * <p> 419 * 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. 420 * </p> 421 * 422 * @param groupId the group id to search with 423 * @param orderByComparator the comparator to order the set by 424 * @return the first matching message boards category 425 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 426 * @throws SystemException if a system exception occurred 427 */ 428 public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_First( 429 long groupId, 430 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 431 throws com.liferay.portal.kernel.exception.SystemException, 432 com.liferay.portlet.messageboards.NoSuchCategoryException { 433 return getPersistence().findByGroupId_First(groupId, orderByComparator); 434 } 435 436 /** 437 * Finds the last message boards category in the ordered set where groupId = ?. 438 * 439 * <p> 440 * 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. 441 * </p> 442 * 443 * @param groupId the group id to search with 444 * @param orderByComparator the comparator to order the set by 445 * @return the last matching message boards category 446 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 447 * @throws SystemException if a system exception occurred 448 */ 449 public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_Last( 450 long groupId, 451 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 452 throws com.liferay.portal.kernel.exception.SystemException, 453 com.liferay.portlet.messageboards.NoSuchCategoryException { 454 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 455 } 456 457 /** 458 * Finds the message boards categories before and after the current message boards category in the ordered set where groupId = ?. 459 * 460 * <p> 461 * 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. 462 * </p> 463 * 464 * @param categoryId the primary key of the current message boards category 465 * @param groupId the group id to search with 466 * @param orderByComparator the comparator to order the set by 467 * @return the previous, current, and next message boards category 468 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 469 * @throws SystemException if a system exception occurred 470 */ 471 public static com.liferay.portlet.messageboards.model.MBCategory[] findByGroupId_PrevAndNext( 472 long categoryId, long groupId, 473 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 474 throws com.liferay.portal.kernel.exception.SystemException, 475 com.liferay.portlet.messageboards.NoSuchCategoryException { 476 return getPersistence() 477 .findByGroupId_PrevAndNext(categoryId, groupId, 478 orderByComparator); 479 } 480 481 /** 482 * Filters by the user's permissions and finds all the message boards categories where groupId = ?. 483 * 484 * @param groupId the group id to search with 485 * @return the matching message boards categories that the user has permission to view 486 * @throws SystemException if a system exception occurred 487 */ 488 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 489 long groupId) 490 throws com.liferay.portal.kernel.exception.SystemException { 491 return getPersistence().filterFindByGroupId(groupId); 492 } 493 494 /** 495 * Filters by the user's permissions and finds a range of all the message boards categories where groupId = ?. 496 * 497 * <p> 498 * 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. 499 * </p> 500 * 501 * @param groupId the group id to search with 502 * @param start the lower bound of the range of message boards categories to return 503 * @param end the upper bound of the range of message boards categories to return (not inclusive) 504 * @return the range of matching message boards categories that the user has permission to view 505 * @throws SystemException if a system exception occurred 506 */ 507 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 508 long groupId, int start, int end) 509 throws com.liferay.portal.kernel.exception.SystemException { 510 return getPersistence().filterFindByGroupId(groupId, start, end); 511 } 512 513 /** 514 * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = ?. 515 * 516 * <p> 517 * 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. 518 * </p> 519 * 520 * @param groupId the group id to search with 521 * @param start the lower bound of the range of message boards categories to return 522 * @param end the upper bound of the range of message boards categories to return (not inclusive) 523 * @param orderByComparator the comparator to order the results by 524 * @return the ordered range of matching message boards categories that the user has permission to view 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 528 long groupId, int start, int end, 529 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 530 throws com.liferay.portal.kernel.exception.SystemException { 531 return getPersistence() 532 .filterFindByGroupId(groupId, start, end, orderByComparator); 533 } 534 535 /** 536 * Finds all the message boards categories where companyId = ?. 537 * 538 * @param companyId the company id to search with 539 * @return the matching message boards categories 540 * @throws SystemException if a system exception occurred 541 */ 542 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 543 long companyId) 544 throws com.liferay.portal.kernel.exception.SystemException { 545 return getPersistence().findByCompanyId(companyId); 546 } 547 548 /** 549 * Finds a range of all the message boards categories where companyId = ?. 550 * 551 * <p> 552 * 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. 553 * </p> 554 * 555 * @param companyId the company id to search with 556 * @param start the lower bound of the range of message boards categories to return 557 * @param end the upper bound of the range of message boards categories to return (not inclusive) 558 * @return the range of matching message boards categories 559 * @throws SystemException if a system exception occurred 560 */ 561 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 562 long companyId, int start, int end) 563 throws com.liferay.portal.kernel.exception.SystemException { 564 return getPersistence().findByCompanyId(companyId, start, end); 565 } 566 567 /** 568 * Finds an ordered range of all the message boards categories where companyId = ?. 569 * 570 * <p> 571 * 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. 572 * </p> 573 * 574 * @param companyId the company id to search with 575 * @param start the lower bound of the range of message boards categories to return 576 * @param end the upper bound of the range of message boards categories to return (not inclusive) 577 * @param orderByComparator the comparator to order the results by 578 * @return the ordered range of matching message boards categories 579 * @throws SystemException if a system exception occurred 580 */ 581 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 582 long companyId, int start, int end, 583 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 584 throws com.liferay.portal.kernel.exception.SystemException { 585 return getPersistence() 586 .findByCompanyId(companyId, start, end, orderByComparator); 587 } 588 589 /** 590 * Finds the first message boards category in the ordered set where companyId = ?. 591 * 592 * <p> 593 * 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. 594 * </p> 595 * 596 * @param companyId the company id to search with 597 * @param orderByComparator the comparator to order the set by 598 * @return the first matching message boards category 599 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 600 * @throws SystemException if a system exception occurred 601 */ 602 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_First( 603 long companyId, 604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 605 throws com.liferay.portal.kernel.exception.SystemException, 606 com.liferay.portlet.messageboards.NoSuchCategoryException { 607 return getPersistence() 608 .findByCompanyId_First(companyId, orderByComparator); 609 } 610 611 /** 612 * Finds the last message boards category in the ordered set where companyId = ?. 613 * 614 * <p> 615 * 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. 616 * </p> 617 * 618 * @param companyId the company id to search with 619 * @param orderByComparator the comparator to order the set by 620 * @return the last matching message boards category 621 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 622 * @throws SystemException if a system exception occurred 623 */ 624 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_Last( 625 long companyId, 626 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 627 throws com.liferay.portal.kernel.exception.SystemException, 628 com.liferay.portlet.messageboards.NoSuchCategoryException { 629 return getPersistence() 630 .findByCompanyId_Last(companyId, orderByComparator); 631 } 632 633 /** 634 * Finds the message boards categories before and after the current message boards category in the ordered set where companyId = ?. 635 * 636 * <p> 637 * 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. 638 * </p> 639 * 640 * @param categoryId the primary key of the current message boards category 641 * @param companyId the company id to search with 642 * @param orderByComparator the comparator to order the set by 643 * @return the previous, current, and next message boards category 644 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 645 * @throws SystemException if a system exception occurred 646 */ 647 public static com.liferay.portlet.messageboards.model.MBCategory[] findByCompanyId_PrevAndNext( 648 long categoryId, long companyId, 649 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 650 throws com.liferay.portal.kernel.exception.SystemException, 651 com.liferay.portlet.messageboards.NoSuchCategoryException { 652 return getPersistence() 653 .findByCompanyId_PrevAndNext(categoryId, companyId, 654 orderByComparator); 655 } 656 657 /** 658 * Finds all the message boards categories where groupId = ? and parentCategoryId = ?. 659 * 660 * @param groupId the group id to search with 661 * @param parentCategoryId the parent category id to search with 662 * @return the matching message boards categories 663 * @throws SystemException if a system exception occurred 664 */ 665 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 666 long groupId, long parentCategoryId) 667 throws com.liferay.portal.kernel.exception.SystemException { 668 return getPersistence().findByG_P(groupId, parentCategoryId); 669 } 670 671 /** 672 * Finds a range of all the message boards categories where groupId = ? and parentCategoryId = ?. 673 * 674 * <p> 675 * 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. 676 * </p> 677 * 678 * @param groupId the group id to search with 679 * @param parentCategoryId the parent category id to search with 680 * @param start the lower bound of the range of message boards categories to return 681 * @param end the upper bound of the range of message boards categories to return (not inclusive) 682 * @return the range of matching message boards categories 683 * @throws SystemException if a system exception occurred 684 */ 685 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 686 long groupId, long parentCategoryId, int start, int end) 687 throws com.liferay.portal.kernel.exception.SystemException { 688 return getPersistence().findByG_P(groupId, parentCategoryId, start, end); 689 } 690 691 /** 692 * Finds an ordered range of all the message boards categories where groupId = ? and parentCategoryId = ?. 693 * 694 * <p> 695 * 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. 696 * </p> 697 * 698 * @param groupId the group id to search with 699 * @param parentCategoryId the parent category id to search with 700 * @param start the lower bound of the range of message boards categories to return 701 * @param end the upper bound of the range of message boards categories to return (not inclusive) 702 * @param orderByComparator the comparator to order the results by 703 * @return the ordered range of matching message boards categories 704 * @throws SystemException if a system exception occurred 705 */ 706 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 707 long groupId, long parentCategoryId, int start, int end, 708 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 709 throws com.liferay.portal.kernel.exception.SystemException { 710 return getPersistence() 711 .findByG_P(groupId, parentCategoryId, start, end, 712 orderByComparator); 713 } 714 715 /** 716 * Finds the first message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 717 * 718 * <p> 719 * 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. 720 * </p> 721 * 722 * @param groupId the group id to search with 723 * @param parentCategoryId the parent category id to search with 724 * @param orderByComparator the comparator to order the set by 725 * @return the first matching message boards category 726 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 727 * @throws SystemException if a system exception occurred 728 */ 729 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_First( 730 long groupId, long parentCategoryId, 731 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 732 throws com.liferay.portal.kernel.exception.SystemException, 733 com.liferay.portlet.messageboards.NoSuchCategoryException { 734 return getPersistence() 735 .findByG_P_First(groupId, parentCategoryId, orderByComparator); 736 } 737 738 /** 739 * Finds the last message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 740 * 741 * <p> 742 * 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. 743 * </p> 744 * 745 * @param groupId the group id to search with 746 * @param parentCategoryId the parent category id to search with 747 * @param orderByComparator the comparator to order the set by 748 * @return the last matching message boards category 749 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 750 * @throws SystemException if a system exception occurred 751 */ 752 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_Last( 753 long groupId, long parentCategoryId, 754 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 755 throws com.liferay.portal.kernel.exception.SystemException, 756 com.liferay.portlet.messageboards.NoSuchCategoryException { 757 return getPersistence() 758 .findByG_P_Last(groupId, parentCategoryId, orderByComparator); 759 } 760 761 /** 762 * Finds the message boards categories before and after the current message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 763 * 764 * <p> 765 * 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. 766 * </p> 767 * 768 * @param categoryId the primary key of the current message boards category 769 * @param groupId the group id to search with 770 * @param parentCategoryId the parent category id to search with 771 * @param orderByComparator the comparator to order the set by 772 * @return the previous, current, and next message boards category 773 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 774 * @throws SystemException if a system exception occurred 775 */ 776 public static com.liferay.portlet.messageboards.model.MBCategory[] findByG_P_PrevAndNext( 777 long categoryId, long groupId, long parentCategoryId, 778 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 779 throws com.liferay.portal.kernel.exception.SystemException, 780 com.liferay.portlet.messageboards.NoSuchCategoryException { 781 return getPersistence() 782 .findByG_P_PrevAndNext(categoryId, groupId, 783 parentCategoryId, orderByComparator); 784 } 785 786 /** 787 * Finds all the message boards categories where groupId = ? and parentCategoryId = any ?. 788 * 789 * <p> 790 * 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. 791 * </p> 792 * 793 * @param groupId the group id to search with 794 * @param parentCategoryIds the parent category ids to search with 795 * @return the matching message boards categories 796 * @throws SystemException if a system exception occurred 797 */ 798 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 799 long groupId, long[] parentCategoryIds) 800 throws com.liferay.portal.kernel.exception.SystemException { 801 return getPersistence().findByG_P(groupId, parentCategoryIds); 802 } 803 804 /** 805 * Finds a range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 806 * 807 * <p> 808 * 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. 809 * </p> 810 * 811 * @param groupId the group id to search with 812 * @param parentCategoryIds the parent category ids to search with 813 * @param start the lower bound of the range of message boards categories to return 814 * @param end the upper bound of the range of message boards categories to return (not inclusive) 815 * @return the range of matching message boards categories 816 * @throws SystemException if a system exception occurred 817 */ 818 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 819 long groupId, long[] parentCategoryIds, int start, int end) 820 throws com.liferay.portal.kernel.exception.SystemException { 821 return getPersistence().findByG_P(groupId, parentCategoryIds, start, end); 822 } 823 824 /** 825 * Finds an ordered range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 826 * 827 * <p> 828 * 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. 829 * </p> 830 * 831 * @param groupId the group id to search with 832 * @param parentCategoryIds the parent category ids to search with 833 * @param start the lower bound of the range of message boards categories to return 834 * @param end the upper bound of the range of message boards categories to return (not inclusive) 835 * @param orderByComparator the comparator to order the results by 836 * @return the ordered range of matching message boards categories 837 * @throws SystemException if a system exception occurred 838 */ 839 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 840 long groupId, long[] parentCategoryIds, int start, int end, 841 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 842 throws com.liferay.portal.kernel.exception.SystemException { 843 return getPersistence() 844 .findByG_P(groupId, parentCategoryIds, start, end, 845 orderByComparator); 846 } 847 848 /** 849 * Filters by the user's permissions and finds all the message boards categories where groupId = ? and parentCategoryId = ?. 850 * 851 * @param groupId the group id to search with 852 * @param parentCategoryId the parent category id to search with 853 * @return the matching message boards categories that the user has permission to view 854 * @throws SystemException if a system exception occurred 855 */ 856 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 857 long groupId, long parentCategoryId) 858 throws com.liferay.portal.kernel.exception.SystemException { 859 return getPersistence().filterFindByG_P(groupId, parentCategoryId); 860 } 861 862 /** 863 * Filters by the user's permissions and finds a range of all the message boards categories where groupId = ? and parentCategoryId = ?. 864 * 865 * <p> 866 * 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. 867 * </p> 868 * 869 * @param groupId the group id to search with 870 * @param parentCategoryId the parent category id to search with 871 * @param start the lower bound of the range of message boards categories to return 872 * @param end the upper bound of the range of message boards categories to return (not inclusive) 873 * @return the range of matching message boards categories that the user has permission to view 874 * @throws SystemException if a system exception occurred 875 */ 876 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 877 long groupId, long parentCategoryId, int start, int end) 878 throws com.liferay.portal.kernel.exception.SystemException { 879 return getPersistence() 880 .filterFindByG_P(groupId, parentCategoryId, start, end); 881 } 882 883 /** 884 * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = ? and parentCategoryId = ?. 885 * 886 * <p> 887 * 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. 888 * </p> 889 * 890 * @param groupId the group id to search with 891 * @param parentCategoryId the parent category id to search with 892 * @param start the lower bound of the range of message boards categories to return 893 * @param end the upper bound of the range of message boards categories to return (not inclusive) 894 * @param orderByComparator the comparator to order the results by 895 * @return the ordered range of matching message boards categories that the user has permission to view 896 * @throws SystemException if a system exception occurred 897 */ 898 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 899 long groupId, long parentCategoryId, int start, int end, 900 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 901 throws com.liferay.portal.kernel.exception.SystemException { 902 return getPersistence() 903 .filterFindByG_P(groupId, parentCategoryId, start, end, 904 orderByComparator); 905 } 906 907 /** 908 * Filters by the user's permissions and finds all the message boards categories where groupId = ? and parentCategoryId = any ?. 909 * 910 * <p> 911 * 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. 912 * </p> 913 * 914 * @param groupId the group id to search with 915 * @param parentCategoryIds the parent category ids to search with 916 * @return the matching message boards categories that the user has permission to view 917 * @throws SystemException if a system exception occurred 918 */ 919 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 920 long groupId, long[] parentCategoryIds) 921 throws com.liferay.portal.kernel.exception.SystemException { 922 return getPersistence().filterFindByG_P(groupId, parentCategoryIds); 923 } 924 925 /** 926 * Filters by the user's permissions and finds a range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 927 * 928 * <p> 929 * 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. 930 * </p> 931 * 932 * @param groupId the group id to search with 933 * @param parentCategoryIds the parent category ids to search with 934 * @param start the lower bound of the range of message boards categories to return 935 * @param end the upper bound of the range of message boards categories to return (not inclusive) 936 * @return the range of matching message boards categories that the user has permission to view 937 * @throws SystemException if a system exception occurred 938 */ 939 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 940 long groupId, long[] parentCategoryIds, int start, int end) 941 throws com.liferay.portal.kernel.exception.SystemException { 942 return getPersistence() 943 .filterFindByG_P(groupId, parentCategoryIds, start, end); 944 } 945 946 /** 947 * Filters by the user's permissions and finds an ordered range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 948 * 949 * <p> 950 * 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. 951 * </p> 952 * 953 * @param groupId the group id to search with 954 * @param parentCategoryIds the parent category ids to search with 955 * @param start the lower bound of the range of message boards categories to return 956 * @param end the upper bound of the range of message boards categories to return (not inclusive) 957 * @param orderByComparator the comparator to order the results by 958 * @return the ordered range of matching message boards categories that the user has permission to view 959 * @throws SystemException if a system exception occurred 960 */ 961 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 962 long groupId, long[] parentCategoryIds, int start, int end, 963 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 964 throws com.liferay.portal.kernel.exception.SystemException { 965 return getPersistence() 966 .filterFindByG_P(groupId, parentCategoryIds, start, end, 967 orderByComparator); 968 } 969 970 /** 971 * Finds all the message boards categories. 972 * 973 * @return the message boards categories 974 * @throws SystemException if a system exception occurred 975 */ 976 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll() 977 throws com.liferay.portal.kernel.exception.SystemException { 978 return getPersistence().findAll(); 979 } 980 981 /** 982 * Finds a range of all the message boards categories. 983 * 984 * <p> 985 * 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. 986 * </p> 987 * 988 * @param start the lower bound of the range of message boards categories to return 989 * @param end the upper bound of the range of message boards categories to return (not inclusive) 990 * @return the range of message boards categories 991 * @throws SystemException if a system exception occurred 992 */ 993 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 994 int start, int end) 995 throws com.liferay.portal.kernel.exception.SystemException { 996 return getPersistence().findAll(start, end); 997 } 998 999 /** 1000 * Finds an ordered range of all the message boards categories. 1001 * 1002 * <p> 1003 * 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. 1004 * </p> 1005 * 1006 * @param start the lower bound of the range of message boards categories to return 1007 * @param end the upper bound of the range of message boards categories to return (not inclusive) 1008 * @param orderByComparator the comparator to order the results by 1009 * @return the ordered range of message boards categories 1010 * @throws SystemException if a system exception occurred 1011 */ 1012 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 1013 int start, int end, 1014 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1015 throws com.liferay.portal.kernel.exception.SystemException { 1016 return getPersistence().findAll(start, end, orderByComparator); 1017 } 1018 1019 /** 1020 * Removes all the message boards categories where uuid = ? from the database. 1021 * 1022 * @param uuid the uuid to search with 1023 * @throws SystemException if a system exception occurred 1024 */ 1025 public static void removeByUuid(java.lang.String uuid) 1026 throws com.liferay.portal.kernel.exception.SystemException { 1027 getPersistence().removeByUuid(uuid); 1028 } 1029 1030 /** 1031 * Removes the message boards category where uuid = ? and groupId = ? from the database. 1032 * 1033 * @param uuid the uuid to search with 1034 * @param groupId the group id to search with 1035 * @throws SystemException if a system exception occurred 1036 */ 1037 public static void removeByUUID_G(java.lang.String uuid, long groupId) 1038 throws com.liferay.portal.kernel.exception.SystemException, 1039 com.liferay.portlet.messageboards.NoSuchCategoryException { 1040 getPersistence().removeByUUID_G(uuid, groupId); 1041 } 1042 1043 /** 1044 * Removes all the message boards categories where groupId = ? from the database. 1045 * 1046 * @param groupId the group id to search with 1047 * @throws SystemException if a system exception occurred 1048 */ 1049 public static void removeByGroupId(long groupId) 1050 throws com.liferay.portal.kernel.exception.SystemException { 1051 getPersistence().removeByGroupId(groupId); 1052 } 1053 1054 /** 1055 * Removes all the message boards categories where companyId = ? from the database. 1056 * 1057 * @param companyId the company id to search with 1058 * @throws SystemException if a system exception occurred 1059 */ 1060 public static void removeByCompanyId(long companyId) 1061 throws com.liferay.portal.kernel.exception.SystemException { 1062 getPersistence().removeByCompanyId(companyId); 1063 } 1064 1065 /** 1066 * Removes all the message boards categories where groupId = ? and parentCategoryId = ? from the database. 1067 * 1068 * @param groupId the group id to search with 1069 * @param parentCategoryId the parent category id to search with 1070 * @throws SystemException if a system exception occurred 1071 */ 1072 public static void removeByG_P(long groupId, long parentCategoryId) 1073 throws com.liferay.portal.kernel.exception.SystemException { 1074 getPersistence().removeByG_P(groupId, parentCategoryId); 1075 } 1076 1077 /** 1078 * Removes all the message boards categories from the database. 1079 * 1080 * @throws SystemException if a system exception occurred 1081 */ 1082 public static void removeAll() 1083 throws com.liferay.portal.kernel.exception.SystemException { 1084 getPersistence().removeAll(); 1085 } 1086 1087 /** 1088 * Counts all the message boards categories where uuid = ?. 1089 * 1090 * @param uuid the uuid to search with 1091 * @return the number of matching message boards categories 1092 * @throws SystemException if a system exception occurred 1093 */ 1094 public static int countByUuid(java.lang.String uuid) 1095 throws com.liferay.portal.kernel.exception.SystemException { 1096 return getPersistence().countByUuid(uuid); 1097 } 1098 1099 /** 1100 * Counts all the message boards categories where uuid = ? and groupId = ?. 1101 * 1102 * @param uuid the uuid to search with 1103 * @param groupId the group id to search with 1104 * @return the number of matching message boards categories 1105 * @throws SystemException if a system exception occurred 1106 */ 1107 public static int countByUUID_G(java.lang.String uuid, long groupId) 1108 throws com.liferay.portal.kernel.exception.SystemException { 1109 return getPersistence().countByUUID_G(uuid, groupId); 1110 } 1111 1112 /** 1113 * Counts all the message boards categories where groupId = ?. 1114 * 1115 * @param groupId the group id to search with 1116 * @return the number of matching message boards categories 1117 * @throws SystemException if a system exception occurred 1118 */ 1119 public static int countByGroupId(long groupId) 1120 throws com.liferay.portal.kernel.exception.SystemException { 1121 return getPersistence().countByGroupId(groupId); 1122 } 1123 1124 /** 1125 * Filters by the user's permissions and counts all the message boards categories where groupId = ?. 1126 * 1127 * @param groupId the group id to search with 1128 * @return the number of matching message boards categories that the user has permission to view 1129 * @throws SystemException if a system exception occurred 1130 */ 1131 public static int filterCountByGroupId(long groupId) 1132 throws com.liferay.portal.kernel.exception.SystemException { 1133 return getPersistence().filterCountByGroupId(groupId); 1134 } 1135 1136 /** 1137 * Counts all the message boards categories where companyId = ?. 1138 * 1139 * @param companyId the company id to search with 1140 * @return the number of matching message boards categories 1141 * @throws SystemException if a system exception occurred 1142 */ 1143 public static int countByCompanyId(long companyId) 1144 throws com.liferay.portal.kernel.exception.SystemException { 1145 return getPersistence().countByCompanyId(companyId); 1146 } 1147 1148 /** 1149 * Counts all the message boards categories where groupId = ? and parentCategoryId = ?. 1150 * 1151 * @param groupId the group id to search with 1152 * @param parentCategoryId the parent category id to search with 1153 * @return the number of matching message boards categories 1154 * @throws SystemException if a system exception occurred 1155 */ 1156 public static int countByG_P(long groupId, long parentCategoryId) 1157 throws com.liferay.portal.kernel.exception.SystemException { 1158 return getPersistence().countByG_P(groupId, parentCategoryId); 1159 } 1160 1161 /** 1162 * Counts all the message boards categories where groupId = ? and parentCategoryId = any ?. 1163 * 1164 * @param groupId the group id to search with 1165 * @param parentCategoryIds the parent category ids to search with 1166 * @return the number of matching message boards categories 1167 * @throws SystemException if a system exception occurred 1168 */ 1169 public static int countByG_P(long groupId, long[] parentCategoryIds) 1170 throws com.liferay.portal.kernel.exception.SystemException { 1171 return getPersistence().countByG_P(groupId, parentCategoryIds); 1172 } 1173 1174 /** 1175 * Filters by the user's permissions and counts all the message boards categories where groupId = ? and parentCategoryId = ?. 1176 * 1177 * @param groupId the group id to search with 1178 * @param parentCategoryId the parent category id to search with 1179 * @return the number of matching message boards categories that the user has permission to view 1180 * @throws SystemException if a system exception occurred 1181 */ 1182 public static int filterCountByG_P(long groupId, long parentCategoryId) 1183 throws com.liferay.portal.kernel.exception.SystemException { 1184 return getPersistence().filterCountByG_P(groupId, parentCategoryId); 1185 } 1186 1187 /** 1188 * Filters by the user's permissions and counts all the message boards categories where groupId = ? and parentCategoryId = any ?. 1189 * 1190 * @param groupId the group id to search with 1191 * @param parentCategoryIds the parent category ids to search with 1192 * @return the number of matching message boards categories that the user has permission to view 1193 * @throws SystemException if a system exception occurred 1194 */ 1195 public static int filterCountByG_P(long groupId, long[] parentCategoryIds) 1196 throws com.liferay.portal.kernel.exception.SystemException { 1197 return getPersistence().filterCountByG_P(groupId, parentCategoryIds); 1198 } 1199 1200 /** 1201 * Counts all the message boards categories. 1202 * 1203 * @return the number of message boards categories 1204 * @throws SystemException if a system exception occurred 1205 */ 1206 public static int countAll() 1207 throws com.liferay.portal.kernel.exception.SystemException { 1208 return getPersistence().countAll(); 1209 } 1210 1211 public static MBCategoryPersistence getPersistence() { 1212 if (_persistence == null) { 1213 _persistence = (MBCategoryPersistence)PortalBeanLocatorUtil.locate(MBCategoryPersistence.class.getName()); 1214 } 1215 1216 return _persistence; 1217 } 1218 1219 public void setPersistence(MBCategoryPersistence persistence) { 1220 _persistence = persistence; 1221 } 1222 1223 private static MBCategoryPersistence _persistence; 1224 }