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