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