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.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.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.messageboards.model.MBCategory; 025 026 import java.util.List; 027 028 /** 029 * 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. 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 MBCategoryPersistence 037 * @see MBCategoryPersistenceImpl 038 * @generated 039 */ 040 public class MBCategoryUtil { 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(MBCategory mbCategory) { 058 getPersistence().clearCache(mbCategory); 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<MBCategory> 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<MBCategory> 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<MBCategory> 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 MBCategory update(MBCategory mbCategory) 101 throws SystemException { 102 return getPersistence().update(mbCategory); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static MBCategory update(MBCategory mbCategory, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(mbCategory, serviceContext); 111 } 112 113 /** 114 * Returns all the message boards categories where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching message boards categories 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 121 java.lang.String uuid) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByUuid(uuid); 124 } 125 126 /** 127 * Returns a range of all the message boards categories where uuid = ?. 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.messageboards.model.impl.MBCategoryModelImpl}. 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 uuid the uuid 134 * @param start the lower bound of the range of message boards categories 135 * @param end the upper bound of the range of message boards categories (not inclusive) 136 * @return the range of matching message boards categories 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 140 java.lang.String uuid, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByUuid(uuid, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the message boards categories where uuid = ?. 147 * 148 * <p> 149 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 150 * </p> 151 * 152 * @param uuid the uuid 153 * @param start the lower bound of the range of message boards categories 154 * @param end the upper bound of the range of message boards categories (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching message boards categories 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid( 160 java.lang.String uuid, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 164 } 165 166 /** 167 * Returns the first message boards category in the ordered set where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 171 * @return the first matching message boards category 172 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_First( 176 java.lang.String uuid, 177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.messageboards.NoSuchCategoryException { 180 return getPersistence().findByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the first message boards category in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the first matching message boards category, or <code>null</code> if a matching message boards category could not be found 189 * @throws SystemException if a system exception occurred 190 */ 191 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUuid_First( 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 194 throws com.liferay.portal.kernel.exception.SystemException { 195 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 196 } 197 198 /** 199 * Returns the last message boards category in the ordered set where uuid = ?. 200 * 201 * @param uuid the uuid 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching message boards category 204 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 205 * @throws SystemException if a system exception occurred 206 */ 207 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_Last( 208 java.lang.String uuid, 209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 210 throws com.liferay.portal.kernel.exception.SystemException, 211 com.liferay.portlet.messageboards.NoSuchCategoryException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last message boards category in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching message boards category, or <code>null</code> if a matching message boards category could not be found 221 * @throws SystemException if a system exception occurred 222 */ 223 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUuid_Last( 224 java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 226 throws com.liferay.portal.kernel.exception.SystemException { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the message boards categories before and after the current message boards category in the ordered set where uuid = ?. 232 * 233 * @param categoryId the primary key of the current message boards category 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next message boards category 237 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 238 * @throws SystemException if a system exception occurred 239 */ 240 public static com.liferay.portlet.messageboards.model.MBCategory[] findByUuid_PrevAndNext( 241 long categoryId, java.lang.String uuid, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException, 244 com.liferay.portlet.messageboards.NoSuchCategoryException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(categoryId, uuid, orderByComparator); 247 } 248 249 /** 250 * Removes all the message boards categories where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 * @throws SystemException if a system exception occurred 254 */ 255 public static void removeByUuid(java.lang.String uuid) 256 throws com.liferay.portal.kernel.exception.SystemException { 257 getPersistence().removeByUuid(uuid); 258 } 259 260 /** 261 * Returns the number of message boards categories where uuid = ?. 262 * 263 * @param uuid the uuid 264 * @return the number of matching message boards categories 265 * @throws SystemException if a system exception occurred 266 */ 267 public static int countByUuid(java.lang.String uuid) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 return getPersistence().countByUuid(uuid); 270 } 271 272 /** 273 * Returns the message boards category where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @return the matching message boards category 278 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.messageboards.model.MBCategory findByUUID_G( 282 java.lang.String uuid, long groupId) 283 throws com.liferay.portal.kernel.exception.SystemException, 284 com.liferay.portlet.messageboards.NoSuchCategoryException { 285 return getPersistence().findByUUID_G(uuid, groupId); 286 } 287 288 /** 289 * Returns the message boards category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 290 * 291 * @param uuid the uuid 292 * @param groupId the group ID 293 * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found 294 * @throws SystemException if a system exception occurred 295 */ 296 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G( 297 java.lang.String uuid, long groupId) 298 throws com.liferay.portal.kernel.exception.SystemException { 299 return getPersistence().fetchByUUID_G(uuid, groupId); 300 } 301 302 /** 303 * Returns the message boards category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @param retrieveFromCache whether to use the finder cache 308 * @return the matching message boards category, or <code>null</code> if a matching message boards category could not be found 309 * @throws SystemException if a system exception occurred 310 */ 311 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUUID_G( 312 java.lang.String uuid, long groupId, boolean retrieveFromCache) 313 throws com.liferay.portal.kernel.exception.SystemException { 314 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 315 } 316 317 /** 318 * Removes the message boards category where uuid = ? and groupId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param groupId the group ID 322 * @return the message boards category that was removed 323 * @throws SystemException if a system exception occurred 324 */ 325 public static com.liferay.portlet.messageboards.model.MBCategory removeByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.messageboards.NoSuchCategoryException { 329 return getPersistence().removeByUUID_G(uuid, groupId); 330 } 331 332 /** 333 * Returns the number of message boards categories where uuid = ? and groupId = ?. 334 * 335 * @param uuid the uuid 336 * @param groupId the group ID 337 * @return the number of matching message boards categories 338 * @throws SystemException if a system exception occurred 339 */ 340 public static int countByUUID_G(java.lang.String uuid, long groupId) 341 throws com.liferay.portal.kernel.exception.SystemException { 342 return getPersistence().countByUUID_G(uuid, groupId); 343 } 344 345 /** 346 * Returns all the message boards categories where uuid = ? and companyId = ?. 347 * 348 * @param uuid the uuid 349 * @param companyId the company ID 350 * @return the matching message boards categories 351 * @throws SystemException if a system exception occurred 352 */ 353 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid_C( 354 java.lang.String uuid, long companyId) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().findByUuid_C(uuid, companyId); 357 } 358 359 /** 360 * Returns a range of all the message boards categories where uuid = ? and companyId = ?. 361 * 362 * <p> 363 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 364 * </p> 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @param start the lower bound of the range of message boards categories 369 * @param end the upper bound of the range of message boards categories (not inclusive) 370 * @return the range of matching message boards categories 371 * @throws SystemException if a system exception occurred 372 */ 373 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid_C( 374 java.lang.String uuid, long companyId, int start, int end) 375 throws com.liferay.portal.kernel.exception.SystemException { 376 return getPersistence().findByUuid_C(uuid, companyId, start, end); 377 } 378 379 /** 380 * Returns an ordered range of all the message boards categories where uuid = ? and companyId = ?. 381 * 382 * <p> 383 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 384 * </p> 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param start the lower bound of the range of message boards categories 389 * @param end the upper bound of the range of message boards categories (not inclusive) 390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 391 * @return the ordered range of matching message boards categories 392 * @throws SystemException if a system exception occurred 393 */ 394 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByUuid_C( 395 java.lang.String uuid, long companyId, int start, int end, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence() 399 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 400 } 401 402 /** 403 * Returns the first message boards category in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the first matching message boards category 409 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_C_First( 413 java.lang.String uuid, long companyId, 414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 415 throws com.liferay.portal.kernel.exception.SystemException, 416 com.liferay.portlet.messageboards.NoSuchCategoryException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first message boards category in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching message boards category, or <code>null</code> if a matching message boards category could not be found 428 * @throws SystemException if a system exception occurred 429 */ 430 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUuid_C_First( 431 java.lang.String uuid, long companyId, 432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 433 throws com.liferay.portal.kernel.exception.SystemException { 434 return getPersistence() 435 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 436 } 437 438 /** 439 * Returns the last message boards category in the ordered set where uuid = ? and companyId = ?. 440 * 441 * @param uuid the uuid 442 * @param companyId the company ID 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the last matching message boards category 445 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 446 * @throws SystemException if a system exception occurred 447 */ 448 public static com.liferay.portlet.messageboards.model.MBCategory findByUuid_C_Last( 449 java.lang.String uuid, long companyId, 450 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 451 throws com.liferay.portal.kernel.exception.SystemException, 452 com.liferay.portlet.messageboards.NoSuchCategoryException { 453 return getPersistence() 454 .findByUuid_C_Last(uuid, companyId, orderByComparator); 455 } 456 457 /** 458 * Returns the last message boards category in the ordered set where uuid = ? and companyId = ?. 459 * 460 * @param uuid the uuid 461 * @param companyId the company ID 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 463 * @return the last matching message boards category, or <code>null</code> if a matching message boards category could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.messageboards.model.MBCategory fetchByUuid_C_Last( 467 java.lang.String uuid, long companyId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence() 471 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 472 } 473 474 /** 475 * Returns the message boards categories before and after the current message boards category in the ordered set where uuid = ? and companyId = ?. 476 * 477 * @param categoryId the primary key of the current message boards category 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the previous, current, and next message boards category 482 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 483 * @throws SystemException if a system exception occurred 484 */ 485 public static com.liferay.portlet.messageboards.model.MBCategory[] findByUuid_C_PrevAndNext( 486 long categoryId, java.lang.String uuid, long companyId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.messageboards.NoSuchCategoryException { 490 return getPersistence() 491 .findByUuid_C_PrevAndNext(categoryId, uuid, companyId, 492 orderByComparator); 493 } 494 495 /** 496 * Removes all the message boards categories where uuid = ? and companyId = ? from the database. 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @throws SystemException if a system exception occurred 501 */ 502 public static void removeByUuid_C(java.lang.String uuid, long companyId) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 getPersistence().removeByUuid_C(uuid, companyId); 505 } 506 507 /** 508 * Returns the number of message boards categories where uuid = ? and companyId = ?. 509 * 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @return the number of matching message boards categories 513 * @throws SystemException if a system exception occurred 514 */ 515 public static int countByUuid_C(java.lang.String uuid, long companyId) 516 throws com.liferay.portal.kernel.exception.SystemException { 517 return getPersistence().countByUuid_C(uuid, companyId); 518 } 519 520 /** 521 * Returns all the message boards categories where groupId = ?. 522 * 523 * @param groupId the group ID 524 * @return the matching message boards categories 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 528 long groupId) 529 throws com.liferay.portal.kernel.exception.SystemException { 530 return getPersistence().findByGroupId(groupId); 531 } 532 533 /** 534 * Returns a range of all the message boards categories where groupId = ?. 535 * 536 * <p> 537 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 538 * </p> 539 * 540 * @param groupId the group ID 541 * @param start the lower bound of the range of message boards categories 542 * @param end the upper bound of the range of message boards categories (not inclusive) 543 * @return the range of matching message boards categories 544 * @throws SystemException if a system exception occurred 545 */ 546 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 547 long groupId, int start, int end) 548 throws com.liferay.portal.kernel.exception.SystemException { 549 return getPersistence().findByGroupId(groupId, start, end); 550 } 551 552 /** 553 * Returns an ordered range of all the message boards categories where groupId = ?. 554 * 555 * <p> 556 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 557 * </p> 558 * 559 * @param groupId the group ID 560 * @param start the lower bound of the range of message boards categories 561 * @param end the upper bound of the range of message boards categories (not inclusive) 562 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 563 * @return the ordered range of matching message boards categories 564 * @throws SystemException if a system exception occurred 565 */ 566 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByGroupId( 567 long groupId, int start, int end, 568 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 569 throws com.liferay.portal.kernel.exception.SystemException { 570 return getPersistence() 571 .findByGroupId(groupId, start, end, orderByComparator); 572 } 573 574 /** 575 * Returns the first message boards category in the ordered set where groupId = ?. 576 * 577 * @param groupId the group ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching message boards category 580 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_First( 584 long groupId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.messageboards.NoSuchCategoryException { 588 return getPersistence().findByGroupId_First(groupId, orderByComparator); 589 } 590 591 /** 592 * Returns the first message boards category in the ordered set where groupId = ?. 593 * 594 * @param groupId the group ID 595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 596 * @return the first matching message boards category, or <code>null</code> if a matching message boards category could not be found 597 * @throws SystemException if a system exception occurred 598 */ 599 public static com.liferay.portlet.messageboards.model.MBCategory fetchByGroupId_First( 600 long groupId, 601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 602 throws com.liferay.portal.kernel.exception.SystemException { 603 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 604 } 605 606 /** 607 * Returns the last message boards category in the ordered set where groupId = ?. 608 * 609 * @param groupId the group ID 610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 611 * @return the last matching message boards category 612 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 613 * @throws SystemException if a system exception occurred 614 */ 615 public static com.liferay.portlet.messageboards.model.MBCategory findByGroupId_Last( 616 long groupId, 617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 618 throws com.liferay.portal.kernel.exception.SystemException, 619 com.liferay.portlet.messageboards.NoSuchCategoryException { 620 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 621 } 622 623 /** 624 * Returns the last message boards category in the ordered set where groupId = ?. 625 * 626 * @param groupId the group ID 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the last matching message boards category, or <code>null</code> if a matching message boards category could not be found 629 * @throws SystemException if a system exception occurred 630 */ 631 public static com.liferay.portlet.messageboards.model.MBCategory fetchByGroupId_Last( 632 long groupId, 633 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 634 throws com.liferay.portal.kernel.exception.SystemException { 635 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 636 } 637 638 /** 639 * Returns the message boards categories before and after the current message boards category in the ordered set where groupId = ?. 640 * 641 * @param categoryId the primary key of the current message boards category 642 * @param groupId the group ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the previous, current, and next message boards category 645 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public static com.liferay.portlet.messageboards.model.MBCategory[] findByGroupId_PrevAndNext( 649 long categoryId, long groupId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.messageboards.NoSuchCategoryException { 653 return getPersistence() 654 .findByGroupId_PrevAndNext(categoryId, groupId, 655 orderByComparator); 656 } 657 658 /** 659 * Returns all the message boards categories that the user has permission to view where groupId = ?. 660 * 661 * @param groupId the group ID 662 * @return the matching message boards categories that the user has permission to view 663 * @throws SystemException if a system exception occurred 664 */ 665 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 666 long groupId) 667 throws com.liferay.portal.kernel.exception.SystemException { 668 return getPersistence().filterFindByGroupId(groupId); 669 } 670 671 /** 672 * Returns a range of all the message boards categories that the user has permission to view where groupId = ?. 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. 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 676 * </p> 677 * 678 * @param groupId the group ID 679 * @param start the lower bound of the range of message boards categories 680 * @param end the upper bound of the range of message boards categories (not inclusive) 681 * @return the range of matching message boards categories that the user has permission to view 682 * @throws SystemException if a system exception occurred 683 */ 684 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 685 long groupId, int start, int end) 686 throws com.liferay.portal.kernel.exception.SystemException { 687 return getPersistence().filterFindByGroupId(groupId, start, end); 688 } 689 690 /** 691 * Returns an ordered range of all the message boards categories that the user has permissions to view where groupId = ?. 692 * 693 * <p> 694 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 695 * </p> 696 * 697 * @param groupId the group ID 698 * @param start the lower bound of the range of message boards categories 699 * @param end the upper bound of the range of message boards categories (not inclusive) 700 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 701 * @return the ordered range of matching message boards categories that the user has permission to view 702 * @throws SystemException if a system exception occurred 703 */ 704 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByGroupId( 705 long groupId, int start, int end, 706 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 707 throws com.liferay.portal.kernel.exception.SystemException { 708 return getPersistence() 709 .filterFindByGroupId(groupId, start, end, orderByComparator); 710 } 711 712 /** 713 * Returns the message boards categories before and after the current message boards category in the ordered set of message boards categories that the user has permission to view where groupId = ?. 714 * 715 * @param categoryId the primary key of the current message boards category 716 * @param groupId the group ID 717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 718 * @return the previous, current, and next message boards category 719 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 720 * @throws SystemException if a system exception occurred 721 */ 722 public static com.liferay.portlet.messageboards.model.MBCategory[] filterFindByGroupId_PrevAndNext( 723 long categoryId, long groupId, 724 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 725 throws com.liferay.portal.kernel.exception.SystemException, 726 com.liferay.portlet.messageboards.NoSuchCategoryException { 727 return getPersistence() 728 .filterFindByGroupId_PrevAndNext(categoryId, groupId, 729 orderByComparator); 730 } 731 732 /** 733 * Removes all the message boards categories where groupId = ? from the database. 734 * 735 * @param groupId the group ID 736 * @throws SystemException if a system exception occurred 737 */ 738 public static void removeByGroupId(long groupId) 739 throws com.liferay.portal.kernel.exception.SystemException { 740 getPersistence().removeByGroupId(groupId); 741 } 742 743 /** 744 * Returns the number of message boards categories where groupId = ?. 745 * 746 * @param groupId the group ID 747 * @return the number of matching message boards categories 748 * @throws SystemException if a system exception occurred 749 */ 750 public static int countByGroupId(long groupId) 751 throws com.liferay.portal.kernel.exception.SystemException { 752 return getPersistence().countByGroupId(groupId); 753 } 754 755 /** 756 * Returns the number of message boards categories that the user has permission to view where groupId = ?. 757 * 758 * @param groupId the group ID 759 * @return the number of matching message boards categories that the user has permission to view 760 * @throws SystemException if a system exception occurred 761 */ 762 public static int filterCountByGroupId(long groupId) 763 throws com.liferay.portal.kernel.exception.SystemException { 764 return getPersistence().filterCountByGroupId(groupId); 765 } 766 767 /** 768 * Returns all the message boards categories where companyId = ?. 769 * 770 * @param companyId the company ID 771 * @return the matching message boards categories 772 * @throws SystemException if a system exception occurred 773 */ 774 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 775 long companyId) 776 throws com.liferay.portal.kernel.exception.SystemException { 777 return getPersistence().findByCompanyId(companyId); 778 } 779 780 /** 781 * Returns a range of all the message boards categories where companyId = ?. 782 * 783 * <p> 784 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 785 * </p> 786 * 787 * @param companyId the company ID 788 * @param start the lower bound of the range of message boards categories 789 * @param end the upper bound of the range of message boards categories (not inclusive) 790 * @return the range of matching message boards categories 791 * @throws SystemException if a system exception occurred 792 */ 793 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 794 long companyId, int start, int end) 795 throws com.liferay.portal.kernel.exception.SystemException { 796 return getPersistence().findByCompanyId(companyId, start, end); 797 } 798 799 /** 800 * Returns an ordered range of all the message boards categories where companyId = ?. 801 * 802 * <p> 803 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 804 * </p> 805 * 806 * @param companyId the company ID 807 * @param start the lower bound of the range of message boards categories 808 * @param end the upper bound of the range of message boards categories (not inclusive) 809 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 810 * @return the ordered range of matching message boards categories 811 * @throws SystemException if a system exception occurred 812 */ 813 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByCompanyId( 814 long companyId, int start, int end, 815 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 816 throws com.liferay.portal.kernel.exception.SystemException { 817 return getPersistence() 818 .findByCompanyId(companyId, start, end, orderByComparator); 819 } 820 821 /** 822 * Returns the first message boards category in the ordered set where companyId = ?. 823 * 824 * @param companyId the company ID 825 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 826 * @return the first matching message boards category 827 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 828 * @throws SystemException if a system exception occurred 829 */ 830 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_First( 831 long companyId, 832 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 833 throws com.liferay.portal.kernel.exception.SystemException, 834 com.liferay.portlet.messageboards.NoSuchCategoryException { 835 return getPersistence() 836 .findByCompanyId_First(companyId, orderByComparator); 837 } 838 839 /** 840 * Returns the first message boards category in the ordered set where companyId = ?. 841 * 842 * @param companyId the company ID 843 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 844 * @return the first matching message boards category, or <code>null</code> if a matching message boards category could not be found 845 * @throws SystemException if a system exception occurred 846 */ 847 public static com.liferay.portlet.messageboards.model.MBCategory fetchByCompanyId_First( 848 long companyId, 849 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 850 throws com.liferay.portal.kernel.exception.SystemException { 851 return getPersistence() 852 .fetchByCompanyId_First(companyId, orderByComparator); 853 } 854 855 /** 856 * Returns the last message boards category in the ordered set where companyId = ?. 857 * 858 * @param companyId the company ID 859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 860 * @return the last matching message boards category 861 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 862 * @throws SystemException if a system exception occurred 863 */ 864 public static com.liferay.portlet.messageboards.model.MBCategory findByCompanyId_Last( 865 long companyId, 866 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 867 throws com.liferay.portal.kernel.exception.SystemException, 868 com.liferay.portlet.messageboards.NoSuchCategoryException { 869 return getPersistence() 870 .findByCompanyId_Last(companyId, orderByComparator); 871 } 872 873 /** 874 * Returns the last message boards category in the ordered set where companyId = ?. 875 * 876 * @param companyId the company ID 877 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 878 * @return the last matching message boards category, or <code>null</code> if a matching message boards category could not be found 879 * @throws SystemException if a system exception occurred 880 */ 881 public static com.liferay.portlet.messageboards.model.MBCategory fetchByCompanyId_Last( 882 long companyId, 883 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 884 throws com.liferay.portal.kernel.exception.SystemException { 885 return getPersistence() 886 .fetchByCompanyId_Last(companyId, orderByComparator); 887 } 888 889 /** 890 * Returns the message boards categories before and after the current message boards category in the ordered set where companyId = ?. 891 * 892 * @param categoryId the primary key of the current message boards category 893 * @param companyId the company ID 894 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 895 * @return the previous, current, and next message boards category 896 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 897 * @throws SystemException if a system exception occurred 898 */ 899 public static com.liferay.portlet.messageboards.model.MBCategory[] findByCompanyId_PrevAndNext( 900 long categoryId, long companyId, 901 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 902 throws com.liferay.portal.kernel.exception.SystemException, 903 com.liferay.portlet.messageboards.NoSuchCategoryException { 904 return getPersistence() 905 .findByCompanyId_PrevAndNext(categoryId, companyId, 906 orderByComparator); 907 } 908 909 /** 910 * Removes all the message boards categories where companyId = ? from the database. 911 * 912 * @param companyId the company ID 913 * @throws SystemException if a system exception occurred 914 */ 915 public static void removeByCompanyId(long companyId) 916 throws com.liferay.portal.kernel.exception.SystemException { 917 getPersistence().removeByCompanyId(companyId); 918 } 919 920 /** 921 * Returns the number of message boards categories where companyId = ?. 922 * 923 * @param companyId the company ID 924 * @return the number of matching message boards categories 925 * @throws SystemException if a system exception occurred 926 */ 927 public static int countByCompanyId(long companyId) 928 throws com.liferay.portal.kernel.exception.SystemException { 929 return getPersistence().countByCompanyId(companyId); 930 } 931 932 /** 933 * Returns all the message boards categories where groupId = ? and parentCategoryId = ?. 934 * 935 * @param groupId the group ID 936 * @param parentCategoryId the parent category ID 937 * @return the matching message boards categories 938 * @throws SystemException if a system exception occurred 939 */ 940 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 941 long groupId, long parentCategoryId) 942 throws com.liferay.portal.kernel.exception.SystemException { 943 return getPersistence().findByG_P(groupId, parentCategoryId); 944 } 945 946 /** 947 * Returns a range of all the message boards categories where groupId = ? and parentCategoryId = ?. 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. 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 951 * </p> 952 * 953 * @param groupId the group ID 954 * @param parentCategoryId the parent category ID 955 * @param start the lower bound of the range of message boards categories 956 * @param end the upper bound of the range of message boards categories (not inclusive) 957 * @return the range of matching message boards categories 958 * @throws SystemException if a system exception occurred 959 */ 960 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 961 long groupId, long parentCategoryId, int start, int end) 962 throws com.liferay.portal.kernel.exception.SystemException { 963 return getPersistence().findByG_P(groupId, parentCategoryId, start, end); 964 } 965 966 /** 967 * Returns an ordered range of all the message boards categories where groupId = ? and parentCategoryId = ?. 968 * 969 * <p> 970 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 971 * </p> 972 * 973 * @param groupId the group ID 974 * @param parentCategoryId the parent category ID 975 * @param start the lower bound of the range of message boards categories 976 * @param end the upper bound of the range of message boards categories (not inclusive) 977 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 978 * @return the ordered range of matching message boards categories 979 * @throws SystemException if a system exception occurred 980 */ 981 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 982 long groupId, long parentCategoryId, int start, int end, 983 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 984 throws com.liferay.portal.kernel.exception.SystemException { 985 return getPersistence() 986 .findByG_P(groupId, parentCategoryId, start, end, 987 orderByComparator); 988 } 989 990 /** 991 * Returns the first message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 992 * 993 * @param groupId the group ID 994 * @param parentCategoryId the parent category ID 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the first matching message boards category 997 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 998 * @throws SystemException if a system exception occurred 999 */ 1000 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_First( 1001 long groupId, long parentCategoryId, 1002 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1003 throws com.liferay.portal.kernel.exception.SystemException, 1004 com.liferay.portlet.messageboards.NoSuchCategoryException { 1005 return getPersistence() 1006 .findByG_P_First(groupId, parentCategoryId, orderByComparator); 1007 } 1008 1009 /** 1010 * Returns the first message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 1011 * 1012 * @param groupId the group ID 1013 * @param parentCategoryId the parent category ID 1014 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1015 * @return the first matching message boards category, or <code>null</code> if a matching message boards category could not be found 1016 * @throws SystemException if a system exception occurred 1017 */ 1018 public static com.liferay.portlet.messageboards.model.MBCategory fetchByG_P_First( 1019 long groupId, long parentCategoryId, 1020 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1021 throws com.liferay.portal.kernel.exception.SystemException { 1022 return getPersistence() 1023 .fetchByG_P_First(groupId, parentCategoryId, 1024 orderByComparator); 1025 } 1026 1027 /** 1028 * Returns the last message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 1029 * 1030 * @param groupId the group ID 1031 * @param parentCategoryId the parent category ID 1032 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1033 * @return the last matching message boards category 1034 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 1035 * @throws SystemException if a system exception occurred 1036 */ 1037 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_Last( 1038 long groupId, long parentCategoryId, 1039 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1040 throws com.liferay.portal.kernel.exception.SystemException, 1041 com.liferay.portlet.messageboards.NoSuchCategoryException { 1042 return getPersistence() 1043 .findByG_P_Last(groupId, parentCategoryId, orderByComparator); 1044 } 1045 1046 /** 1047 * Returns the last message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 1048 * 1049 * @param groupId the group ID 1050 * @param parentCategoryId the parent category ID 1051 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1052 * @return the last matching message boards category, or <code>null</code> if a matching message boards category could not be found 1053 * @throws SystemException if a system exception occurred 1054 */ 1055 public static com.liferay.portlet.messageboards.model.MBCategory fetchByG_P_Last( 1056 long groupId, long parentCategoryId, 1057 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1058 throws com.liferay.portal.kernel.exception.SystemException { 1059 return getPersistence() 1060 .fetchByG_P_Last(groupId, parentCategoryId, orderByComparator); 1061 } 1062 1063 /** 1064 * Returns the message boards categories before and after the current message boards category in the ordered set where groupId = ? and parentCategoryId = ?. 1065 * 1066 * @param categoryId the primary key of the current message boards category 1067 * @param groupId the group ID 1068 * @param parentCategoryId the parent category ID 1069 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1070 * @return the previous, current, and next message boards category 1071 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 1072 * @throws SystemException if a system exception occurred 1073 */ 1074 public static com.liferay.portlet.messageboards.model.MBCategory[] findByG_P_PrevAndNext( 1075 long categoryId, long groupId, long parentCategoryId, 1076 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1077 throws com.liferay.portal.kernel.exception.SystemException, 1078 com.liferay.portlet.messageboards.NoSuchCategoryException { 1079 return getPersistence() 1080 .findByG_P_PrevAndNext(categoryId, groupId, 1081 parentCategoryId, orderByComparator); 1082 } 1083 1084 /** 1085 * Returns all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 1086 * 1087 * @param groupId the group ID 1088 * @param parentCategoryId the parent category ID 1089 * @return the matching message boards categories that the user has permission to view 1090 * @throws SystemException if a system exception occurred 1091 */ 1092 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 1093 long groupId, long parentCategoryId) 1094 throws com.liferay.portal.kernel.exception.SystemException { 1095 return getPersistence().filterFindByG_P(groupId, parentCategoryId); 1096 } 1097 1098 /** 1099 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 1100 * 1101 * <p> 1102 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1103 * </p> 1104 * 1105 * @param groupId the group ID 1106 * @param parentCategoryId the parent category ID 1107 * @param start the lower bound of the range of message boards categories 1108 * @param end the upper bound of the range of message boards categories (not inclusive) 1109 * @return the range of matching message boards categories that the user has permission to view 1110 * @throws SystemException if a system exception occurred 1111 */ 1112 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 1113 long groupId, long parentCategoryId, int start, int end) 1114 throws com.liferay.portal.kernel.exception.SystemException { 1115 return getPersistence() 1116 .filterFindByG_P(groupId, parentCategoryId, start, end); 1117 } 1118 1119 /** 1120 * Returns an ordered range of all the message boards categories that the user has permissions to view where groupId = ? and parentCategoryId = ?. 1121 * 1122 * <p> 1123 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1124 * </p> 1125 * 1126 * @param groupId the group ID 1127 * @param parentCategoryId the parent category ID 1128 * @param start the lower bound of the range of message boards categories 1129 * @param end the upper bound of the range of message boards categories (not inclusive) 1130 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1131 * @return the ordered range of matching message boards categories that the user has permission to view 1132 * @throws SystemException if a system exception occurred 1133 */ 1134 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 1135 long groupId, long parentCategoryId, int start, int end, 1136 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1137 throws com.liferay.portal.kernel.exception.SystemException { 1138 return getPersistence() 1139 .filterFindByG_P(groupId, parentCategoryId, start, end, 1140 orderByComparator); 1141 } 1142 1143 /** 1144 * Returns the message boards categories before and after the current message boards category in the ordered set of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 1145 * 1146 * @param categoryId the primary key of the current message boards category 1147 * @param groupId the group ID 1148 * @param parentCategoryId the parent category ID 1149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1150 * @return the previous, current, and next message boards category 1151 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 1152 * @throws SystemException if a system exception occurred 1153 */ 1154 public static com.liferay.portlet.messageboards.model.MBCategory[] filterFindByG_P_PrevAndNext( 1155 long categoryId, long groupId, long parentCategoryId, 1156 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1157 throws com.liferay.portal.kernel.exception.SystemException, 1158 com.liferay.portlet.messageboards.NoSuchCategoryException { 1159 return getPersistence() 1160 .filterFindByG_P_PrevAndNext(categoryId, groupId, 1161 parentCategoryId, orderByComparator); 1162 } 1163 1164 /** 1165 * Returns all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 1166 * 1167 * @param groupId the group ID 1168 * @param parentCategoryIds the parent category IDs 1169 * @return the matching message boards categories that the user has permission to view 1170 * @throws SystemException if a system exception occurred 1171 */ 1172 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 1173 long groupId, long[] parentCategoryIds) 1174 throws com.liferay.portal.kernel.exception.SystemException { 1175 return getPersistence().filterFindByG_P(groupId, parentCategoryIds); 1176 } 1177 1178 /** 1179 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 1180 * 1181 * <p> 1182 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1183 * </p> 1184 * 1185 * @param groupId the group ID 1186 * @param parentCategoryIds the parent category IDs 1187 * @param start the lower bound of the range of message boards categories 1188 * @param end the upper bound of the range of message boards categories (not inclusive) 1189 * @return the range of matching message boards categories that the user has permission to view 1190 * @throws SystemException if a system exception occurred 1191 */ 1192 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 1193 long groupId, long[] parentCategoryIds, int start, int end) 1194 throws com.liferay.portal.kernel.exception.SystemException { 1195 return getPersistence() 1196 .filterFindByG_P(groupId, parentCategoryIds, start, end); 1197 } 1198 1199 /** 1200 * Returns an ordered range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 1201 * 1202 * <p> 1203 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1204 * </p> 1205 * 1206 * @param groupId the group ID 1207 * @param parentCategoryIds the parent category IDs 1208 * @param start the lower bound of the range of message boards categories 1209 * @param end the upper bound of the range of message boards categories (not inclusive) 1210 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1211 * @return the ordered range of matching message boards categories that the user has permission to view 1212 * @throws SystemException if a system exception occurred 1213 */ 1214 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P( 1215 long groupId, long[] parentCategoryIds, int start, int end, 1216 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1217 throws com.liferay.portal.kernel.exception.SystemException { 1218 return getPersistence() 1219 .filterFindByG_P(groupId, parentCategoryIds, start, end, 1220 orderByComparator); 1221 } 1222 1223 /** 1224 * Returns all the message boards categories where groupId = ? and parentCategoryId = any ?. 1225 * 1226 * <p> 1227 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1228 * </p> 1229 * 1230 * @param groupId the group ID 1231 * @param parentCategoryIds the parent category IDs 1232 * @return the matching message boards categories 1233 * @throws SystemException if a system exception occurred 1234 */ 1235 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 1236 long groupId, long[] parentCategoryIds) 1237 throws com.liferay.portal.kernel.exception.SystemException { 1238 return getPersistence().findByG_P(groupId, parentCategoryIds); 1239 } 1240 1241 /** 1242 * Returns a range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 1243 * 1244 * <p> 1245 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1246 * </p> 1247 * 1248 * @param groupId the group ID 1249 * @param parentCategoryIds the parent category IDs 1250 * @param start the lower bound of the range of message boards categories 1251 * @param end the upper bound of the range of message boards categories (not inclusive) 1252 * @return the range of matching message boards categories 1253 * @throws SystemException if a system exception occurred 1254 */ 1255 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 1256 long groupId, long[] parentCategoryIds, int start, int end) 1257 throws com.liferay.portal.kernel.exception.SystemException { 1258 return getPersistence().findByG_P(groupId, parentCategoryIds, start, end); 1259 } 1260 1261 /** 1262 * Returns an ordered range of all the message boards categories where groupId = ? and parentCategoryId = any ?. 1263 * 1264 * <p> 1265 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1266 * </p> 1267 * 1268 * @param groupId the group ID 1269 * @param parentCategoryIds the parent category IDs 1270 * @param start the lower bound of the range of message boards categories 1271 * @param end the upper bound of the range of message boards categories (not inclusive) 1272 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1273 * @return the ordered range of matching message boards categories 1274 * @throws SystemException if a system exception occurred 1275 */ 1276 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P( 1277 long groupId, long[] parentCategoryIds, int start, int end, 1278 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1279 throws com.liferay.portal.kernel.exception.SystemException { 1280 return getPersistence() 1281 .findByG_P(groupId, parentCategoryIds, start, end, 1282 orderByComparator); 1283 } 1284 1285 /** 1286 * Removes all the message boards categories where groupId = ? and parentCategoryId = ? from the database. 1287 * 1288 * @param groupId the group ID 1289 * @param parentCategoryId the parent category ID 1290 * @throws SystemException if a system exception occurred 1291 */ 1292 public static void removeByG_P(long groupId, long parentCategoryId) 1293 throws com.liferay.portal.kernel.exception.SystemException { 1294 getPersistence().removeByG_P(groupId, parentCategoryId); 1295 } 1296 1297 /** 1298 * Returns the number of message boards categories where groupId = ? and parentCategoryId = ?. 1299 * 1300 * @param groupId the group ID 1301 * @param parentCategoryId the parent category ID 1302 * @return the number of matching message boards categories 1303 * @throws SystemException if a system exception occurred 1304 */ 1305 public static int countByG_P(long groupId, long parentCategoryId) 1306 throws com.liferay.portal.kernel.exception.SystemException { 1307 return getPersistence().countByG_P(groupId, parentCategoryId); 1308 } 1309 1310 /** 1311 * Returns the number of message boards categories where groupId = ? and parentCategoryId = any ?. 1312 * 1313 * @param groupId the group ID 1314 * @param parentCategoryIds the parent category IDs 1315 * @return the number of matching message boards categories 1316 * @throws SystemException if a system exception occurred 1317 */ 1318 public static int countByG_P(long groupId, long[] parentCategoryIds) 1319 throws com.liferay.portal.kernel.exception.SystemException { 1320 return getPersistence().countByG_P(groupId, parentCategoryIds); 1321 } 1322 1323 /** 1324 * Returns the number of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ?. 1325 * 1326 * @param groupId the group ID 1327 * @param parentCategoryId the parent category ID 1328 * @return the number of matching message boards categories that the user has permission to view 1329 * @throws SystemException if a system exception occurred 1330 */ 1331 public static int filterCountByG_P(long groupId, long parentCategoryId) 1332 throws com.liferay.portal.kernel.exception.SystemException { 1333 return getPersistence().filterCountByG_P(groupId, parentCategoryId); 1334 } 1335 1336 /** 1337 * Returns the number of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ?. 1338 * 1339 * @param groupId the group ID 1340 * @param parentCategoryIds the parent category IDs 1341 * @return the number of matching message boards categories that the user has permission to view 1342 * @throws SystemException if a system exception occurred 1343 */ 1344 public static int filterCountByG_P(long groupId, long[] parentCategoryIds) 1345 throws com.liferay.portal.kernel.exception.SystemException { 1346 return getPersistence().filterCountByG_P(groupId, parentCategoryIds); 1347 } 1348 1349 /** 1350 * Returns all the message boards categories where groupId = ? and status = ?. 1351 * 1352 * @param groupId the group ID 1353 * @param status the status 1354 * @return the matching message boards categories 1355 * @throws SystemException if a system exception occurred 1356 */ 1357 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_S( 1358 long groupId, int status) 1359 throws com.liferay.portal.kernel.exception.SystemException { 1360 return getPersistence().findByG_S(groupId, status); 1361 } 1362 1363 /** 1364 * Returns a range of all the message boards categories where groupId = ? and status = ?. 1365 * 1366 * <p> 1367 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1368 * </p> 1369 * 1370 * @param groupId the group ID 1371 * @param status the status 1372 * @param start the lower bound of the range of message boards categories 1373 * @param end the upper bound of the range of message boards categories (not inclusive) 1374 * @return the range of matching message boards categories 1375 * @throws SystemException if a system exception occurred 1376 */ 1377 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_S( 1378 long groupId, int status, int start, int end) 1379 throws com.liferay.portal.kernel.exception.SystemException { 1380 return getPersistence().findByG_S(groupId, status, start, end); 1381 } 1382 1383 /** 1384 * Returns an ordered range of all the message boards categories where groupId = ? and status = ?. 1385 * 1386 * <p> 1387 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1388 * </p> 1389 * 1390 * @param groupId the group ID 1391 * @param status the status 1392 * @param start the lower bound of the range of message boards categories 1393 * @param end the upper bound of the range of message boards categories (not inclusive) 1394 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1395 * @return the ordered range of matching message boards categories 1396 * @throws SystemException if a system exception occurred 1397 */ 1398 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_S( 1399 long groupId, int status, int start, int end, 1400 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1401 throws com.liferay.portal.kernel.exception.SystemException { 1402 return getPersistence() 1403 .findByG_S(groupId, status, start, end, orderByComparator); 1404 } 1405 1406 /** 1407 * Returns the first message boards category in the ordered set where groupId = ? and status = ?. 1408 * 1409 * @param groupId the group ID 1410 * @param status the status 1411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1412 * @return the first matching message boards category 1413 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 1414 * @throws SystemException if a system exception occurred 1415 */ 1416 public static com.liferay.portlet.messageboards.model.MBCategory findByG_S_First( 1417 long groupId, int status, 1418 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1419 throws com.liferay.portal.kernel.exception.SystemException, 1420 com.liferay.portlet.messageboards.NoSuchCategoryException { 1421 return getPersistence() 1422 .findByG_S_First(groupId, status, orderByComparator); 1423 } 1424 1425 /** 1426 * Returns the first message boards category in the ordered set where groupId = ? and status = ?. 1427 * 1428 * @param groupId the group ID 1429 * @param status the status 1430 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1431 * @return the first matching message boards category, or <code>null</code> if a matching message boards category could not be found 1432 * @throws SystemException if a system exception occurred 1433 */ 1434 public static com.liferay.portlet.messageboards.model.MBCategory fetchByG_S_First( 1435 long groupId, int status, 1436 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1437 throws com.liferay.portal.kernel.exception.SystemException { 1438 return getPersistence() 1439 .fetchByG_S_First(groupId, status, orderByComparator); 1440 } 1441 1442 /** 1443 * Returns the last message boards category in the ordered set where groupId = ? and status = ?. 1444 * 1445 * @param groupId the group ID 1446 * @param status the status 1447 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1448 * @return the last matching message boards category 1449 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 1450 * @throws SystemException if a system exception occurred 1451 */ 1452 public static com.liferay.portlet.messageboards.model.MBCategory findByG_S_Last( 1453 long groupId, int status, 1454 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1455 throws com.liferay.portal.kernel.exception.SystemException, 1456 com.liferay.portlet.messageboards.NoSuchCategoryException { 1457 return getPersistence() 1458 .findByG_S_Last(groupId, status, orderByComparator); 1459 } 1460 1461 /** 1462 * Returns the last message boards category in the ordered set where groupId = ? and status = ?. 1463 * 1464 * @param groupId the group ID 1465 * @param status the status 1466 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1467 * @return the last matching message boards category, or <code>null</code> if a matching message boards category could not be found 1468 * @throws SystemException if a system exception occurred 1469 */ 1470 public static com.liferay.portlet.messageboards.model.MBCategory fetchByG_S_Last( 1471 long groupId, int status, 1472 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1473 throws com.liferay.portal.kernel.exception.SystemException { 1474 return getPersistence() 1475 .fetchByG_S_Last(groupId, status, orderByComparator); 1476 } 1477 1478 /** 1479 * Returns the message boards categories before and after the current message boards category in the ordered set where groupId = ? and status = ?. 1480 * 1481 * @param categoryId the primary key of the current message boards category 1482 * @param groupId the group ID 1483 * @param status the status 1484 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1485 * @return the previous, current, and next message boards category 1486 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 1487 * @throws SystemException if a system exception occurred 1488 */ 1489 public static com.liferay.portlet.messageboards.model.MBCategory[] findByG_S_PrevAndNext( 1490 long categoryId, long groupId, int status, 1491 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1492 throws com.liferay.portal.kernel.exception.SystemException, 1493 com.liferay.portlet.messageboards.NoSuchCategoryException { 1494 return getPersistence() 1495 .findByG_S_PrevAndNext(categoryId, groupId, status, 1496 orderByComparator); 1497 } 1498 1499 /** 1500 * Returns all the message boards categories that the user has permission to view where groupId = ? and status = ?. 1501 * 1502 * @param groupId the group ID 1503 * @param status the status 1504 * @return the matching message boards categories that the user has permission to view 1505 * @throws SystemException if a system exception occurred 1506 */ 1507 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_S( 1508 long groupId, int status) 1509 throws com.liferay.portal.kernel.exception.SystemException { 1510 return getPersistence().filterFindByG_S(groupId, status); 1511 } 1512 1513 /** 1514 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and status = ?. 1515 * 1516 * <p> 1517 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1518 * </p> 1519 * 1520 * @param groupId the group ID 1521 * @param status the status 1522 * @param start the lower bound of the range of message boards categories 1523 * @param end the upper bound of the range of message boards categories (not inclusive) 1524 * @return the range of matching message boards categories that the user has permission to view 1525 * @throws SystemException if a system exception occurred 1526 */ 1527 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_S( 1528 long groupId, int status, int start, int end) 1529 throws com.liferay.portal.kernel.exception.SystemException { 1530 return getPersistence().filterFindByG_S(groupId, status, start, end); 1531 } 1532 1533 /** 1534 * Returns an ordered range of all the message boards categories that the user has permissions to view where groupId = ? and status = ?. 1535 * 1536 * <p> 1537 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1538 * </p> 1539 * 1540 * @param groupId the group ID 1541 * @param status the status 1542 * @param start the lower bound of the range of message boards categories 1543 * @param end the upper bound of the range of message boards categories (not inclusive) 1544 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1545 * @return the ordered range of matching message boards categories that the user has permission to view 1546 * @throws SystemException if a system exception occurred 1547 */ 1548 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_S( 1549 long groupId, int status, int start, int end, 1550 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1551 throws com.liferay.portal.kernel.exception.SystemException { 1552 return getPersistence() 1553 .filterFindByG_S(groupId, status, start, end, 1554 orderByComparator); 1555 } 1556 1557 /** 1558 * Returns the message boards categories before and after the current message boards category in the ordered set of message boards categories that the user has permission to view where groupId = ? and status = ?. 1559 * 1560 * @param categoryId the primary key of the current message boards category 1561 * @param groupId the group ID 1562 * @param status the status 1563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1564 * @return the previous, current, and next message boards category 1565 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 1566 * @throws SystemException if a system exception occurred 1567 */ 1568 public static com.liferay.portlet.messageboards.model.MBCategory[] filterFindByG_S_PrevAndNext( 1569 long categoryId, long groupId, int status, 1570 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1571 throws com.liferay.portal.kernel.exception.SystemException, 1572 com.liferay.portlet.messageboards.NoSuchCategoryException { 1573 return getPersistence() 1574 .filterFindByG_S_PrevAndNext(categoryId, groupId, status, 1575 orderByComparator); 1576 } 1577 1578 /** 1579 * Removes all the message boards categories where groupId = ? and status = ? from the database. 1580 * 1581 * @param groupId the group ID 1582 * @param status the status 1583 * @throws SystemException if a system exception occurred 1584 */ 1585 public static void removeByG_S(long groupId, int status) 1586 throws com.liferay.portal.kernel.exception.SystemException { 1587 getPersistence().removeByG_S(groupId, status); 1588 } 1589 1590 /** 1591 * Returns the number of message boards categories where groupId = ? and status = ?. 1592 * 1593 * @param groupId the group ID 1594 * @param status the status 1595 * @return the number of matching message boards categories 1596 * @throws SystemException if a system exception occurred 1597 */ 1598 public static int countByG_S(long groupId, int status) 1599 throws com.liferay.portal.kernel.exception.SystemException { 1600 return getPersistence().countByG_S(groupId, status); 1601 } 1602 1603 /** 1604 * Returns the number of message boards categories that the user has permission to view where groupId = ? and status = ?. 1605 * 1606 * @param groupId the group ID 1607 * @param status the status 1608 * @return the number of matching message boards categories that the user has permission to view 1609 * @throws SystemException if a system exception occurred 1610 */ 1611 public static int filterCountByG_S(long groupId, int status) 1612 throws com.liferay.portal.kernel.exception.SystemException { 1613 return getPersistence().filterCountByG_S(groupId, status); 1614 } 1615 1616 /** 1617 * Returns all the message boards categories where companyId = ? and status = ?. 1618 * 1619 * @param companyId the company ID 1620 * @param status the status 1621 * @return the matching message boards categories 1622 * @throws SystemException if a system exception occurred 1623 */ 1624 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByC_S( 1625 long companyId, int status) 1626 throws com.liferay.portal.kernel.exception.SystemException { 1627 return getPersistence().findByC_S(companyId, status); 1628 } 1629 1630 /** 1631 * Returns a range of all the message boards categories where companyId = ? and status = ?. 1632 * 1633 * <p> 1634 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1635 * </p> 1636 * 1637 * @param companyId the company ID 1638 * @param status the status 1639 * @param start the lower bound of the range of message boards categories 1640 * @param end the upper bound of the range of message boards categories (not inclusive) 1641 * @return the range of matching message boards categories 1642 * @throws SystemException if a system exception occurred 1643 */ 1644 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByC_S( 1645 long companyId, int status, int start, int end) 1646 throws com.liferay.portal.kernel.exception.SystemException { 1647 return getPersistence().findByC_S(companyId, status, start, end); 1648 } 1649 1650 /** 1651 * Returns an ordered range of all the message boards categories where companyId = ? and status = ?. 1652 * 1653 * <p> 1654 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1655 * </p> 1656 * 1657 * @param companyId the company ID 1658 * @param status the status 1659 * @param start the lower bound of the range of message boards categories 1660 * @param end the upper bound of the range of message boards categories (not inclusive) 1661 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1662 * @return the ordered range of matching message boards categories 1663 * @throws SystemException if a system exception occurred 1664 */ 1665 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByC_S( 1666 long companyId, int status, int start, int end, 1667 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1668 throws com.liferay.portal.kernel.exception.SystemException { 1669 return getPersistence() 1670 .findByC_S(companyId, status, start, end, orderByComparator); 1671 } 1672 1673 /** 1674 * Returns the first message boards category in the ordered set where companyId = ? and status = ?. 1675 * 1676 * @param companyId the company ID 1677 * @param status the status 1678 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1679 * @return the first matching message boards category 1680 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 1681 * @throws SystemException if a system exception occurred 1682 */ 1683 public static com.liferay.portlet.messageboards.model.MBCategory findByC_S_First( 1684 long companyId, int status, 1685 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1686 throws com.liferay.portal.kernel.exception.SystemException, 1687 com.liferay.portlet.messageboards.NoSuchCategoryException { 1688 return getPersistence() 1689 .findByC_S_First(companyId, status, orderByComparator); 1690 } 1691 1692 /** 1693 * Returns the first message boards category in the ordered set where companyId = ? and status = ?. 1694 * 1695 * @param companyId the company ID 1696 * @param status the status 1697 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1698 * @return the first matching message boards category, or <code>null</code> if a matching message boards category could not be found 1699 * @throws SystemException if a system exception occurred 1700 */ 1701 public static com.liferay.portlet.messageboards.model.MBCategory fetchByC_S_First( 1702 long companyId, int status, 1703 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1704 throws com.liferay.portal.kernel.exception.SystemException { 1705 return getPersistence() 1706 .fetchByC_S_First(companyId, status, orderByComparator); 1707 } 1708 1709 /** 1710 * Returns the last message boards category in the ordered set where companyId = ? and status = ?. 1711 * 1712 * @param companyId the company ID 1713 * @param status the status 1714 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1715 * @return the last matching message boards category 1716 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 1717 * @throws SystemException if a system exception occurred 1718 */ 1719 public static com.liferay.portlet.messageboards.model.MBCategory findByC_S_Last( 1720 long companyId, int status, 1721 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1722 throws com.liferay.portal.kernel.exception.SystemException, 1723 com.liferay.portlet.messageboards.NoSuchCategoryException { 1724 return getPersistence() 1725 .findByC_S_Last(companyId, status, orderByComparator); 1726 } 1727 1728 /** 1729 * Returns the last message boards category in the ordered set where companyId = ? and status = ?. 1730 * 1731 * @param companyId the company ID 1732 * @param status the status 1733 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1734 * @return the last matching message boards category, or <code>null</code> if a matching message boards category could not be found 1735 * @throws SystemException if a system exception occurred 1736 */ 1737 public static com.liferay.portlet.messageboards.model.MBCategory fetchByC_S_Last( 1738 long companyId, int status, 1739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1740 throws com.liferay.portal.kernel.exception.SystemException { 1741 return getPersistence() 1742 .fetchByC_S_Last(companyId, status, orderByComparator); 1743 } 1744 1745 /** 1746 * Returns the message boards categories before and after the current message boards category in the ordered set where companyId = ? and status = ?. 1747 * 1748 * @param categoryId the primary key of the current message boards category 1749 * @param companyId the company ID 1750 * @param status the status 1751 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1752 * @return the previous, current, and next message boards category 1753 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 1754 * @throws SystemException if a system exception occurred 1755 */ 1756 public static com.liferay.portlet.messageboards.model.MBCategory[] findByC_S_PrevAndNext( 1757 long categoryId, long companyId, int status, 1758 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1759 throws com.liferay.portal.kernel.exception.SystemException, 1760 com.liferay.portlet.messageboards.NoSuchCategoryException { 1761 return getPersistence() 1762 .findByC_S_PrevAndNext(categoryId, companyId, status, 1763 orderByComparator); 1764 } 1765 1766 /** 1767 * Removes all the message boards categories where companyId = ? and status = ? from the database. 1768 * 1769 * @param companyId the company ID 1770 * @param status the status 1771 * @throws SystemException if a system exception occurred 1772 */ 1773 public static void removeByC_S(long companyId, int status) 1774 throws com.liferay.portal.kernel.exception.SystemException { 1775 getPersistence().removeByC_S(companyId, status); 1776 } 1777 1778 /** 1779 * Returns the number of message boards categories where companyId = ? and status = ?. 1780 * 1781 * @param companyId the company ID 1782 * @param status the status 1783 * @return the number of matching message boards categories 1784 * @throws SystemException if a system exception occurred 1785 */ 1786 public static int countByC_S(long companyId, int status) 1787 throws com.liferay.portal.kernel.exception.SystemException { 1788 return getPersistence().countByC_S(companyId, status); 1789 } 1790 1791 /** 1792 * Returns all the message boards categories where groupId = ? and parentCategoryId = ? and status = ?. 1793 * 1794 * @param groupId the group ID 1795 * @param parentCategoryId the parent category ID 1796 * @param status the status 1797 * @return the matching message boards categories 1798 * @throws SystemException if a system exception occurred 1799 */ 1800 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P_S( 1801 long groupId, long parentCategoryId, int status) 1802 throws com.liferay.portal.kernel.exception.SystemException { 1803 return getPersistence().findByG_P_S(groupId, parentCategoryId, status); 1804 } 1805 1806 /** 1807 * Returns a range of all the message boards categories where groupId = ? and parentCategoryId = ? and status = ?. 1808 * 1809 * <p> 1810 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1811 * </p> 1812 * 1813 * @param groupId the group ID 1814 * @param parentCategoryId the parent category ID 1815 * @param status the status 1816 * @param start the lower bound of the range of message boards categories 1817 * @param end the upper bound of the range of message boards categories (not inclusive) 1818 * @return the range of matching message boards categories 1819 * @throws SystemException if a system exception occurred 1820 */ 1821 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P_S( 1822 long groupId, long parentCategoryId, int status, int start, int end) 1823 throws com.liferay.portal.kernel.exception.SystemException { 1824 return getPersistence() 1825 .findByG_P_S(groupId, parentCategoryId, status, start, end); 1826 } 1827 1828 /** 1829 * Returns an ordered range of all the message boards categories where groupId = ? and parentCategoryId = ? and status = ?. 1830 * 1831 * <p> 1832 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1833 * </p> 1834 * 1835 * @param groupId the group ID 1836 * @param parentCategoryId the parent category ID 1837 * @param status the status 1838 * @param start the lower bound of the range of message boards categories 1839 * @param end the upper bound of the range of message boards categories (not inclusive) 1840 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1841 * @return the ordered range of matching message boards categories 1842 * @throws SystemException if a system exception occurred 1843 */ 1844 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P_S( 1845 long groupId, long parentCategoryId, int status, int start, int end, 1846 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1847 throws com.liferay.portal.kernel.exception.SystemException { 1848 return getPersistence() 1849 .findByG_P_S(groupId, parentCategoryId, status, start, end, 1850 orderByComparator); 1851 } 1852 1853 /** 1854 * Returns the first message boards category in the ordered set where groupId = ? and parentCategoryId = ? and status = ?. 1855 * 1856 * @param groupId the group ID 1857 * @param parentCategoryId the parent category ID 1858 * @param status the status 1859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1860 * @return the first matching message boards category 1861 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 1862 * @throws SystemException if a system exception occurred 1863 */ 1864 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_S_First( 1865 long groupId, long parentCategoryId, int status, 1866 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1867 throws com.liferay.portal.kernel.exception.SystemException, 1868 com.liferay.portlet.messageboards.NoSuchCategoryException { 1869 return getPersistence() 1870 .findByG_P_S_First(groupId, parentCategoryId, status, 1871 orderByComparator); 1872 } 1873 1874 /** 1875 * Returns the first message boards category in the ordered set where groupId = ? and parentCategoryId = ? and status = ?. 1876 * 1877 * @param groupId the group ID 1878 * @param parentCategoryId the parent category ID 1879 * @param status the status 1880 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1881 * @return the first matching message boards category, or <code>null</code> if a matching message boards category could not be found 1882 * @throws SystemException if a system exception occurred 1883 */ 1884 public static com.liferay.portlet.messageboards.model.MBCategory fetchByG_P_S_First( 1885 long groupId, long parentCategoryId, int status, 1886 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1887 throws com.liferay.portal.kernel.exception.SystemException { 1888 return getPersistence() 1889 .fetchByG_P_S_First(groupId, parentCategoryId, status, 1890 orderByComparator); 1891 } 1892 1893 /** 1894 * Returns the last message boards category in the ordered set where groupId = ? and parentCategoryId = ? and status = ?. 1895 * 1896 * @param groupId the group ID 1897 * @param parentCategoryId the parent category ID 1898 * @param status the status 1899 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1900 * @return the last matching message boards category 1901 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a matching message boards category could not be found 1902 * @throws SystemException if a system exception occurred 1903 */ 1904 public static com.liferay.portlet.messageboards.model.MBCategory findByG_P_S_Last( 1905 long groupId, long parentCategoryId, int status, 1906 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1907 throws com.liferay.portal.kernel.exception.SystemException, 1908 com.liferay.portlet.messageboards.NoSuchCategoryException { 1909 return getPersistence() 1910 .findByG_P_S_Last(groupId, parentCategoryId, status, 1911 orderByComparator); 1912 } 1913 1914 /** 1915 * Returns the last message boards category in the ordered set where groupId = ? and parentCategoryId = ? and status = ?. 1916 * 1917 * @param groupId the group ID 1918 * @param parentCategoryId the parent category ID 1919 * @param status the status 1920 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1921 * @return the last matching message boards category, or <code>null</code> if a matching message boards category could not be found 1922 * @throws SystemException if a system exception occurred 1923 */ 1924 public static com.liferay.portlet.messageboards.model.MBCategory fetchByG_P_S_Last( 1925 long groupId, long parentCategoryId, int status, 1926 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1927 throws com.liferay.portal.kernel.exception.SystemException { 1928 return getPersistence() 1929 .fetchByG_P_S_Last(groupId, parentCategoryId, status, 1930 orderByComparator); 1931 } 1932 1933 /** 1934 * Returns the message boards categories before and after the current message boards category in the ordered set where groupId = ? and parentCategoryId = ? and status = ?. 1935 * 1936 * @param categoryId the primary key of the current message boards category 1937 * @param groupId the group ID 1938 * @param parentCategoryId the parent category ID 1939 * @param status the status 1940 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1941 * @return the previous, current, and next message boards category 1942 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 1943 * @throws SystemException if a system exception occurred 1944 */ 1945 public static com.liferay.portlet.messageboards.model.MBCategory[] findByG_P_S_PrevAndNext( 1946 long categoryId, long groupId, long parentCategoryId, int status, 1947 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1948 throws com.liferay.portal.kernel.exception.SystemException, 1949 com.liferay.portlet.messageboards.NoSuchCategoryException { 1950 return getPersistence() 1951 .findByG_P_S_PrevAndNext(categoryId, groupId, 1952 parentCategoryId, status, orderByComparator); 1953 } 1954 1955 /** 1956 * Returns all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ? and status = ?. 1957 * 1958 * @param groupId the group ID 1959 * @param parentCategoryId the parent category ID 1960 * @param status the status 1961 * @return the matching message boards categories that the user has permission to view 1962 * @throws SystemException if a system exception occurred 1963 */ 1964 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P_S( 1965 long groupId, long parentCategoryId, int status) 1966 throws com.liferay.portal.kernel.exception.SystemException { 1967 return getPersistence() 1968 .filterFindByG_P_S(groupId, parentCategoryId, status); 1969 } 1970 1971 /** 1972 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ? and status = ?. 1973 * 1974 * <p> 1975 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1976 * </p> 1977 * 1978 * @param groupId the group ID 1979 * @param parentCategoryId the parent category ID 1980 * @param status the status 1981 * @param start the lower bound of the range of message boards categories 1982 * @param end the upper bound of the range of message boards categories (not inclusive) 1983 * @return the range of matching message boards categories that the user has permission to view 1984 * @throws SystemException if a system exception occurred 1985 */ 1986 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P_S( 1987 long groupId, long parentCategoryId, int status, int start, int end) 1988 throws com.liferay.portal.kernel.exception.SystemException { 1989 return getPersistence() 1990 .filterFindByG_P_S(groupId, parentCategoryId, status, start, 1991 end); 1992 } 1993 1994 /** 1995 * Returns an ordered range of all the message boards categories that the user has permissions to view where groupId = ? and parentCategoryId = ? and status = ?. 1996 * 1997 * <p> 1998 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 1999 * </p> 2000 * 2001 * @param groupId the group ID 2002 * @param parentCategoryId the parent category ID 2003 * @param status the status 2004 * @param start the lower bound of the range of message boards categories 2005 * @param end the upper bound of the range of message boards categories (not inclusive) 2006 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2007 * @return the ordered range of matching message boards categories that the user has permission to view 2008 * @throws SystemException if a system exception occurred 2009 */ 2010 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P_S( 2011 long groupId, long parentCategoryId, int status, int start, int end, 2012 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2013 throws com.liferay.portal.kernel.exception.SystemException { 2014 return getPersistence() 2015 .filterFindByG_P_S(groupId, parentCategoryId, status, start, 2016 end, orderByComparator); 2017 } 2018 2019 /** 2020 * Returns the message boards categories before and after the current message boards category in the ordered set of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ? and status = ?. 2021 * 2022 * @param categoryId the primary key of the current message boards category 2023 * @param groupId the group ID 2024 * @param parentCategoryId the parent category ID 2025 * @param status the status 2026 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2027 * @return the previous, current, and next message boards category 2028 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 2029 * @throws SystemException if a system exception occurred 2030 */ 2031 public static com.liferay.portlet.messageboards.model.MBCategory[] filterFindByG_P_S_PrevAndNext( 2032 long categoryId, long groupId, long parentCategoryId, int status, 2033 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2034 throws com.liferay.portal.kernel.exception.SystemException, 2035 com.liferay.portlet.messageboards.NoSuchCategoryException { 2036 return getPersistence() 2037 .filterFindByG_P_S_PrevAndNext(categoryId, groupId, 2038 parentCategoryId, status, orderByComparator); 2039 } 2040 2041 /** 2042 * Returns all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ? and status = ?. 2043 * 2044 * @param groupId the group ID 2045 * @param parentCategoryIds the parent category IDs 2046 * @param status the status 2047 * @return the matching message boards categories that the user has permission to view 2048 * @throws SystemException if a system exception occurred 2049 */ 2050 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P_S( 2051 long groupId, long[] parentCategoryIds, int status) 2052 throws com.liferay.portal.kernel.exception.SystemException { 2053 return getPersistence() 2054 .filterFindByG_P_S(groupId, parentCategoryIds, status); 2055 } 2056 2057 /** 2058 * Returns a range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ? and status = ?. 2059 * 2060 * <p> 2061 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 2062 * </p> 2063 * 2064 * @param groupId the group ID 2065 * @param parentCategoryIds the parent category IDs 2066 * @param status the status 2067 * @param start the lower bound of the range of message boards categories 2068 * @param end the upper bound of the range of message boards categories (not inclusive) 2069 * @return the range of matching message boards categories that the user has permission to view 2070 * @throws SystemException if a system exception occurred 2071 */ 2072 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P_S( 2073 long groupId, long[] parentCategoryIds, int status, int start, int end) 2074 throws com.liferay.portal.kernel.exception.SystemException { 2075 return getPersistence() 2076 .filterFindByG_P_S(groupId, parentCategoryIds, status, 2077 start, end); 2078 } 2079 2080 /** 2081 * Returns an ordered range of all the message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ? and status = ?. 2082 * 2083 * <p> 2084 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 2085 * </p> 2086 * 2087 * @param groupId the group ID 2088 * @param parentCategoryIds the parent category IDs 2089 * @param status the status 2090 * @param start the lower bound of the range of message boards categories 2091 * @param end the upper bound of the range of message boards categories (not inclusive) 2092 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2093 * @return the ordered range of matching message boards categories that the user has permission to view 2094 * @throws SystemException if a system exception occurred 2095 */ 2096 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> filterFindByG_P_S( 2097 long groupId, long[] parentCategoryIds, int status, int start, int end, 2098 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2099 throws com.liferay.portal.kernel.exception.SystemException { 2100 return getPersistence() 2101 .filterFindByG_P_S(groupId, parentCategoryIds, status, 2102 start, end, orderByComparator); 2103 } 2104 2105 /** 2106 * Returns all the message boards categories where groupId = ? and parentCategoryId = any ? and status = ?. 2107 * 2108 * <p> 2109 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 2110 * </p> 2111 * 2112 * @param groupId the group ID 2113 * @param parentCategoryIds the parent category IDs 2114 * @param status the status 2115 * @return the matching message boards categories 2116 * @throws SystemException if a system exception occurred 2117 */ 2118 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P_S( 2119 long groupId, long[] parentCategoryIds, int status) 2120 throws com.liferay.portal.kernel.exception.SystemException { 2121 return getPersistence().findByG_P_S(groupId, parentCategoryIds, status); 2122 } 2123 2124 /** 2125 * Returns a range of all the message boards categories where groupId = ? and parentCategoryId = any ? and status = ?. 2126 * 2127 * <p> 2128 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 2129 * </p> 2130 * 2131 * @param groupId the group ID 2132 * @param parentCategoryIds the parent category IDs 2133 * @param status the status 2134 * @param start the lower bound of the range of message boards categories 2135 * @param end the upper bound of the range of message boards categories (not inclusive) 2136 * @return the range of matching message boards categories 2137 * @throws SystemException if a system exception occurred 2138 */ 2139 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P_S( 2140 long groupId, long[] parentCategoryIds, int status, int start, int end) 2141 throws com.liferay.portal.kernel.exception.SystemException { 2142 return getPersistence() 2143 .findByG_P_S(groupId, parentCategoryIds, status, start, end); 2144 } 2145 2146 /** 2147 * Returns an ordered range of all the message boards categories where groupId = ? and parentCategoryId = any ? and status = ?. 2148 * 2149 * <p> 2150 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 2151 * </p> 2152 * 2153 * @param groupId the group ID 2154 * @param parentCategoryIds the parent category IDs 2155 * @param status the status 2156 * @param start the lower bound of the range of message boards categories 2157 * @param end the upper bound of the range of message boards categories (not inclusive) 2158 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2159 * @return the ordered range of matching message boards categories 2160 * @throws SystemException if a system exception occurred 2161 */ 2162 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findByG_P_S( 2163 long groupId, long[] parentCategoryIds, int status, int start, int end, 2164 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2165 throws com.liferay.portal.kernel.exception.SystemException { 2166 return getPersistence() 2167 .findByG_P_S(groupId, parentCategoryIds, status, start, end, 2168 orderByComparator); 2169 } 2170 2171 /** 2172 * Removes all the message boards categories where groupId = ? and parentCategoryId = ? and status = ? from the database. 2173 * 2174 * @param groupId the group ID 2175 * @param parentCategoryId the parent category ID 2176 * @param status the status 2177 * @throws SystemException if a system exception occurred 2178 */ 2179 public static void removeByG_P_S(long groupId, long parentCategoryId, 2180 int status) throws com.liferay.portal.kernel.exception.SystemException { 2181 getPersistence().removeByG_P_S(groupId, parentCategoryId, status); 2182 } 2183 2184 /** 2185 * Returns the number of message boards categories where groupId = ? and parentCategoryId = ? and status = ?. 2186 * 2187 * @param groupId the group ID 2188 * @param parentCategoryId the parent category ID 2189 * @param status the status 2190 * @return the number of matching message boards categories 2191 * @throws SystemException if a system exception occurred 2192 */ 2193 public static int countByG_P_S(long groupId, long parentCategoryId, 2194 int status) throws com.liferay.portal.kernel.exception.SystemException { 2195 return getPersistence().countByG_P_S(groupId, parentCategoryId, status); 2196 } 2197 2198 /** 2199 * Returns the number of message boards categories where groupId = ? and parentCategoryId = any ? and status = ?. 2200 * 2201 * @param groupId the group ID 2202 * @param parentCategoryIds the parent category IDs 2203 * @param status the status 2204 * @return the number of matching message boards categories 2205 * @throws SystemException if a system exception occurred 2206 */ 2207 public static int countByG_P_S(long groupId, long[] parentCategoryIds, 2208 int status) throws com.liferay.portal.kernel.exception.SystemException { 2209 return getPersistence().countByG_P_S(groupId, parentCategoryIds, status); 2210 } 2211 2212 /** 2213 * Returns the number of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = ? and status = ?. 2214 * 2215 * @param groupId the group ID 2216 * @param parentCategoryId the parent category ID 2217 * @param status the status 2218 * @return the number of matching message boards categories that the user has permission to view 2219 * @throws SystemException if a system exception occurred 2220 */ 2221 public static int filterCountByG_P_S(long groupId, long parentCategoryId, 2222 int status) throws com.liferay.portal.kernel.exception.SystemException { 2223 return getPersistence() 2224 .filterCountByG_P_S(groupId, parentCategoryId, status); 2225 } 2226 2227 /** 2228 * Returns the number of message boards categories that the user has permission to view where groupId = ? and parentCategoryId = any ? and status = ?. 2229 * 2230 * @param groupId the group ID 2231 * @param parentCategoryIds the parent category IDs 2232 * @param status the status 2233 * @return the number of matching message boards categories that the user has permission to view 2234 * @throws SystemException if a system exception occurred 2235 */ 2236 public static int filterCountByG_P_S(long groupId, 2237 long[] parentCategoryIds, int status) 2238 throws com.liferay.portal.kernel.exception.SystemException { 2239 return getPersistence() 2240 .filterCountByG_P_S(groupId, parentCategoryIds, status); 2241 } 2242 2243 /** 2244 * Caches the message boards category in the entity cache if it is enabled. 2245 * 2246 * @param mbCategory the message boards category 2247 */ 2248 public static void cacheResult( 2249 com.liferay.portlet.messageboards.model.MBCategory mbCategory) { 2250 getPersistence().cacheResult(mbCategory); 2251 } 2252 2253 /** 2254 * Caches the message boards categories in the entity cache if it is enabled. 2255 * 2256 * @param mbCategories the message boards categories 2257 */ 2258 public static void cacheResult( 2259 java.util.List<com.liferay.portlet.messageboards.model.MBCategory> mbCategories) { 2260 getPersistence().cacheResult(mbCategories); 2261 } 2262 2263 /** 2264 * Creates a new message boards category with the primary key. Does not add the message boards category to the database. 2265 * 2266 * @param categoryId the primary key for the new message boards category 2267 * @return the new message boards category 2268 */ 2269 public static com.liferay.portlet.messageboards.model.MBCategory create( 2270 long categoryId) { 2271 return getPersistence().create(categoryId); 2272 } 2273 2274 /** 2275 * Removes the message boards category with the primary key from the database. Also notifies the appropriate model listeners. 2276 * 2277 * @param categoryId the primary key of the message boards category 2278 * @return the message boards category that was removed 2279 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 2280 * @throws SystemException if a system exception occurred 2281 */ 2282 public static com.liferay.portlet.messageboards.model.MBCategory remove( 2283 long categoryId) 2284 throws com.liferay.portal.kernel.exception.SystemException, 2285 com.liferay.portlet.messageboards.NoSuchCategoryException { 2286 return getPersistence().remove(categoryId); 2287 } 2288 2289 public static com.liferay.portlet.messageboards.model.MBCategory updateImpl( 2290 com.liferay.portlet.messageboards.model.MBCategory mbCategory) 2291 throws com.liferay.portal.kernel.exception.SystemException { 2292 return getPersistence().updateImpl(mbCategory); 2293 } 2294 2295 /** 2296 * Returns the message boards category with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchCategoryException} if it could not be found. 2297 * 2298 * @param categoryId the primary key of the message boards category 2299 * @return the message boards category 2300 * @throws com.liferay.portlet.messageboards.NoSuchCategoryException if a message boards category with the primary key could not be found 2301 * @throws SystemException if a system exception occurred 2302 */ 2303 public static com.liferay.portlet.messageboards.model.MBCategory findByPrimaryKey( 2304 long categoryId) 2305 throws com.liferay.portal.kernel.exception.SystemException, 2306 com.liferay.portlet.messageboards.NoSuchCategoryException { 2307 return getPersistence().findByPrimaryKey(categoryId); 2308 } 2309 2310 /** 2311 * Returns the message boards category with the primary key or returns <code>null</code> if it could not be found. 2312 * 2313 * @param categoryId the primary key of the message boards category 2314 * @return the message boards category, or <code>null</code> if a message boards category with the primary key could not be found 2315 * @throws SystemException if a system exception occurred 2316 */ 2317 public static com.liferay.portlet.messageboards.model.MBCategory fetchByPrimaryKey( 2318 long categoryId) 2319 throws com.liferay.portal.kernel.exception.SystemException { 2320 return getPersistence().fetchByPrimaryKey(categoryId); 2321 } 2322 2323 /** 2324 * Returns all the message boards categories. 2325 * 2326 * @return the message boards categories 2327 * @throws SystemException if a system exception occurred 2328 */ 2329 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll() 2330 throws com.liferay.portal.kernel.exception.SystemException { 2331 return getPersistence().findAll(); 2332 } 2333 2334 /** 2335 * Returns a range of all the message boards categories. 2336 * 2337 * <p> 2338 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 2339 * </p> 2340 * 2341 * @param start the lower bound of the range of message boards categories 2342 * @param end the upper bound of the range of message boards categories (not inclusive) 2343 * @return the range of message boards categories 2344 * @throws SystemException if a system exception occurred 2345 */ 2346 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 2347 int start, int end) 2348 throws com.liferay.portal.kernel.exception.SystemException { 2349 return getPersistence().findAll(start, end); 2350 } 2351 2352 /** 2353 * Returns an ordered range of all the message boards categories. 2354 * 2355 * <p> 2356 * 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.messageboards.model.impl.MBCategoryModelImpl}. 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. 2357 * </p> 2358 * 2359 * @param start the lower bound of the range of message boards categories 2360 * @param end the upper bound of the range of message boards categories (not inclusive) 2361 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2362 * @return the ordered range of message boards categories 2363 * @throws SystemException if a system exception occurred 2364 */ 2365 public static java.util.List<com.liferay.portlet.messageboards.model.MBCategory> findAll( 2366 int start, int end, 2367 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2368 throws com.liferay.portal.kernel.exception.SystemException { 2369 return getPersistence().findAll(start, end, orderByComparator); 2370 } 2371 2372 /** 2373 * Removes all the message boards categories from the database. 2374 * 2375 * @throws SystemException if a system exception occurred 2376 */ 2377 public static void removeAll() 2378 throws com.liferay.portal.kernel.exception.SystemException { 2379 getPersistence().removeAll(); 2380 } 2381 2382 /** 2383 * Returns the number of message boards categories. 2384 * 2385 * @return the number of message boards categories 2386 * @throws SystemException if a system exception occurred 2387 */ 2388 public static int countAll() 2389 throws com.liferay.portal.kernel.exception.SystemException { 2390 return getPersistence().countAll(); 2391 } 2392 2393 public static MBCategoryPersistence getPersistence() { 2394 if (_persistence == null) { 2395 _persistence = (MBCategoryPersistence)PortalBeanLocatorUtil.locate(MBCategoryPersistence.class.getName()); 2396 2397 ReferenceRegistry.registerReference(MBCategoryUtil.class, 2398 "_persistence"); 2399 } 2400 2401 return _persistence; 2402 } 2403 2404 /** 2405 * @deprecated As of 6.2.0 2406 */ 2407 public void setPersistence(MBCategoryPersistence persistence) { 2408 } 2409 2410 private static MBCategoryPersistence _persistence; 2411 }