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