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