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