001 /** 002 * Copyright (c) 2000-2010 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 com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.service.ServiceContext; 022 023 import com.liferay.portlet.messageboards.model.MBMessage; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the message-boards message service. 029 * 030 * <p> 031 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class. 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see MBMessagePersistence 036 * @see MBMessagePersistenceImpl 037 * @generated 038 */ 039 public class MBMessageUtil { 040 /** 041 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 042 */ 043 public static void clearCache() { 044 getPersistence().clearCache(); 045 } 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 049 */ 050 public static void clearCache(MBMessage mbMessage) { 051 getPersistence().clearCache(mbMessage); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 056 */ 057 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 058 throws SystemException { 059 return getPersistence().countWithDynamicQuery(dynamicQuery); 060 } 061 062 /** 063 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 064 */ 065 public static List<MBMessage> findWithDynamicQuery( 066 DynamicQuery dynamicQuery) throws SystemException { 067 return getPersistence().findWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 072 */ 073 public static List<MBMessage> findWithDynamicQuery( 074 DynamicQuery dynamicQuery, int start, int end) 075 throws SystemException { 076 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 081 */ 082 public static List<MBMessage> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end, 084 OrderByComparator orderByComparator) throws SystemException { 085 return getPersistence() 086 .findWithDynamicQuery(dynamicQuery, start, end, 087 orderByComparator); 088 } 089 090 /** 091 * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel) 092 */ 093 public static MBMessage remove(MBMessage mbMessage) 094 throws SystemException { 095 return getPersistence().remove(mbMessage); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 100 */ 101 public static MBMessage update(MBMessage mbMessage, boolean merge) 102 throws SystemException { 103 return getPersistence().update(mbMessage, merge); 104 } 105 106 /** 107 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 108 */ 109 public static MBMessage update(MBMessage mbMessage, boolean merge, 110 ServiceContext serviceContext) throws SystemException { 111 return getPersistence().update(mbMessage, merge, serviceContext); 112 } 113 114 /** 115 * Caches the message-boards message in the entity cache if it is enabled. 116 * 117 * @param mbMessage the message-boards message to cache 118 */ 119 public static void cacheResult( 120 com.liferay.portlet.messageboards.model.MBMessage mbMessage) { 121 getPersistence().cacheResult(mbMessage); 122 } 123 124 /** 125 * Caches the message-boards messages in the entity cache if it is enabled. 126 * 127 * @param mbMessages the message-boards messages to cache 128 */ 129 public static void cacheResult( 130 java.util.List<com.liferay.portlet.messageboards.model.MBMessage> mbMessages) { 131 getPersistence().cacheResult(mbMessages); 132 } 133 134 /** 135 * Creates a new message-boards message with the primary key. 136 * 137 * @param messageId the primary key for the new message-boards message 138 * @return the new message-boards message 139 */ 140 public static com.liferay.portlet.messageboards.model.MBMessage create( 141 long messageId) { 142 return getPersistence().create(messageId); 143 } 144 145 /** 146 * Removes the message-boards message with the primary key from the database. Also notifies the appropriate model listeners. 147 * 148 * @param messageId the primary key of the message-boards message to remove 149 * @return the message-boards message that was removed 150 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 151 * @throws SystemException if a system exception occurred 152 */ 153 public static com.liferay.portlet.messageboards.model.MBMessage remove( 154 long messageId) 155 throws com.liferay.portal.kernel.exception.SystemException, 156 com.liferay.portlet.messageboards.NoSuchMessageException { 157 return getPersistence().remove(messageId); 158 } 159 160 public static com.liferay.portlet.messageboards.model.MBMessage updateImpl( 161 com.liferay.portlet.messageboards.model.MBMessage mbMessage, 162 boolean merge) 163 throws com.liferay.portal.kernel.exception.SystemException { 164 return getPersistence().updateImpl(mbMessage, merge); 165 } 166 167 /** 168 * Finds the message-boards message with the primary key or throws a {@link com.liferay.portlet.messageboards.NoSuchMessageException} if it could not be found. 169 * 170 * @param messageId the primary key of the message-boards message to find 171 * @return the message-boards message 172 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.messageboards.model.MBMessage findByPrimaryKey( 176 long messageId) 177 throws com.liferay.portal.kernel.exception.SystemException, 178 com.liferay.portlet.messageboards.NoSuchMessageException { 179 return getPersistence().findByPrimaryKey(messageId); 180 } 181 182 /** 183 * Finds the message-boards message with the primary key or returns <code>null</code> if it could not be found. 184 * 185 * @param messageId the primary key of the message-boards message to find 186 * @return the message-boards message, or <code>null</code> if a message-boards message with the primary key could not be found 187 * @throws SystemException if a system exception occurred 188 */ 189 public static com.liferay.portlet.messageboards.model.MBMessage fetchByPrimaryKey( 190 long messageId) 191 throws com.liferay.portal.kernel.exception.SystemException { 192 return getPersistence().fetchByPrimaryKey(messageId); 193 } 194 195 /** 196 * Finds all the message-boards messages where uuid = ?. 197 * 198 * @param uuid the uuid to search with 199 * @return the matching message-boards messages 200 * @throws SystemException if a system exception occurred 201 */ 202 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid( 203 java.lang.String uuid) 204 throws com.liferay.portal.kernel.exception.SystemException { 205 return getPersistence().findByUuid(uuid); 206 } 207 208 /** 209 * Finds a range of all the message-boards messages where uuid = ?. 210 * 211 * <p> 212 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 213 * </p> 214 * 215 * @param uuid the uuid to search with 216 * @param start the lower bound of the range of message-boards messages to return 217 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 218 * @return the range of matching message-boards messages 219 * @throws SystemException if a system exception occurred 220 */ 221 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid( 222 java.lang.String uuid, int start, int end) 223 throws com.liferay.portal.kernel.exception.SystemException { 224 return getPersistence().findByUuid(uuid, start, end); 225 } 226 227 /** 228 * Finds an ordered range of all the message-boards messages where uuid = ?. 229 * 230 * <p> 231 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 232 * </p> 233 * 234 * @param uuid the uuid to search with 235 * @param start the lower bound of the range of message-boards messages to return 236 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 237 * @param orderByComparator the comparator to order the results by 238 * @return the ordered range of matching message-boards messages 239 * @throws SystemException if a system exception occurred 240 */ 241 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUuid( 242 java.lang.String uuid, int start, int end, 243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 244 throws com.liferay.portal.kernel.exception.SystemException { 245 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 246 } 247 248 /** 249 * Finds the first message-boards message in the ordered set where uuid = ?. 250 * 251 * <p> 252 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 253 * </p> 254 * 255 * @param uuid the uuid to search with 256 * @param orderByComparator the comparator to order the set by 257 * @return the first matching message-boards message 258 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 259 * @throws SystemException if a system exception occurred 260 */ 261 public static com.liferay.portlet.messageboards.model.MBMessage findByUuid_First( 262 java.lang.String uuid, 263 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 264 throws com.liferay.portal.kernel.exception.SystemException, 265 com.liferay.portlet.messageboards.NoSuchMessageException { 266 return getPersistence().findByUuid_First(uuid, orderByComparator); 267 } 268 269 /** 270 * Finds the last message-boards message in the ordered set where uuid = ?. 271 * 272 * <p> 273 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 274 * </p> 275 * 276 * @param uuid the uuid to search with 277 * @param orderByComparator the comparator to order the set by 278 * @return the last matching message-boards message 279 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 280 * @throws SystemException if a system exception occurred 281 */ 282 public static com.liferay.portlet.messageboards.model.MBMessage findByUuid_Last( 283 java.lang.String uuid, 284 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 285 throws com.liferay.portal.kernel.exception.SystemException, 286 com.liferay.portlet.messageboards.NoSuchMessageException { 287 return getPersistence().findByUuid_Last(uuid, orderByComparator); 288 } 289 290 /** 291 * Finds the message-boards messages before and after the current message-boards message in the ordered set where uuid = ?. 292 * 293 * <p> 294 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 295 * </p> 296 * 297 * @param messageId the primary key of the current message-boards message 298 * @param uuid the uuid to search with 299 * @param orderByComparator the comparator to order the set by 300 * @return the previous, current, and next message-boards message 301 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 302 * @throws SystemException if a system exception occurred 303 */ 304 public static com.liferay.portlet.messageboards.model.MBMessage[] findByUuid_PrevAndNext( 305 long messageId, java.lang.String uuid, 306 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 307 throws com.liferay.portal.kernel.exception.SystemException, 308 com.liferay.portlet.messageboards.NoSuchMessageException { 309 return getPersistence() 310 .findByUuid_PrevAndNext(messageId, uuid, orderByComparator); 311 } 312 313 /** 314 * Finds the message-boards message where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.messageboards.NoSuchMessageException} if it could not be found. 315 * 316 * @param uuid the uuid to search with 317 * @param groupId the group id to search with 318 * @return the matching message-boards message 319 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 320 * @throws SystemException if a system exception occurred 321 */ 322 public static com.liferay.portlet.messageboards.model.MBMessage findByUUID_G( 323 java.lang.String uuid, long groupId) 324 throws com.liferay.portal.kernel.exception.SystemException, 325 com.liferay.portlet.messageboards.NoSuchMessageException { 326 return getPersistence().findByUUID_G(uuid, groupId); 327 } 328 329 /** 330 * Finds the message-boards message where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 331 * 332 * @param uuid the uuid to search with 333 * @param groupId the group id to search with 334 * @return the matching message-boards message, or <code>null</code> if a matching message-boards message could not be found 335 * @throws SystemException if a system exception occurred 336 */ 337 public static com.liferay.portlet.messageboards.model.MBMessage fetchByUUID_G( 338 java.lang.String uuid, long groupId) 339 throws com.liferay.portal.kernel.exception.SystemException { 340 return getPersistence().fetchByUUID_G(uuid, groupId); 341 } 342 343 /** 344 * Finds the message-boards message where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 345 * 346 * @param uuid the uuid to search with 347 * @param groupId the group id to search with 348 * @return the matching message-boards message, or <code>null</code> if a matching message-boards message could not be found 349 * @throws SystemException if a system exception occurred 350 */ 351 public static com.liferay.portlet.messageboards.model.MBMessage fetchByUUID_G( 352 java.lang.String uuid, long groupId, boolean retrieveFromCache) 353 throws com.liferay.portal.kernel.exception.SystemException { 354 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 355 } 356 357 /** 358 * Finds all the message-boards messages where groupId = ?. 359 * 360 * @param groupId the group id to search with 361 * @return the matching message-boards messages 362 * @throws SystemException if a system exception occurred 363 */ 364 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId( 365 long groupId) 366 throws com.liferay.portal.kernel.exception.SystemException { 367 return getPersistence().findByGroupId(groupId); 368 } 369 370 /** 371 * Finds a range of all the message-boards messages where groupId = ?. 372 * 373 * <p> 374 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 375 * </p> 376 * 377 * @param groupId the group id to search with 378 * @param start the lower bound of the range of message-boards messages to return 379 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 380 * @return the range of matching message-boards messages 381 * @throws SystemException if a system exception occurred 382 */ 383 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId( 384 long groupId, int start, int end) 385 throws com.liferay.portal.kernel.exception.SystemException { 386 return getPersistence().findByGroupId(groupId, start, end); 387 } 388 389 /** 390 * Finds an ordered range of all the message-boards messages where groupId = ?. 391 * 392 * <p> 393 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 394 * </p> 395 * 396 * @param groupId the group id to search with 397 * @param start the lower bound of the range of message-boards messages to return 398 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 399 * @param orderByComparator the comparator to order the results by 400 * @return the ordered range of matching message-boards messages 401 * @throws SystemException if a system exception occurred 402 */ 403 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByGroupId( 404 long groupId, int start, int end, 405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 406 throws com.liferay.portal.kernel.exception.SystemException { 407 return getPersistence() 408 .findByGroupId(groupId, start, end, orderByComparator); 409 } 410 411 /** 412 * Finds the first message-boards message in the ordered set where groupId = ?. 413 * 414 * <p> 415 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 416 * </p> 417 * 418 * @param groupId the group id to search with 419 * @param orderByComparator the comparator to order the set by 420 * @return the first matching message-boards message 421 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 422 * @throws SystemException if a system exception occurred 423 */ 424 public static com.liferay.portlet.messageboards.model.MBMessage findByGroupId_First( 425 long groupId, 426 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 427 throws com.liferay.portal.kernel.exception.SystemException, 428 com.liferay.portlet.messageboards.NoSuchMessageException { 429 return getPersistence().findByGroupId_First(groupId, orderByComparator); 430 } 431 432 /** 433 * Finds the last message-boards message in the ordered set where groupId = ?. 434 * 435 * <p> 436 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 437 * </p> 438 * 439 * @param groupId the group id to search with 440 * @param orderByComparator the comparator to order the set by 441 * @return the last matching message-boards message 442 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 443 * @throws SystemException if a system exception occurred 444 */ 445 public static com.liferay.portlet.messageboards.model.MBMessage findByGroupId_Last( 446 long groupId, 447 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 448 throws com.liferay.portal.kernel.exception.SystemException, 449 com.liferay.portlet.messageboards.NoSuchMessageException { 450 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 451 } 452 453 /** 454 * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = ?. 455 * 456 * <p> 457 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 458 * </p> 459 * 460 * @param messageId the primary key of the current message-boards message 461 * @param groupId the group id to search with 462 * @param orderByComparator the comparator to order the set by 463 * @return the previous, current, and next message-boards message 464 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 465 * @throws SystemException if a system exception occurred 466 */ 467 public static com.liferay.portlet.messageboards.model.MBMessage[] findByGroupId_PrevAndNext( 468 long messageId, long groupId, 469 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 470 throws com.liferay.portal.kernel.exception.SystemException, 471 com.liferay.portlet.messageboards.NoSuchMessageException { 472 return getPersistence() 473 .findByGroupId_PrevAndNext(messageId, groupId, 474 orderByComparator); 475 } 476 477 /** 478 * Filters by the user's permissions and finds all the message-boards messages where groupId = ?. 479 * 480 * @param groupId the group id to search with 481 * @return the matching message-boards messages that the user has permission to view 482 * @throws SystemException if a system exception occurred 483 */ 484 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId( 485 long groupId) 486 throws com.liferay.portal.kernel.exception.SystemException { 487 return getPersistence().filterFindByGroupId(groupId); 488 } 489 490 /** 491 * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = ?. 492 * 493 * <p> 494 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 495 * </p> 496 * 497 * @param groupId the group id to search with 498 * @param start the lower bound of the range of message-boards messages to return 499 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 500 * @return the range of matching message-boards messages that the user has permission to view 501 * @throws SystemException if a system exception occurred 502 */ 503 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId( 504 long groupId, int start, int end) 505 throws com.liferay.portal.kernel.exception.SystemException { 506 return getPersistence().filterFindByGroupId(groupId, start, end); 507 } 508 509 /** 510 * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = ?. 511 * 512 * <p> 513 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 514 * </p> 515 * 516 * @param groupId the group id to search with 517 * @param start the lower bound of the range of message-boards messages to return 518 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 519 * @param orderByComparator the comparator to order the results by 520 * @return the ordered range of matching message-boards messages that the user has permission to view 521 * @throws SystemException if a system exception occurred 522 */ 523 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByGroupId( 524 long groupId, int start, int end, 525 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 526 throws com.liferay.portal.kernel.exception.SystemException { 527 return getPersistence() 528 .filterFindByGroupId(groupId, start, end, orderByComparator); 529 } 530 531 /** 532 * Finds all the message-boards messages where companyId = ?. 533 * 534 * @param companyId the company id to search with 535 * @return the matching message-boards messages 536 * @throws SystemException if a system exception occurred 537 */ 538 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId( 539 long companyId) 540 throws com.liferay.portal.kernel.exception.SystemException { 541 return getPersistence().findByCompanyId(companyId); 542 } 543 544 /** 545 * Finds a range of all the message-boards messages where companyId = ?. 546 * 547 * <p> 548 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 549 * </p> 550 * 551 * @param companyId the company id to search with 552 * @param start the lower bound of the range of message-boards messages to return 553 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 554 * @return the range of matching message-boards messages 555 * @throws SystemException if a system exception occurred 556 */ 557 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId( 558 long companyId, int start, int end) 559 throws com.liferay.portal.kernel.exception.SystemException { 560 return getPersistence().findByCompanyId(companyId, start, end); 561 } 562 563 /** 564 * Finds an ordered range of all the message-boards messages where companyId = ?. 565 * 566 * <p> 567 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 568 * </p> 569 * 570 * @param companyId the company id to search with 571 * @param start the lower bound of the range of message-boards messages to return 572 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 573 * @param orderByComparator the comparator to order the results by 574 * @return the ordered range of matching message-boards messages 575 * @throws SystemException if a system exception occurred 576 */ 577 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByCompanyId( 578 long companyId, int start, int end, 579 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 580 throws com.liferay.portal.kernel.exception.SystemException { 581 return getPersistence() 582 .findByCompanyId(companyId, start, end, orderByComparator); 583 } 584 585 /** 586 * Finds the first message-boards message in the ordered set where companyId = ?. 587 * 588 * <p> 589 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 590 * </p> 591 * 592 * @param companyId the company id to search with 593 * @param orderByComparator the comparator to order the set by 594 * @return the first matching message-boards message 595 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 596 * @throws SystemException if a system exception occurred 597 */ 598 public static com.liferay.portlet.messageboards.model.MBMessage findByCompanyId_First( 599 long companyId, 600 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 601 throws com.liferay.portal.kernel.exception.SystemException, 602 com.liferay.portlet.messageboards.NoSuchMessageException { 603 return getPersistence() 604 .findByCompanyId_First(companyId, orderByComparator); 605 } 606 607 /** 608 * Finds the last message-boards message in the ordered set where companyId = ?. 609 * 610 * <p> 611 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 612 * </p> 613 * 614 * @param companyId the company id to search with 615 * @param orderByComparator the comparator to order the set by 616 * @return the last matching message-boards message 617 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 618 * @throws SystemException if a system exception occurred 619 */ 620 public static com.liferay.portlet.messageboards.model.MBMessage findByCompanyId_Last( 621 long companyId, 622 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 623 throws com.liferay.portal.kernel.exception.SystemException, 624 com.liferay.portlet.messageboards.NoSuchMessageException { 625 return getPersistence() 626 .findByCompanyId_Last(companyId, orderByComparator); 627 } 628 629 /** 630 * Finds the message-boards messages before and after the current message-boards message in the ordered set where companyId = ?. 631 * 632 * <p> 633 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 634 * </p> 635 * 636 * @param messageId the primary key of the current message-boards message 637 * @param companyId the company id to search with 638 * @param orderByComparator the comparator to order the set by 639 * @return the previous, current, and next message-boards message 640 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 641 * @throws SystemException if a system exception occurred 642 */ 643 public static com.liferay.portlet.messageboards.model.MBMessage[] findByCompanyId_PrevAndNext( 644 long messageId, long companyId, 645 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 646 throws com.liferay.portal.kernel.exception.SystemException, 647 com.liferay.portlet.messageboards.NoSuchMessageException { 648 return getPersistence() 649 .findByCompanyId_PrevAndNext(messageId, companyId, 650 orderByComparator); 651 } 652 653 /** 654 * Finds all the message-boards messages where threadId = ?. 655 * 656 * @param threadId the thread id to search with 657 * @return the matching message-boards messages 658 * @throws SystemException if a system exception occurred 659 */ 660 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId( 661 long threadId) 662 throws com.liferay.portal.kernel.exception.SystemException { 663 return getPersistence().findByThreadId(threadId); 664 } 665 666 /** 667 * Finds a range of all the message-boards messages where threadId = ?. 668 * 669 * <p> 670 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 671 * </p> 672 * 673 * @param threadId the thread id to search with 674 * @param start the lower bound of the range of message-boards messages to return 675 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 676 * @return the range of matching message-boards messages 677 * @throws SystemException if a system exception occurred 678 */ 679 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId( 680 long threadId, int start, int end) 681 throws com.liferay.portal.kernel.exception.SystemException { 682 return getPersistence().findByThreadId(threadId, start, end); 683 } 684 685 /** 686 * Finds an ordered range of all the message-boards messages where threadId = ?. 687 * 688 * <p> 689 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 690 * </p> 691 * 692 * @param threadId the thread id to search with 693 * @param start the lower bound of the range of message-boards messages to return 694 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 695 * @param orderByComparator the comparator to order the results by 696 * @return the ordered range of matching message-boards messages 697 * @throws SystemException if a system exception occurred 698 */ 699 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadId( 700 long threadId, int start, int end, 701 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 702 throws com.liferay.portal.kernel.exception.SystemException { 703 return getPersistence() 704 .findByThreadId(threadId, start, end, orderByComparator); 705 } 706 707 /** 708 * Finds the first message-boards message in the ordered set where threadId = ?. 709 * 710 * <p> 711 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 712 * </p> 713 * 714 * @param threadId the thread id to search with 715 * @param orderByComparator the comparator to order the set by 716 * @return the first matching message-boards message 717 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 718 * @throws SystemException if a system exception occurred 719 */ 720 public static com.liferay.portlet.messageboards.model.MBMessage findByThreadId_First( 721 long threadId, 722 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 723 throws com.liferay.portal.kernel.exception.SystemException, 724 com.liferay.portlet.messageboards.NoSuchMessageException { 725 return getPersistence().findByThreadId_First(threadId, orderByComparator); 726 } 727 728 /** 729 * Finds the last message-boards message in the ordered set where threadId = ?. 730 * 731 * <p> 732 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 733 * </p> 734 * 735 * @param threadId the thread id to search with 736 * @param orderByComparator the comparator to order the set by 737 * @return the last matching message-boards message 738 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 739 * @throws SystemException if a system exception occurred 740 */ 741 public static com.liferay.portlet.messageboards.model.MBMessage findByThreadId_Last( 742 long threadId, 743 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 744 throws com.liferay.portal.kernel.exception.SystemException, 745 com.liferay.portlet.messageboards.NoSuchMessageException { 746 return getPersistence().findByThreadId_Last(threadId, orderByComparator); 747 } 748 749 /** 750 * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = ?. 751 * 752 * <p> 753 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 754 * </p> 755 * 756 * @param messageId the primary key of the current message-boards message 757 * @param threadId the thread id to search with 758 * @param orderByComparator the comparator to order the set by 759 * @return the previous, current, and next message-boards message 760 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 761 * @throws SystemException if a system exception occurred 762 */ 763 public static com.liferay.portlet.messageboards.model.MBMessage[] findByThreadId_PrevAndNext( 764 long messageId, long threadId, 765 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 766 throws com.liferay.portal.kernel.exception.SystemException, 767 com.liferay.portlet.messageboards.NoSuchMessageException { 768 return getPersistence() 769 .findByThreadId_PrevAndNext(messageId, threadId, 770 orderByComparator); 771 } 772 773 /** 774 * Finds all the message-boards messages where threadId = ?. 775 * 776 * @param threadId the thread id to search with 777 * @return the matching message-boards messages 778 * @throws SystemException if a system exception occurred 779 */ 780 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies( 781 long threadId) 782 throws com.liferay.portal.kernel.exception.SystemException { 783 return getPersistence().findByThreadReplies(threadId); 784 } 785 786 /** 787 * Finds a range of all the message-boards messages where threadId = ?. 788 * 789 * <p> 790 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 791 * </p> 792 * 793 * @param threadId the thread id to search with 794 * @param start the lower bound of the range of message-boards messages to return 795 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 796 * @return the range of matching message-boards messages 797 * @throws SystemException if a system exception occurred 798 */ 799 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies( 800 long threadId, int start, int end) 801 throws com.liferay.portal.kernel.exception.SystemException { 802 return getPersistence().findByThreadReplies(threadId, start, end); 803 } 804 805 /** 806 * Finds an ordered range of all the message-boards messages where threadId = ?. 807 * 808 * <p> 809 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 810 * </p> 811 * 812 * @param threadId the thread id to search with 813 * @param start the lower bound of the range of message-boards messages to return 814 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 815 * @param orderByComparator the comparator to order the results by 816 * @return the ordered range of matching message-boards messages 817 * @throws SystemException if a system exception occurred 818 */ 819 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByThreadReplies( 820 long threadId, int start, int end, 821 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 822 throws com.liferay.portal.kernel.exception.SystemException { 823 return getPersistence() 824 .findByThreadReplies(threadId, start, end, orderByComparator); 825 } 826 827 /** 828 * Finds the first message-boards message in the ordered set where threadId = ?. 829 * 830 * <p> 831 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 832 * </p> 833 * 834 * @param threadId the thread id to search with 835 * @param orderByComparator the comparator to order the set by 836 * @return the first matching message-boards message 837 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 838 * @throws SystemException if a system exception occurred 839 */ 840 public static com.liferay.portlet.messageboards.model.MBMessage findByThreadReplies_First( 841 long threadId, 842 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 843 throws com.liferay.portal.kernel.exception.SystemException, 844 com.liferay.portlet.messageboards.NoSuchMessageException { 845 return getPersistence() 846 .findByThreadReplies_First(threadId, orderByComparator); 847 } 848 849 /** 850 * Finds the last message-boards message in the ordered set where threadId = ?. 851 * 852 * <p> 853 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 854 * </p> 855 * 856 * @param threadId the thread id to search with 857 * @param orderByComparator the comparator to order the set by 858 * @return the last matching message-boards message 859 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 860 * @throws SystemException if a system exception occurred 861 */ 862 public static com.liferay.portlet.messageboards.model.MBMessage findByThreadReplies_Last( 863 long threadId, 864 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 865 throws com.liferay.portal.kernel.exception.SystemException, 866 com.liferay.portlet.messageboards.NoSuchMessageException { 867 return getPersistence() 868 .findByThreadReplies_Last(threadId, orderByComparator); 869 } 870 871 /** 872 * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = ?. 873 * 874 * <p> 875 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 876 * </p> 877 * 878 * @param messageId the primary key of the current message-boards message 879 * @param threadId the thread id to search with 880 * @param orderByComparator the comparator to order the set by 881 * @return the previous, current, and next message-boards message 882 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 883 * @throws SystemException if a system exception occurred 884 */ 885 public static com.liferay.portlet.messageboards.model.MBMessage[] findByThreadReplies_PrevAndNext( 886 long messageId, long threadId, 887 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 888 throws com.liferay.portal.kernel.exception.SystemException, 889 com.liferay.portlet.messageboards.NoSuchMessageException { 890 return getPersistence() 891 .findByThreadReplies_PrevAndNext(messageId, threadId, 892 orderByComparator); 893 } 894 895 /** 896 * Finds all the message-boards messages where userId = ?. 897 * 898 * @param userId the user id to search with 899 * @return the matching message-boards messages 900 * @throws SystemException if a system exception occurred 901 */ 902 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId( 903 long userId) throws com.liferay.portal.kernel.exception.SystemException { 904 return getPersistence().findByUserId(userId); 905 } 906 907 /** 908 * Finds a range of all the message-boards messages where userId = ?. 909 * 910 * <p> 911 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 912 * </p> 913 * 914 * @param userId the user id to search with 915 * @param start the lower bound of the range of message-boards messages to return 916 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 917 * @return the range of matching message-boards messages 918 * @throws SystemException if a system exception occurred 919 */ 920 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId( 921 long userId, int start, int end) 922 throws com.liferay.portal.kernel.exception.SystemException { 923 return getPersistence().findByUserId(userId, start, end); 924 } 925 926 /** 927 * Finds an ordered range of all the message-boards messages where userId = ?. 928 * 929 * <p> 930 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 931 * </p> 932 * 933 * @param userId the user id to search with 934 * @param start the lower bound of the range of message-boards messages to return 935 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 936 * @param orderByComparator the comparator to order the results by 937 * @return the ordered range of matching message-boards messages 938 * @throws SystemException if a system exception occurred 939 */ 940 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByUserId( 941 long userId, int start, int end, 942 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 943 throws com.liferay.portal.kernel.exception.SystemException { 944 return getPersistence() 945 .findByUserId(userId, start, end, orderByComparator); 946 } 947 948 /** 949 * Finds the first message-boards message in the ordered set where userId = ?. 950 * 951 * <p> 952 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 953 * </p> 954 * 955 * @param userId the user id to search with 956 * @param orderByComparator the comparator to order the set by 957 * @return the first matching message-boards message 958 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 959 * @throws SystemException if a system exception occurred 960 */ 961 public static com.liferay.portlet.messageboards.model.MBMessage findByUserId_First( 962 long userId, 963 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 964 throws com.liferay.portal.kernel.exception.SystemException, 965 com.liferay.portlet.messageboards.NoSuchMessageException { 966 return getPersistence().findByUserId_First(userId, orderByComparator); 967 } 968 969 /** 970 * Finds the last message-boards message in the ordered set where userId = ?. 971 * 972 * <p> 973 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 974 * </p> 975 * 976 * @param userId the user id to search with 977 * @param orderByComparator the comparator to order the set by 978 * @return the last matching message-boards message 979 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 980 * @throws SystemException if a system exception occurred 981 */ 982 public static com.liferay.portlet.messageboards.model.MBMessage findByUserId_Last( 983 long userId, 984 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 985 throws com.liferay.portal.kernel.exception.SystemException, 986 com.liferay.portlet.messageboards.NoSuchMessageException { 987 return getPersistence().findByUserId_Last(userId, orderByComparator); 988 } 989 990 /** 991 * Finds the message-boards messages before and after the current message-boards message in the ordered set where userId = ?. 992 * 993 * <p> 994 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 995 * </p> 996 * 997 * @param messageId the primary key of the current message-boards message 998 * @param userId the user id to search with 999 * @param orderByComparator the comparator to order the set by 1000 * @return the previous, current, and next message-boards message 1001 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 1002 * @throws SystemException if a system exception occurred 1003 */ 1004 public static com.liferay.portlet.messageboards.model.MBMessage[] findByUserId_PrevAndNext( 1005 long messageId, long userId, 1006 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1007 throws com.liferay.portal.kernel.exception.SystemException, 1008 com.liferay.portlet.messageboards.NoSuchMessageException { 1009 return getPersistence() 1010 .findByUserId_PrevAndNext(messageId, userId, 1011 orderByComparator); 1012 } 1013 1014 /** 1015 * Finds all the message-boards messages where groupId = ? and userId = ?. 1016 * 1017 * @param groupId the group id to search with 1018 * @param userId the user id to search with 1019 * @return the matching message-boards messages 1020 * @throws SystemException if a system exception occurred 1021 */ 1022 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U( 1023 long groupId, long userId) 1024 throws com.liferay.portal.kernel.exception.SystemException { 1025 return getPersistence().findByG_U(groupId, userId); 1026 } 1027 1028 /** 1029 * Finds a range of all the message-boards messages where groupId = ? and userId = ?. 1030 * 1031 * <p> 1032 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1033 * </p> 1034 * 1035 * @param groupId the group id to search with 1036 * @param userId the user id to search with 1037 * @param start the lower bound of the range of message-boards messages to return 1038 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1039 * @return the range of matching message-boards messages 1040 * @throws SystemException if a system exception occurred 1041 */ 1042 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U( 1043 long groupId, long userId, int start, int end) 1044 throws com.liferay.portal.kernel.exception.SystemException { 1045 return getPersistence().findByG_U(groupId, userId, start, end); 1046 } 1047 1048 /** 1049 * Finds an ordered range of all the message-boards messages where groupId = ? and userId = ?. 1050 * 1051 * <p> 1052 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1053 * </p> 1054 * 1055 * @param groupId the group id to search with 1056 * @param userId the user id to search with 1057 * @param start the lower bound of the range of message-boards messages to return 1058 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1059 * @param orderByComparator the comparator to order the results by 1060 * @return the ordered range of matching message-boards messages 1061 * @throws SystemException if a system exception occurred 1062 */ 1063 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U( 1064 long groupId, long userId, int start, int end, 1065 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1066 throws com.liferay.portal.kernel.exception.SystemException { 1067 return getPersistence() 1068 .findByG_U(groupId, userId, start, end, orderByComparator); 1069 } 1070 1071 /** 1072 * Finds the first message-boards message in the ordered set where groupId = ? and userId = ?. 1073 * 1074 * <p> 1075 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1076 * </p> 1077 * 1078 * @param groupId the group id to search with 1079 * @param userId the user id to search with 1080 * @param orderByComparator the comparator to order the set by 1081 * @return the first matching message-boards message 1082 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1083 * @throws SystemException if a system exception occurred 1084 */ 1085 public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_First( 1086 long groupId, long userId, 1087 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1088 throws com.liferay.portal.kernel.exception.SystemException, 1089 com.liferay.portlet.messageboards.NoSuchMessageException { 1090 return getPersistence() 1091 .findByG_U_First(groupId, userId, orderByComparator); 1092 } 1093 1094 /** 1095 * Finds the last message-boards message in the ordered set where groupId = ? and userId = ?. 1096 * 1097 * <p> 1098 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1099 * </p> 1100 * 1101 * @param groupId the group id to search with 1102 * @param userId the user id to search with 1103 * @param orderByComparator the comparator to order the set by 1104 * @return the last matching message-boards message 1105 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1106 * @throws SystemException if a system exception occurred 1107 */ 1108 public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_Last( 1109 long groupId, long userId, 1110 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1111 throws com.liferay.portal.kernel.exception.SystemException, 1112 com.liferay.portlet.messageboards.NoSuchMessageException { 1113 return getPersistence() 1114 .findByG_U_Last(groupId, userId, orderByComparator); 1115 } 1116 1117 /** 1118 * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = ? and userId = ?. 1119 * 1120 * <p> 1121 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1122 * </p> 1123 * 1124 * @param messageId the primary key of the current message-boards message 1125 * @param groupId the group id to search with 1126 * @param userId the user id to search with 1127 * @param orderByComparator the comparator to order the set by 1128 * @return the previous, current, and next message-boards message 1129 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 1130 * @throws SystemException if a system exception occurred 1131 */ 1132 public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_U_PrevAndNext( 1133 long messageId, long groupId, long userId, 1134 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1135 throws com.liferay.portal.kernel.exception.SystemException, 1136 com.liferay.portlet.messageboards.NoSuchMessageException { 1137 return getPersistence() 1138 .findByG_U_PrevAndNext(messageId, groupId, userId, 1139 orderByComparator); 1140 } 1141 1142 /** 1143 * Filters by the user's permissions and finds all the message-boards messages where groupId = ? and userId = ?. 1144 * 1145 * @param groupId the group id to search with 1146 * @param userId the user id to search with 1147 * @return the matching message-boards messages that the user has permission to view 1148 * @throws SystemException if a system exception occurred 1149 */ 1150 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U( 1151 long groupId, long userId) 1152 throws com.liferay.portal.kernel.exception.SystemException { 1153 return getPersistence().filterFindByG_U(groupId, userId); 1154 } 1155 1156 /** 1157 * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = ? and userId = ?. 1158 * 1159 * <p> 1160 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1161 * </p> 1162 * 1163 * @param groupId the group id to search with 1164 * @param userId the user id to search with 1165 * @param start the lower bound of the range of message-boards messages to return 1166 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1167 * @return the range of matching message-boards messages that the user has permission to view 1168 * @throws SystemException if a system exception occurred 1169 */ 1170 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U( 1171 long groupId, long userId, int start, int end) 1172 throws com.liferay.portal.kernel.exception.SystemException { 1173 return getPersistence().filterFindByG_U(groupId, userId, start, end); 1174 } 1175 1176 /** 1177 * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = ? and userId = ?. 1178 * 1179 * <p> 1180 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1181 * </p> 1182 * 1183 * @param groupId the group id to search with 1184 * @param userId the user id to search with 1185 * @param start the lower bound of the range of message-boards messages to return 1186 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1187 * @param orderByComparator the comparator to order the results by 1188 * @return the ordered range of matching message-boards messages that the user has permission to view 1189 * @throws SystemException if a system exception occurred 1190 */ 1191 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U( 1192 long groupId, long userId, int start, int end, 1193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1194 throws com.liferay.portal.kernel.exception.SystemException { 1195 return getPersistence() 1196 .filterFindByG_U(groupId, userId, start, end, 1197 orderByComparator); 1198 } 1199 1200 /** 1201 * Finds all the message-boards messages where groupId = ? and categoryId = ?. 1202 * 1203 * @param groupId the group id to search with 1204 * @param categoryId the category id to search with 1205 * @return the matching message-boards messages 1206 * @throws SystemException if a system exception occurred 1207 */ 1208 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C( 1209 long groupId, long categoryId) 1210 throws com.liferay.portal.kernel.exception.SystemException { 1211 return getPersistence().findByG_C(groupId, categoryId); 1212 } 1213 1214 /** 1215 * Finds a range of all the message-boards messages where groupId = ? and categoryId = ?. 1216 * 1217 * <p> 1218 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1219 * </p> 1220 * 1221 * @param groupId the group id to search with 1222 * @param categoryId the category id to search with 1223 * @param start the lower bound of the range of message-boards messages to return 1224 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1225 * @return the range of matching message-boards messages 1226 * @throws SystemException if a system exception occurred 1227 */ 1228 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C( 1229 long groupId, long categoryId, int start, int end) 1230 throws com.liferay.portal.kernel.exception.SystemException { 1231 return getPersistence().findByG_C(groupId, categoryId, start, end); 1232 } 1233 1234 /** 1235 * Finds an ordered range of all the message-boards messages where groupId = ? and categoryId = ?. 1236 * 1237 * <p> 1238 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1239 * </p> 1240 * 1241 * @param groupId the group id to search with 1242 * @param categoryId the category id to search with 1243 * @param start the lower bound of the range of message-boards messages to return 1244 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1245 * @param orderByComparator the comparator to order the results by 1246 * @return the ordered range of matching message-boards messages 1247 * @throws SystemException if a system exception occurred 1248 */ 1249 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C( 1250 long groupId, long categoryId, int start, int end, 1251 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1252 throws com.liferay.portal.kernel.exception.SystemException { 1253 return getPersistence() 1254 .findByG_C(groupId, categoryId, start, end, orderByComparator); 1255 } 1256 1257 /** 1258 * Finds the first message-boards message in the ordered set where groupId = ? and categoryId = ?. 1259 * 1260 * <p> 1261 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 1262 * </p> 1263 * 1264 * @param groupId the group id to search with 1265 * @param categoryId the category id to search with 1266 * @param orderByComparator the comparator to order the set by 1267 * @return the first matching message-boards message 1268 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1269 * @throws SystemException if a system exception occurred 1270 */ 1271 public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_First( 1272 long groupId, long categoryId, 1273 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1274 throws com.liferay.portal.kernel.exception.SystemException, 1275 com.liferay.portlet.messageboards.NoSuchMessageException { 1276 return getPersistence() 1277 .findByG_C_First(groupId, categoryId, orderByComparator); 1278 } 1279 1280 /** 1281 * Finds the last message-boards message in the ordered set where groupId = ? and categoryId = ?. 1282 * 1283 * <p> 1284 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1285 * </p> 1286 * 1287 * @param groupId the group id to search with 1288 * @param categoryId the category id to search with 1289 * @param orderByComparator the comparator to order the set by 1290 * @return the last matching message-boards message 1291 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1292 * @throws SystemException if a system exception occurred 1293 */ 1294 public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_Last( 1295 long groupId, long categoryId, 1296 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1297 throws com.liferay.portal.kernel.exception.SystemException, 1298 com.liferay.portlet.messageboards.NoSuchMessageException { 1299 return getPersistence() 1300 .findByG_C_Last(groupId, categoryId, orderByComparator); 1301 } 1302 1303 /** 1304 * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = ? and categoryId = ?. 1305 * 1306 * <p> 1307 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1308 * </p> 1309 * 1310 * @param messageId the primary key of the current message-boards message 1311 * @param groupId the group id to search with 1312 * @param categoryId the category id to search with 1313 * @param orderByComparator the comparator to order the set by 1314 * @return the previous, current, and next message-boards message 1315 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 1316 * @throws SystemException if a system exception occurred 1317 */ 1318 public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_PrevAndNext( 1319 long messageId, long groupId, long categoryId, 1320 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1321 throws com.liferay.portal.kernel.exception.SystemException, 1322 com.liferay.portlet.messageboards.NoSuchMessageException { 1323 return getPersistence() 1324 .findByG_C_PrevAndNext(messageId, groupId, categoryId, 1325 orderByComparator); 1326 } 1327 1328 /** 1329 * Filters by the user's permissions and finds all the message-boards messages where groupId = ? and categoryId = ?. 1330 * 1331 * @param groupId the group id to search with 1332 * @param categoryId the category id to search with 1333 * @return the matching message-boards messages that the user has permission to view 1334 * @throws SystemException if a system exception occurred 1335 */ 1336 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C( 1337 long groupId, long categoryId) 1338 throws com.liferay.portal.kernel.exception.SystemException { 1339 return getPersistence().filterFindByG_C(groupId, categoryId); 1340 } 1341 1342 /** 1343 * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = ? and categoryId = ?. 1344 * 1345 * <p> 1346 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1347 * </p> 1348 * 1349 * @param groupId the group id to search with 1350 * @param categoryId the category id to search with 1351 * @param start the lower bound of the range of message-boards messages to return 1352 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1353 * @return the range of matching message-boards messages that the user has permission to view 1354 * @throws SystemException if a system exception occurred 1355 */ 1356 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C( 1357 long groupId, long categoryId, int start, int end) 1358 throws com.liferay.portal.kernel.exception.SystemException { 1359 return getPersistence().filterFindByG_C(groupId, categoryId, start, end); 1360 } 1361 1362 /** 1363 * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = ? and categoryId = ?. 1364 * 1365 * <p> 1366 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1367 * </p> 1368 * 1369 * @param groupId the group id to search with 1370 * @param categoryId the category id to search with 1371 * @param start the lower bound of the range of message-boards messages to return 1372 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1373 * @param orderByComparator the comparator to order the results by 1374 * @return the ordered range of matching message-boards messages that the user has permission to view 1375 * @throws SystemException if a system exception occurred 1376 */ 1377 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C( 1378 long groupId, long categoryId, int start, int end, 1379 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1380 throws com.liferay.portal.kernel.exception.SystemException { 1381 return getPersistence() 1382 .filterFindByG_C(groupId, categoryId, start, end, 1383 orderByComparator); 1384 } 1385 1386 /** 1387 * Finds all the message-boards messages where groupId = ? and status = ?. 1388 * 1389 * @param groupId the group id to search with 1390 * @param status the status to search with 1391 * @return the matching message-boards messages 1392 * @throws SystemException if a system exception occurred 1393 */ 1394 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S( 1395 long groupId, int status) 1396 throws com.liferay.portal.kernel.exception.SystemException { 1397 return getPersistence().findByG_S(groupId, status); 1398 } 1399 1400 /** 1401 * Finds a range of all the message-boards messages where groupId = ? and status = ?. 1402 * 1403 * <p> 1404 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1405 * </p> 1406 * 1407 * @param groupId the group id to search with 1408 * @param status the status to search with 1409 * @param start the lower bound of the range of message-boards messages to return 1410 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1411 * @return the range of matching message-boards messages 1412 * @throws SystemException if a system exception occurred 1413 */ 1414 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S( 1415 long groupId, int status, int start, int end) 1416 throws com.liferay.portal.kernel.exception.SystemException { 1417 return getPersistence().findByG_S(groupId, status, start, end); 1418 } 1419 1420 /** 1421 * Finds an ordered range of all the message-boards messages where groupId = ? and status = ?. 1422 * 1423 * <p> 1424 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1425 * </p> 1426 * 1427 * @param groupId the group id to search with 1428 * @param status the status to search with 1429 * @param start the lower bound of the range of message-boards messages to return 1430 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1431 * @param orderByComparator the comparator to order the results by 1432 * @return the ordered range of matching message-boards messages 1433 * @throws SystemException if a system exception occurred 1434 */ 1435 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_S( 1436 long groupId, int status, int start, int end, 1437 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1438 throws com.liferay.portal.kernel.exception.SystemException { 1439 return getPersistence() 1440 .findByG_S(groupId, status, start, end, orderByComparator); 1441 } 1442 1443 /** 1444 * Finds the first message-boards message in the ordered set where groupId = ? and status = ?. 1445 * 1446 * <p> 1447 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1448 * </p> 1449 * 1450 * @param groupId the group id to search with 1451 * @param status the status to search with 1452 * @param orderByComparator the comparator to order the set by 1453 * @return the first matching message-boards message 1454 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1455 * @throws SystemException if a system exception occurred 1456 */ 1457 public static com.liferay.portlet.messageboards.model.MBMessage findByG_S_First( 1458 long groupId, int status, 1459 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1460 throws com.liferay.portal.kernel.exception.SystemException, 1461 com.liferay.portlet.messageboards.NoSuchMessageException { 1462 return getPersistence() 1463 .findByG_S_First(groupId, status, orderByComparator); 1464 } 1465 1466 /** 1467 * Finds the last message-boards message in the ordered set where groupId = ? and status = ?. 1468 * 1469 * <p> 1470 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1471 * </p> 1472 * 1473 * @param groupId the group id to search with 1474 * @param status the status to search with 1475 * @param orderByComparator the comparator to order the set by 1476 * @return the last matching message-boards message 1477 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1478 * @throws SystemException if a system exception occurred 1479 */ 1480 public static com.liferay.portlet.messageboards.model.MBMessage findByG_S_Last( 1481 long groupId, int status, 1482 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1483 throws com.liferay.portal.kernel.exception.SystemException, 1484 com.liferay.portlet.messageboards.NoSuchMessageException { 1485 return getPersistence() 1486 .findByG_S_Last(groupId, status, orderByComparator); 1487 } 1488 1489 /** 1490 * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = ? and status = ?. 1491 * 1492 * <p> 1493 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1494 * </p> 1495 * 1496 * @param messageId the primary key of the current message-boards message 1497 * @param groupId the group id to search with 1498 * @param status the status to search with 1499 * @param orderByComparator the comparator to order the set by 1500 * @return the previous, current, and next message-boards message 1501 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 1502 * @throws SystemException if a system exception occurred 1503 */ 1504 public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_S_PrevAndNext( 1505 long messageId, long groupId, int status, 1506 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1507 throws com.liferay.portal.kernel.exception.SystemException, 1508 com.liferay.portlet.messageboards.NoSuchMessageException { 1509 return getPersistence() 1510 .findByG_S_PrevAndNext(messageId, groupId, status, 1511 orderByComparator); 1512 } 1513 1514 /** 1515 * Filters by the user's permissions and finds all the message-boards messages where groupId = ? and status = ?. 1516 * 1517 * @param groupId the group id to search with 1518 * @param status the status to search with 1519 * @return the matching message-boards messages that the user has permission to view 1520 * @throws SystemException if a system exception occurred 1521 */ 1522 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S( 1523 long groupId, int status) 1524 throws com.liferay.portal.kernel.exception.SystemException { 1525 return getPersistence().filterFindByG_S(groupId, status); 1526 } 1527 1528 /** 1529 * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = ? and status = ?. 1530 * 1531 * <p> 1532 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1533 * </p> 1534 * 1535 * @param groupId the group id to search with 1536 * @param status the status to search with 1537 * @param start the lower bound of the range of message-boards messages to return 1538 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1539 * @return the range of matching message-boards messages that the user has permission to view 1540 * @throws SystemException if a system exception occurred 1541 */ 1542 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S( 1543 long groupId, int status, int start, int end) 1544 throws com.liferay.portal.kernel.exception.SystemException { 1545 return getPersistence().filterFindByG_S(groupId, status, start, end); 1546 } 1547 1548 /** 1549 * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = ? and status = ?. 1550 * 1551 * <p> 1552 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1553 * </p> 1554 * 1555 * @param groupId the group id to search with 1556 * @param status the status to search with 1557 * @param start the lower bound of the range of message-boards messages to return 1558 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1559 * @param orderByComparator the comparator to order the results by 1560 * @return the ordered range of matching message-boards messages that the user has permission to view 1561 * @throws SystemException if a system exception occurred 1562 */ 1563 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_S( 1564 long groupId, int status, int start, int end, 1565 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1566 throws com.liferay.portal.kernel.exception.SystemException { 1567 return getPersistence() 1568 .filterFindByG_S(groupId, status, start, end, 1569 orderByComparator); 1570 } 1571 1572 /** 1573 * Finds all the message-boards messages where companyId = ? and status = ?. 1574 * 1575 * @param companyId the company id to search with 1576 * @param status the status to search with 1577 * @return the matching message-boards messages 1578 * @throws SystemException if a system exception occurred 1579 */ 1580 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S( 1581 long companyId, int status) 1582 throws com.liferay.portal.kernel.exception.SystemException { 1583 return getPersistence().findByC_S(companyId, status); 1584 } 1585 1586 /** 1587 * Finds a range of all the message-boards messages where companyId = ? and status = ?. 1588 * 1589 * <p> 1590 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1591 * </p> 1592 * 1593 * @param companyId the company id to search with 1594 * @param status the status to search with 1595 * @param start the lower bound of the range of message-boards messages to return 1596 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1597 * @return the range of matching message-boards messages 1598 * @throws SystemException if a system exception occurred 1599 */ 1600 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S( 1601 long companyId, int status, int start, int end) 1602 throws com.liferay.portal.kernel.exception.SystemException { 1603 return getPersistence().findByC_S(companyId, status, start, end); 1604 } 1605 1606 /** 1607 * Finds an ordered range of all the message-boards messages where companyId = ? and status = ?. 1608 * 1609 * <p> 1610 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1611 * </p> 1612 * 1613 * @param companyId the company id to search with 1614 * @param status the status to search with 1615 * @param start the lower bound of the range of message-boards messages to return 1616 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1617 * @param orderByComparator the comparator to order the results by 1618 * @return the ordered range of matching message-boards messages 1619 * @throws SystemException if a system exception occurred 1620 */ 1621 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_S( 1622 long companyId, int status, int start, int end, 1623 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1624 throws com.liferay.portal.kernel.exception.SystemException { 1625 return getPersistence() 1626 .findByC_S(companyId, status, start, end, orderByComparator); 1627 } 1628 1629 /** 1630 * Finds the first message-boards message in the ordered set where companyId = ? and status = ?. 1631 * 1632 * <p> 1633 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1634 * </p> 1635 * 1636 * @param companyId the company id to search with 1637 * @param status the status to search with 1638 * @param orderByComparator the comparator to order the set by 1639 * @return the first matching message-boards message 1640 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1641 * @throws SystemException if a system exception occurred 1642 */ 1643 public static com.liferay.portlet.messageboards.model.MBMessage findByC_S_First( 1644 long companyId, int status, 1645 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1646 throws com.liferay.portal.kernel.exception.SystemException, 1647 com.liferay.portlet.messageboards.NoSuchMessageException { 1648 return getPersistence() 1649 .findByC_S_First(companyId, status, orderByComparator); 1650 } 1651 1652 /** 1653 * Finds the last message-boards message in the ordered set where companyId = ? and status = ?. 1654 * 1655 * <p> 1656 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1657 * </p> 1658 * 1659 * @param companyId the company id to search with 1660 * @param status the status to search with 1661 * @param orderByComparator the comparator to order the set by 1662 * @return the last matching message-boards message 1663 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1664 * @throws SystemException if a system exception occurred 1665 */ 1666 public static com.liferay.portlet.messageboards.model.MBMessage findByC_S_Last( 1667 long companyId, int status, 1668 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1669 throws com.liferay.portal.kernel.exception.SystemException, 1670 com.liferay.portlet.messageboards.NoSuchMessageException { 1671 return getPersistence() 1672 .findByC_S_Last(companyId, status, orderByComparator); 1673 } 1674 1675 /** 1676 * Finds the message-boards messages before and after the current message-boards message in the ordered set where companyId = ? and status = ?. 1677 * 1678 * <p> 1679 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1680 * </p> 1681 * 1682 * @param messageId the primary key of the current message-boards message 1683 * @param companyId the company id to search with 1684 * @param status the status to search with 1685 * @param orderByComparator the comparator to order the set by 1686 * @return the previous, current, and next message-boards message 1687 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 1688 * @throws SystemException if a system exception occurred 1689 */ 1690 public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_S_PrevAndNext( 1691 long messageId, long companyId, int status, 1692 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1693 throws com.liferay.portal.kernel.exception.SystemException, 1694 com.liferay.portlet.messageboards.NoSuchMessageException { 1695 return getPersistence() 1696 .findByC_S_PrevAndNext(messageId, companyId, status, 1697 orderByComparator); 1698 } 1699 1700 /** 1701 * Finds all the message-boards messages where classNameId = ? and classPK = ?. 1702 * 1703 * @param classNameId the class name id to search with 1704 * @param classPK the class p k to search with 1705 * @return the matching message-boards messages 1706 * @throws SystemException if a system exception occurred 1707 */ 1708 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C( 1709 long classNameId, long classPK) 1710 throws com.liferay.portal.kernel.exception.SystemException { 1711 return getPersistence().findByC_C(classNameId, classPK); 1712 } 1713 1714 /** 1715 * Finds a range of all the message-boards messages where classNameId = ? and classPK = ?. 1716 * 1717 * <p> 1718 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1719 * </p> 1720 * 1721 * @param classNameId the class name id to search with 1722 * @param classPK the class p k to search with 1723 * @param start the lower bound of the range of message-boards messages to return 1724 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1725 * @return the range of matching message-boards messages 1726 * @throws SystemException if a system exception occurred 1727 */ 1728 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C( 1729 long classNameId, long classPK, int start, int end) 1730 throws com.liferay.portal.kernel.exception.SystemException { 1731 return getPersistence().findByC_C(classNameId, classPK, start, end); 1732 } 1733 1734 /** 1735 * Finds an ordered range of all the message-boards messages where classNameId = ? and classPK = ?. 1736 * 1737 * <p> 1738 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1739 * </p> 1740 * 1741 * @param classNameId the class name id to search with 1742 * @param classPK the class p k to search with 1743 * @param start the lower bound of the range of message-boards messages to return 1744 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1745 * @param orderByComparator the comparator to order the results by 1746 * @return the ordered range of matching message-boards messages 1747 * @throws SystemException if a system exception occurred 1748 */ 1749 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C( 1750 long classNameId, long classPK, int start, int end, 1751 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1752 throws com.liferay.portal.kernel.exception.SystemException { 1753 return getPersistence() 1754 .findByC_C(classNameId, classPK, start, end, 1755 orderByComparator); 1756 } 1757 1758 /** 1759 * Finds the first message-boards message in the ordered set where classNameId = ? and classPK = ?. 1760 * 1761 * <p> 1762 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1763 * </p> 1764 * 1765 * @param classNameId the class name id to search with 1766 * @param classPK the class p k to search with 1767 * @param orderByComparator the comparator to order the set by 1768 * @return the first matching message-boards message 1769 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1770 * @throws SystemException if a system exception occurred 1771 */ 1772 public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_First( 1773 long classNameId, long classPK, 1774 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1775 throws com.liferay.portal.kernel.exception.SystemException, 1776 com.liferay.portlet.messageboards.NoSuchMessageException { 1777 return getPersistence() 1778 .findByC_C_First(classNameId, classPK, orderByComparator); 1779 } 1780 1781 /** 1782 * Finds the last message-boards message in the ordered set where classNameId = ? and classPK = ?. 1783 * 1784 * <p> 1785 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1786 * </p> 1787 * 1788 * @param classNameId the class name id to search with 1789 * @param classPK the class p k to search with 1790 * @param orderByComparator the comparator to order the set by 1791 * @return the last matching message-boards message 1792 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1793 * @throws SystemException if a system exception occurred 1794 */ 1795 public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_Last( 1796 long classNameId, long classPK, 1797 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1798 throws com.liferay.portal.kernel.exception.SystemException, 1799 com.liferay.portlet.messageboards.NoSuchMessageException { 1800 return getPersistence() 1801 .findByC_C_Last(classNameId, classPK, orderByComparator); 1802 } 1803 1804 /** 1805 * Finds the message-boards messages before and after the current message-boards message in the ordered set where classNameId = ? and classPK = ?. 1806 * 1807 * <p> 1808 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1809 * </p> 1810 * 1811 * @param messageId the primary key of the current message-boards message 1812 * @param classNameId the class name id to search with 1813 * @param classPK the class p k to search with 1814 * @param orderByComparator the comparator to order the set by 1815 * @return the previous, current, and next message-boards message 1816 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 1817 * @throws SystemException if a system exception occurred 1818 */ 1819 public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_C_PrevAndNext( 1820 long messageId, long classNameId, long classPK, 1821 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1822 throws com.liferay.portal.kernel.exception.SystemException, 1823 com.liferay.portlet.messageboards.NoSuchMessageException { 1824 return getPersistence() 1825 .findByC_C_PrevAndNext(messageId, classNameId, classPK, 1826 orderByComparator); 1827 } 1828 1829 /** 1830 * Finds all the message-boards messages where threadId = ? and parentMessageId = ?. 1831 * 1832 * @param threadId the thread id to search with 1833 * @param parentMessageId the parent message id to search with 1834 * @return the matching message-boards messages 1835 * @throws SystemException if a system exception occurred 1836 */ 1837 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P( 1838 long threadId, long parentMessageId) 1839 throws com.liferay.portal.kernel.exception.SystemException { 1840 return getPersistence().findByT_P(threadId, parentMessageId); 1841 } 1842 1843 /** 1844 * Finds a range of all the message-boards messages where threadId = ? and parentMessageId = ?. 1845 * 1846 * <p> 1847 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1848 * </p> 1849 * 1850 * @param threadId the thread id to search with 1851 * @param parentMessageId the parent message id to search with 1852 * @param start the lower bound of the range of message-boards messages to return 1853 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1854 * @return the range of matching message-boards messages 1855 * @throws SystemException if a system exception occurred 1856 */ 1857 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P( 1858 long threadId, long parentMessageId, int start, int end) 1859 throws com.liferay.portal.kernel.exception.SystemException { 1860 return getPersistence().findByT_P(threadId, parentMessageId, start, end); 1861 } 1862 1863 /** 1864 * Finds an ordered range of all the message-boards messages where threadId = ? and parentMessageId = ?. 1865 * 1866 * <p> 1867 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1868 * </p> 1869 * 1870 * @param threadId the thread id to search with 1871 * @param parentMessageId the parent message id to search with 1872 * @param start the lower bound of the range of message-boards messages to return 1873 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1874 * @param orderByComparator the comparator to order the results by 1875 * @return the ordered range of matching message-boards messages 1876 * @throws SystemException if a system exception occurred 1877 */ 1878 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_P( 1879 long threadId, long parentMessageId, int start, int end, 1880 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1881 throws com.liferay.portal.kernel.exception.SystemException { 1882 return getPersistence() 1883 .findByT_P(threadId, parentMessageId, start, end, 1884 orderByComparator); 1885 } 1886 1887 /** 1888 * Finds the first message-boards message in the ordered set where threadId = ? and parentMessageId = ?. 1889 * 1890 * <p> 1891 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1892 * </p> 1893 * 1894 * @param threadId the thread id to search with 1895 * @param parentMessageId the parent message id to search with 1896 * @param orderByComparator the comparator to order the set by 1897 * @return the first matching message-boards message 1898 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1899 * @throws SystemException if a system exception occurred 1900 */ 1901 public static com.liferay.portlet.messageboards.model.MBMessage findByT_P_First( 1902 long threadId, long parentMessageId, 1903 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1904 throws com.liferay.portal.kernel.exception.SystemException, 1905 com.liferay.portlet.messageboards.NoSuchMessageException { 1906 return getPersistence() 1907 .findByT_P_First(threadId, parentMessageId, orderByComparator); 1908 } 1909 1910 /** 1911 * Finds the last message-boards message in the ordered set where threadId = ? and parentMessageId = ?. 1912 * 1913 * <p> 1914 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1915 * </p> 1916 * 1917 * @param threadId the thread id to search with 1918 * @param parentMessageId the parent message id to search with 1919 * @param orderByComparator the comparator to order the set by 1920 * @return the last matching message-boards message 1921 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 1922 * @throws SystemException if a system exception occurred 1923 */ 1924 public static com.liferay.portlet.messageboards.model.MBMessage findByT_P_Last( 1925 long threadId, long parentMessageId, 1926 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1927 throws com.liferay.portal.kernel.exception.SystemException, 1928 com.liferay.portlet.messageboards.NoSuchMessageException { 1929 return getPersistence() 1930 .findByT_P_Last(threadId, parentMessageId, orderByComparator); 1931 } 1932 1933 /** 1934 * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = ? and parentMessageId = ?. 1935 * 1936 * <p> 1937 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1938 * </p> 1939 * 1940 * @param messageId the primary key of the current message-boards message 1941 * @param threadId the thread id to search with 1942 * @param parentMessageId the parent message id to search with 1943 * @param orderByComparator the comparator to order the set by 1944 * @return the previous, current, and next message-boards message 1945 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 1946 * @throws SystemException if a system exception occurred 1947 */ 1948 public static com.liferay.portlet.messageboards.model.MBMessage[] findByT_P_PrevAndNext( 1949 long messageId, long threadId, long parentMessageId, 1950 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1951 throws com.liferay.portal.kernel.exception.SystemException, 1952 com.liferay.portlet.messageboards.NoSuchMessageException { 1953 return getPersistence() 1954 .findByT_P_PrevAndNext(messageId, threadId, parentMessageId, 1955 orderByComparator); 1956 } 1957 1958 /** 1959 * Finds all the message-boards messages where threadId = ? and status = ?. 1960 * 1961 * @param threadId the thread id to search with 1962 * @param status the status to search with 1963 * @return the matching message-boards messages 1964 * @throws SystemException if a system exception occurred 1965 */ 1966 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S( 1967 long threadId, int status) 1968 throws com.liferay.portal.kernel.exception.SystemException { 1969 return getPersistence().findByT_S(threadId, status); 1970 } 1971 1972 /** 1973 * Finds a range of all the message-boards messages where threadId = ? and status = ?. 1974 * 1975 * <p> 1976 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1977 * </p> 1978 * 1979 * @param threadId the thread id to search with 1980 * @param status the status to search with 1981 * @param start the lower bound of the range of message-boards messages to return 1982 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 1983 * @return the range of matching message-boards messages 1984 * @throws SystemException if a system exception occurred 1985 */ 1986 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S( 1987 long threadId, int status, int start, int end) 1988 throws com.liferay.portal.kernel.exception.SystemException { 1989 return getPersistence().findByT_S(threadId, status, start, end); 1990 } 1991 1992 /** 1993 * Finds an ordered range of all the message-boards messages where threadId = ? and status = ?. 1994 * 1995 * <p> 1996 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1997 * </p> 1998 * 1999 * @param threadId the thread id to search with 2000 * @param status the status to search with 2001 * @param start the lower bound of the range of message-boards messages to return 2002 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2003 * @param orderByComparator the comparator to order the results by 2004 * @return the ordered range of matching message-boards messages 2005 * @throws SystemException if a system exception occurred 2006 */ 2007 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByT_S( 2008 long threadId, int status, int start, int end, 2009 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2010 throws com.liferay.portal.kernel.exception.SystemException { 2011 return getPersistence() 2012 .findByT_S(threadId, status, start, end, orderByComparator); 2013 } 2014 2015 /** 2016 * Finds the first message-boards message in the ordered set where threadId = ? and status = ?. 2017 * 2018 * <p> 2019 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2020 * </p> 2021 * 2022 * @param threadId the thread id to search with 2023 * @param status the status to search with 2024 * @param orderByComparator the comparator to order the set by 2025 * @return the first matching message-boards message 2026 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2027 * @throws SystemException if a system exception occurred 2028 */ 2029 public static com.liferay.portlet.messageboards.model.MBMessage findByT_S_First( 2030 long threadId, int status, 2031 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2032 throws com.liferay.portal.kernel.exception.SystemException, 2033 com.liferay.portlet.messageboards.NoSuchMessageException { 2034 return getPersistence() 2035 .findByT_S_First(threadId, status, orderByComparator); 2036 } 2037 2038 /** 2039 * Finds the last message-boards message in the ordered set where threadId = ? and status = ?. 2040 * 2041 * <p> 2042 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2043 * </p> 2044 * 2045 * @param threadId the thread id to search with 2046 * @param status the status to search with 2047 * @param orderByComparator the comparator to order the set by 2048 * @return the last matching message-boards message 2049 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2050 * @throws SystemException if a system exception occurred 2051 */ 2052 public static com.liferay.portlet.messageboards.model.MBMessage findByT_S_Last( 2053 long threadId, int status, 2054 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2055 throws com.liferay.portal.kernel.exception.SystemException, 2056 com.liferay.portlet.messageboards.NoSuchMessageException { 2057 return getPersistence() 2058 .findByT_S_Last(threadId, status, orderByComparator); 2059 } 2060 2061 /** 2062 * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = ? and status = ?. 2063 * 2064 * <p> 2065 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2066 * </p> 2067 * 2068 * @param messageId the primary key of the current message-boards message 2069 * @param threadId the thread id to search with 2070 * @param status the status to search with 2071 * @param orderByComparator the comparator to order the set by 2072 * @return the previous, current, and next message-boards message 2073 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 2074 * @throws SystemException if a system exception occurred 2075 */ 2076 public static com.liferay.portlet.messageboards.model.MBMessage[] findByT_S_PrevAndNext( 2077 long messageId, long threadId, int status, 2078 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2079 throws com.liferay.portal.kernel.exception.SystemException, 2080 com.liferay.portlet.messageboards.NoSuchMessageException { 2081 return getPersistence() 2082 .findByT_S_PrevAndNext(messageId, threadId, status, 2083 orderByComparator); 2084 } 2085 2086 /** 2087 * Finds all the message-boards messages where threadId = ? and status = ?. 2088 * 2089 * @param threadId the thread id to search with 2090 * @param status the status to search with 2091 * @return the matching message-boards messages 2092 * @throws SystemException if a system exception occurred 2093 */ 2094 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S( 2095 long threadId, int status) 2096 throws com.liferay.portal.kernel.exception.SystemException { 2097 return getPersistence().findByTR_S(threadId, status); 2098 } 2099 2100 /** 2101 * Finds a range of all the message-boards messages where threadId = ? and status = ?. 2102 * 2103 * <p> 2104 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2105 * </p> 2106 * 2107 * @param threadId the thread id to search with 2108 * @param status the status to search with 2109 * @param start the lower bound of the range of message-boards messages to return 2110 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2111 * @return the range of matching message-boards messages 2112 * @throws SystemException if a system exception occurred 2113 */ 2114 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S( 2115 long threadId, int status, int start, int end) 2116 throws com.liferay.portal.kernel.exception.SystemException { 2117 return getPersistence().findByTR_S(threadId, status, start, end); 2118 } 2119 2120 /** 2121 * Finds an ordered range of all the message-boards messages where threadId = ? and status = ?. 2122 * 2123 * <p> 2124 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 2125 * </p> 2126 * 2127 * @param threadId the thread id to search with 2128 * @param status the status to search with 2129 * @param start the lower bound of the range of message-boards messages to return 2130 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2131 * @param orderByComparator the comparator to order the results by 2132 * @return the ordered range of matching message-boards messages 2133 * @throws SystemException if a system exception occurred 2134 */ 2135 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByTR_S( 2136 long threadId, int status, int start, int end, 2137 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2138 throws com.liferay.portal.kernel.exception.SystemException { 2139 return getPersistence() 2140 .findByTR_S(threadId, status, start, end, orderByComparator); 2141 } 2142 2143 /** 2144 * Finds the first message-boards message in the ordered set where threadId = ? and status = ?. 2145 * 2146 * <p> 2147 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2148 * </p> 2149 * 2150 * @param threadId the thread id to search with 2151 * @param status the status to search with 2152 * @param orderByComparator the comparator to order the set by 2153 * @return the first matching message-boards message 2154 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2155 * @throws SystemException if a system exception occurred 2156 */ 2157 public static com.liferay.portlet.messageboards.model.MBMessage findByTR_S_First( 2158 long threadId, int status, 2159 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2160 throws com.liferay.portal.kernel.exception.SystemException, 2161 com.liferay.portlet.messageboards.NoSuchMessageException { 2162 return getPersistence() 2163 .findByTR_S_First(threadId, status, orderByComparator); 2164 } 2165 2166 /** 2167 * Finds the last message-boards message in the ordered set where threadId = ? and status = ?. 2168 * 2169 * <p> 2170 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2171 * </p> 2172 * 2173 * @param threadId the thread id to search with 2174 * @param status the status to search with 2175 * @param orderByComparator the comparator to order the set by 2176 * @return the last matching message-boards message 2177 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2178 * @throws SystemException if a system exception occurred 2179 */ 2180 public static com.liferay.portlet.messageboards.model.MBMessage findByTR_S_Last( 2181 long threadId, int status, 2182 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2183 throws com.liferay.portal.kernel.exception.SystemException, 2184 com.liferay.portlet.messageboards.NoSuchMessageException { 2185 return getPersistence() 2186 .findByTR_S_Last(threadId, status, orderByComparator); 2187 } 2188 2189 /** 2190 * Finds the message-boards messages before and after the current message-boards message in the ordered set where threadId = ? and status = ?. 2191 * 2192 * <p> 2193 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2194 * </p> 2195 * 2196 * @param messageId the primary key of the current message-boards message 2197 * @param threadId the thread id to search with 2198 * @param status the status to search with 2199 * @param orderByComparator the comparator to order the set by 2200 * @return the previous, current, and next message-boards message 2201 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 2202 * @throws SystemException if a system exception occurred 2203 */ 2204 public static com.liferay.portlet.messageboards.model.MBMessage[] findByTR_S_PrevAndNext( 2205 long messageId, long threadId, int status, 2206 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2207 throws com.liferay.portal.kernel.exception.SystemException, 2208 com.liferay.portlet.messageboards.NoSuchMessageException { 2209 return getPersistence() 2210 .findByTR_S_PrevAndNext(messageId, threadId, status, 2211 orderByComparator); 2212 } 2213 2214 /** 2215 * Finds all the message-boards messages where groupId = ? and userId = ? and status = ?. 2216 * 2217 * @param groupId the group id to search with 2218 * @param userId the user id to search with 2219 * @param status the status to search with 2220 * @return the matching message-boards messages 2221 * @throws SystemException if a system exception occurred 2222 */ 2223 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S( 2224 long groupId, long userId, int status) 2225 throws com.liferay.portal.kernel.exception.SystemException { 2226 return getPersistence().findByG_U_S(groupId, userId, status); 2227 } 2228 2229 /** 2230 * Finds a range of all the message-boards messages where groupId = ? and userId = ? and status = ?. 2231 * 2232 * <p> 2233 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2234 * </p> 2235 * 2236 * @param groupId the group id to search with 2237 * @param userId the user id to search with 2238 * @param status the status to search with 2239 * @param start the lower bound of the range of message-boards messages to return 2240 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2241 * @return the range of matching message-boards messages 2242 * @throws SystemException if a system exception occurred 2243 */ 2244 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S( 2245 long groupId, long userId, int status, int start, int end) 2246 throws com.liferay.portal.kernel.exception.SystemException { 2247 return getPersistence().findByG_U_S(groupId, userId, status, start, end); 2248 } 2249 2250 /** 2251 * Finds an ordered range of all the message-boards messages where groupId = ? and userId = ? and status = ?. 2252 * 2253 * <p> 2254 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2255 * </p> 2256 * 2257 * @param groupId the group id to search with 2258 * @param userId the user id to search with 2259 * @param status the status to search with 2260 * @param start the lower bound of the range of message-boards messages to return 2261 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2262 * @param orderByComparator the comparator to order the results by 2263 * @return the ordered range of matching message-boards messages 2264 * @throws SystemException if a system exception occurred 2265 */ 2266 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_U_S( 2267 long groupId, long userId, int status, int start, int end, 2268 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2269 throws com.liferay.portal.kernel.exception.SystemException { 2270 return getPersistence() 2271 .findByG_U_S(groupId, userId, status, start, end, 2272 orderByComparator); 2273 } 2274 2275 /** 2276 * Finds the first message-boards message in the ordered set where groupId = ? and userId = ? and status = ?. 2277 * 2278 * <p> 2279 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2280 * </p> 2281 * 2282 * @param groupId the group id to search with 2283 * @param userId the user id to search with 2284 * @param status the status to search with 2285 * @param orderByComparator the comparator to order the set by 2286 * @return the first matching message-boards message 2287 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2288 * @throws SystemException if a system exception occurred 2289 */ 2290 public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_S_First( 2291 long groupId, long userId, int status, 2292 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2293 throws com.liferay.portal.kernel.exception.SystemException, 2294 com.liferay.portlet.messageboards.NoSuchMessageException { 2295 return getPersistence() 2296 .findByG_U_S_First(groupId, userId, status, orderByComparator); 2297 } 2298 2299 /** 2300 * Finds the last message-boards message in the ordered set where groupId = ? and userId = ? and status = ?. 2301 * 2302 * <p> 2303 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2304 * </p> 2305 * 2306 * @param groupId the group id to search with 2307 * @param userId the user id to search with 2308 * @param status the status to search with 2309 * @param orderByComparator the comparator to order the set by 2310 * @return the last matching message-boards message 2311 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2312 * @throws SystemException if a system exception occurred 2313 */ 2314 public static com.liferay.portlet.messageboards.model.MBMessage findByG_U_S_Last( 2315 long groupId, long userId, int status, 2316 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2317 throws com.liferay.portal.kernel.exception.SystemException, 2318 com.liferay.portlet.messageboards.NoSuchMessageException { 2319 return getPersistence() 2320 .findByG_U_S_Last(groupId, userId, status, orderByComparator); 2321 } 2322 2323 /** 2324 * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = ? and userId = ? and status = ?. 2325 * 2326 * <p> 2327 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2328 * </p> 2329 * 2330 * @param messageId the primary key of the current message-boards message 2331 * @param groupId the group id to search with 2332 * @param userId the user id to search with 2333 * @param status the status to search with 2334 * @param orderByComparator the comparator to order the set by 2335 * @return the previous, current, and next message-boards message 2336 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 2337 * @throws SystemException if a system exception occurred 2338 */ 2339 public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_U_S_PrevAndNext( 2340 long messageId, long groupId, long userId, int status, 2341 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2342 throws com.liferay.portal.kernel.exception.SystemException, 2343 com.liferay.portlet.messageboards.NoSuchMessageException { 2344 return getPersistence() 2345 .findByG_U_S_PrevAndNext(messageId, groupId, userId, status, 2346 orderByComparator); 2347 } 2348 2349 /** 2350 * Filters by the user's permissions and finds all the message-boards messages where groupId = ? and userId = ? and status = ?. 2351 * 2352 * @param groupId the group id to search with 2353 * @param userId the user id to search with 2354 * @param status the status to search with 2355 * @return the matching message-boards messages that the user has permission to view 2356 * @throws SystemException if a system exception occurred 2357 */ 2358 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S( 2359 long groupId, long userId, int status) 2360 throws com.liferay.portal.kernel.exception.SystemException { 2361 return getPersistence().filterFindByG_U_S(groupId, userId, status); 2362 } 2363 2364 /** 2365 * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = ? and userId = ? and status = ?. 2366 * 2367 * <p> 2368 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2369 * </p> 2370 * 2371 * @param groupId the group id to search with 2372 * @param userId the user id to search with 2373 * @param status the status to search with 2374 * @param start the lower bound of the range of message-boards messages to return 2375 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2376 * @return the range of matching message-boards messages that the user has permission to view 2377 * @throws SystemException if a system exception occurred 2378 */ 2379 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S( 2380 long groupId, long userId, int status, int start, int end) 2381 throws com.liferay.portal.kernel.exception.SystemException { 2382 return getPersistence() 2383 .filterFindByG_U_S(groupId, userId, status, start, end); 2384 } 2385 2386 /** 2387 * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = ? and userId = ? and status = ?. 2388 * 2389 * <p> 2390 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2391 * </p> 2392 * 2393 * @param groupId the group id to search with 2394 * @param userId the user id to search with 2395 * @param status the status to search with 2396 * @param start the lower bound of the range of message-boards messages to return 2397 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2398 * @param orderByComparator the comparator to order the results by 2399 * @return the ordered range of matching message-boards messages that the user has permission to view 2400 * @throws SystemException if a system exception occurred 2401 */ 2402 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_U_S( 2403 long groupId, long userId, int status, int start, int end, 2404 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2405 throws com.liferay.portal.kernel.exception.SystemException { 2406 return getPersistence() 2407 .filterFindByG_U_S(groupId, userId, status, start, end, 2408 orderByComparator); 2409 } 2410 2411 /** 2412 * Finds all the message-boards messages where groupId = ? and categoryId = ? and threadId = ?. 2413 * 2414 * @param groupId the group id to search with 2415 * @param categoryId the category id to search with 2416 * @param threadId the thread id to search with 2417 * @return the matching message-boards messages 2418 * @throws SystemException if a system exception occurred 2419 */ 2420 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T( 2421 long groupId, long categoryId, long threadId) 2422 throws com.liferay.portal.kernel.exception.SystemException { 2423 return getPersistence().findByG_C_T(groupId, categoryId, threadId); 2424 } 2425 2426 /** 2427 * Finds a range of all the message-boards messages where groupId = ? and categoryId = ? and threadId = ?. 2428 * 2429 * <p> 2430 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2431 * </p> 2432 * 2433 * @param groupId the group id to search with 2434 * @param categoryId the category id to search with 2435 * @param threadId the thread id to search with 2436 * @param start the lower bound of the range of message-boards messages to return 2437 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2438 * @return the range of matching message-boards messages 2439 * @throws SystemException if a system exception occurred 2440 */ 2441 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T( 2442 long groupId, long categoryId, long threadId, int start, int end) 2443 throws com.liferay.portal.kernel.exception.SystemException { 2444 return getPersistence() 2445 .findByG_C_T(groupId, categoryId, threadId, start, end); 2446 } 2447 2448 /** 2449 * Finds an ordered range of all the message-boards messages where groupId = ? and categoryId = ? and threadId = ?. 2450 * 2451 * <p> 2452 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2453 * </p> 2454 * 2455 * @param groupId the group id to search with 2456 * @param categoryId the category id to search with 2457 * @param threadId the thread id to search with 2458 * @param start the lower bound of the range of message-boards messages to return 2459 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2460 * @param orderByComparator the comparator to order the results by 2461 * @return the ordered range of matching message-boards messages 2462 * @throws SystemException if a system exception occurred 2463 */ 2464 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T( 2465 long groupId, long categoryId, long threadId, int start, int end, 2466 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2467 throws com.liferay.portal.kernel.exception.SystemException { 2468 return getPersistence() 2469 .findByG_C_T(groupId, categoryId, threadId, start, end, 2470 orderByComparator); 2471 } 2472 2473 /** 2474 * Finds the first message-boards message in the ordered set where groupId = ? and categoryId = ? and threadId = ?. 2475 * 2476 * <p> 2477 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2478 * </p> 2479 * 2480 * @param groupId the group id to search with 2481 * @param categoryId the category id to search with 2482 * @param threadId the thread id to search with 2483 * @param orderByComparator the comparator to order the set by 2484 * @return the first matching message-boards message 2485 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2486 * @throws SystemException if a system exception occurred 2487 */ 2488 public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_First( 2489 long groupId, long categoryId, long threadId, 2490 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2491 throws com.liferay.portal.kernel.exception.SystemException, 2492 com.liferay.portlet.messageboards.NoSuchMessageException { 2493 return getPersistence() 2494 .findByG_C_T_First(groupId, categoryId, threadId, 2495 orderByComparator); 2496 } 2497 2498 /** 2499 * Finds the last message-boards message in the ordered set where groupId = ? and categoryId = ? and threadId = ?. 2500 * 2501 * <p> 2502 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2503 * </p> 2504 * 2505 * @param groupId the group id to search with 2506 * @param categoryId the category id to search with 2507 * @param threadId the thread id to search with 2508 * @param orderByComparator the comparator to order the set by 2509 * @return the last matching message-boards message 2510 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2511 * @throws SystemException if a system exception occurred 2512 */ 2513 public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_Last( 2514 long groupId, long categoryId, long threadId, 2515 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2516 throws com.liferay.portal.kernel.exception.SystemException, 2517 com.liferay.portlet.messageboards.NoSuchMessageException { 2518 return getPersistence() 2519 .findByG_C_T_Last(groupId, categoryId, threadId, 2520 orderByComparator); 2521 } 2522 2523 /** 2524 * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = ? and categoryId = ? and threadId = ?. 2525 * 2526 * <p> 2527 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2528 * </p> 2529 * 2530 * @param messageId the primary key of the current message-boards message 2531 * @param groupId the group id to search with 2532 * @param categoryId the category id to search with 2533 * @param threadId the thread id to search with 2534 * @param orderByComparator the comparator to order the set by 2535 * @return the previous, current, and next message-boards message 2536 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 2537 * @throws SystemException if a system exception occurred 2538 */ 2539 public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_T_PrevAndNext( 2540 long messageId, long groupId, long categoryId, long threadId, 2541 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2542 throws com.liferay.portal.kernel.exception.SystemException, 2543 com.liferay.portlet.messageboards.NoSuchMessageException { 2544 return getPersistence() 2545 .findByG_C_T_PrevAndNext(messageId, groupId, categoryId, 2546 threadId, orderByComparator); 2547 } 2548 2549 /** 2550 * Filters by the user's permissions and finds all the message-boards messages where groupId = ? and categoryId = ? and threadId = ?. 2551 * 2552 * @param groupId the group id to search with 2553 * @param categoryId the category id to search with 2554 * @param threadId the thread id to search with 2555 * @return the matching message-boards messages that the user has permission to view 2556 * @throws SystemException if a system exception occurred 2557 */ 2558 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T( 2559 long groupId, long categoryId, long threadId) 2560 throws com.liferay.portal.kernel.exception.SystemException { 2561 return getPersistence().filterFindByG_C_T(groupId, categoryId, threadId); 2562 } 2563 2564 /** 2565 * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = ? and categoryId = ? and threadId = ?. 2566 * 2567 * <p> 2568 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2569 * </p> 2570 * 2571 * @param groupId the group id to search with 2572 * @param categoryId the category id to search with 2573 * @param threadId the thread id to search with 2574 * @param start the lower bound of the range of message-boards messages to return 2575 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2576 * @return the range of matching message-boards messages that the user has permission to view 2577 * @throws SystemException if a system exception occurred 2578 */ 2579 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T( 2580 long groupId, long categoryId, long threadId, int start, int end) 2581 throws com.liferay.portal.kernel.exception.SystemException { 2582 return getPersistence() 2583 .filterFindByG_C_T(groupId, categoryId, threadId, start, end); 2584 } 2585 2586 /** 2587 * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = ? and categoryId = ? and threadId = ?. 2588 * 2589 * <p> 2590 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2591 * </p> 2592 * 2593 * @param groupId the group id to search with 2594 * @param categoryId the category id to search with 2595 * @param threadId the thread id to search with 2596 * @param start the lower bound of the range of message-boards messages to return 2597 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2598 * @param orderByComparator the comparator to order the results by 2599 * @return the ordered range of matching message-boards messages that the user has permission to view 2600 * @throws SystemException if a system exception occurred 2601 */ 2602 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T( 2603 long groupId, long categoryId, long threadId, int start, int end, 2604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2605 throws com.liferay.portal.kernel.exception.SystemException { 2606 return getPersistence() 2607 .filterFindByG_C_T(groupId, categoryId, threadId, start, 2608 end, orderByComparator); 2609 } 2610 2611 /** 2612 * Finds all the message-boards messages where groupId = ? and categoryId = ? and status = ?. 2613 * 2614 * @param groupId the group id to search with 2615 * @param categoryId the category id to search with 2616 * @param status the status to search with 2617 * @return the matching message-boards messages 2618 * @throws SystemException if a system exception occurred 2619 */ 2620 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S( 2621 long groupId, long categoryId, int status) 2622 throws com.liferay.portal.kernel.exception.SystemException { 2623 return getPersistence().findByG_C_S(groupId, categoryId, status); 2624 } 2625 2626 /** 2627 * Finds a range of all the message-boards messages where groupId = ? and categoryId = ? and status = ?. 2628 * 2629 * <p> 2630 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2631 * </p> 2632 * 2633 * @param groupId the group id to search with 2634 * @param categoryId the category id to search with 2635 * @param status the status to search with 2636 * @param start the lower bound of the range of message-boards messages to return 2637 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2638 * @return the range of matching message-boards messages 2639 * @throws SystemException if a system exception occurred 2640 */ 2641 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S( 2642 long groupId, long categoryId, int status, int start, int end) 2643 throws com.liferay.portal.kernel.exception.SystemException { 2644 return getPersistence() 2645 .findByG_C_S(groupId, categoryId, status, start, end); 2646 } 2647 2648 /** 2649 * Finds an ordered range of all the message-boards messages where groupId = ? and categoryId = ? and status = ?. 2650 * 2651 * <p> 2652 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2653 * </p> 2654 * 2655 * @param groupId the group id to search with 2656 * @param categoryId the category id to search with 2657 * @param status the status to search with 2658 * @param start the lower bound of the range of message-boards messages to return 2659 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2660 * @param orderByComparator the comparator to order the results by 2661 * @return the ordered range of matching message-boards messages 2662 * @throws SystemException if a system exception occurred 2663 */ 2664 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_S( 2665 long groupId, long categoryId, int status, int start, int end, 2666 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2667 throws com.liferay.portal.kernel.exception.SystemException { 2668 return getPersistence() 2669 .findByG_C_S(groupId, categoryId, status, start, end, 2670 orderByComparator); 2671 } 2672 2673 /** 2674 * Finds the first message-boards message in the ordered set where groupId = ? and categoryId = ? and status = ?. 2675 * 2676 * <p> 2677 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2678 * </p> 2679 * 2680 * @param groupId the group id to search with 2681 * @param categoryId the category id to search with 2682 * @param status the status to search with 2683 * @param orderByComparator the comparator to order the set by 2684 * @return the first matching message-boards message 2685 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2686 * @throws SystemException if a system exception occurred 2687 */ 2688 public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_S_First( 2689 long groupId, long categoryId, int status, 2690 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2691 throws com.liferay.portal.kernel.exception.SystemException, 2692 com.liferay.portlet.messageboards.NoSuchMessageException { 2693 return getPersistence() 2694 .findByG_C_S_First(groupId, categoryId, status, 2695 orderByComparator); 2696 } 2697 2698 /** 2699 * Finds the last message-boards message in the ordered set where groupId = ? and categoryId = ? and status = ?. 2700 * 2701 * <p> 2702 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2703 * </p> 2704 * 2705 * @param groupId the group id to search with 2706 * @param categoryId the category id to search with 2707 * @param status the status to search with 2708 * @param orderByComparator the comparator to order the set by 2709 * @return the last matching message-boards message 2710 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2711 * @throws SystemException if a system exception occurred 2712 */ 2713 public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_S_Last( 2714 long groupId, long categoryId, int status, 2715 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2716 throws com.liferay.portal.kernel.exception.SystemException, 2717 com.liferay.portlet.messageboards.NoSuchMessageException { 2718 return getPersistence() 2719 .findByG_C_S_Last(groupId, categoryId, status, 2720 orderByComparator); 2721 } 2722 2723 /** 2724 * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = ? and categoryId = ? and status = ?. 2725 * 2726 * <p> 2727 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2728 * </p> 2729 * 2730 * @param messageId the primary key of the current message-boards message 2731 * @param groupId the group id to search with 2732 * @param categoryId the category id to search with 2733 * @param status the status to search with 2734 * @param orderByComparator the comparator to order the set by 2735 * @return the previous, current, and next message-boards message 2736 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 2737 * @throws SystemException if a system exception occurred 2738 */ 2739 public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_S_PrevAndNext( 2740 long messageId, long groupId, long categoryId, int status, 2741 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2742 throws com.liferay.portal.kernel.exception.SystemException, 2743 com.liferay.portlet.messageboards.NoSuchMessageException { 2744 return getPersistence() 2745 .findByG_C_S_PrevAndNext(messageId, groupId, categoryId, 2746 status, orderByComparator); 2747 } 2748 2749 /** 2750 * Filters by the user's permissions and finds all the message-boards messages where groupId = ? and categoryId = ? and status = ?. 2751 * 2752 * @param groupId the group id to search with 2753 * @param categoryId the category id to search with 2754 * @param status the status to search with 2755 * @return the matching message-boards messages that the user has permission to view 2756 * @throws SystemException if a system exception occurred 2757 */ 2758 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S( 2759 long groupId, long categoryId, int status) 2760 throws com.liferay.portal.kernel.exception.SystemException { 2761 return getPersistence().filterFindByG_C_S(groupId, categoryId, status); 2762 } 2763 2764 /** 2765 * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = ? and categoryId = ? and status = ?. 2766 * 2767 * <p> 2768 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2769 * </p> 2770 * 2771 * @param groupId the group id to search with 2772 * @param categoryId the category id to search with 2773 * @param status the status to search with 2774 * @param start the lower bound of the range of message-boards messages to return 2775 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2776 * @return the range of matching message-boards messages that the user has permission to view 2777 * @throws SystemException if a system exception occurred 2778 */ 2779 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S( 2780 long groupId, long categoryId, int status, int start, int end) 2781 throws com.liferay.portal.kernel.exception.SystemException { 2782 return getPersistence() 2783 .filterFindByG_C_S(groupId, categoryId, status, start, end); 2784 } 2785 2786 /** 2787 * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = ? and categoryId = ? and status = ?. 2788 * 2789 * <p> 2790 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2791 * </p> 2792 * 2793 * @param groupId the group id to search with 2794 * @param categoryId the category id to search with 2795 * @param status the status to search with 2796 * @param start the lower bound of the range of message-boards messages to return 2797 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2798 * @param orderByComparator the comparator to order the results by 2799 * @return the ordered range of matching message-boards messages that the user has permission to view 2800 * @throws SystemException if a system exception occurred 2801 */ 2802 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_S( 2803 long groupId, long categoryId, int status, int start, int end, 2804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2805 throws com.liferay.portal.kernel.exception.SystemException { 2806 return getPersistence() 2807 .filterFindByG_C_S(groupId, categoryId, status, start, end, 2808 orderByComparator); 2809 } 2810 2811 /** 2812 * Finds all the message-boards messages where classNameId = ? and classPK = ? and status = ?. 2813 * 2814 * @param classNameId the class name id to search with 2815 * @param classPK the class p k to search with 2816 * @param status the status to search with 2817 * @return the matching message-boards messages 2818 * @throws SystemException if a system exception occurred 2819 */ 2820 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S( 2821 long classNameId, long classPK, int status) 2822 throws com.liferay.portal.kernel.exception.SystemException { 2823 return getPersistence().findByC_C_S(classNameId, classPK, status); 2824 } 2825 2826 /** 2827 * Finds a range of all the message-boards messages where classNameId = ? and classPK = ? and status = ?. 2828 * 2829 * <p> 2830 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2831 * </p> 2832 * 2833 * @param classNameId the class name id to search with 2834 * @param classPK the class p k to search with 2835 * @param status the status to search with 2836 * @param start the lower bound of the range of message-boards messages to return 2837 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2838 * @return the range of matching message-boards messages 2839 * @throws SystemException if a system exception occurred 2840 */ 2841 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S( 2842 long classNameId, long classPK, int status, int start, int end) 2843 throws com.liferay.portal.kernel.exception.SystemException { 2844 return getPersistence() 2845 .findByC_C_S(classNameId, classPK, status, start, end); 2846 } 2847 2848 /** 2849 * Finds an ordered range of all the message-boards messages where classNameId = ? and classPK = ? and status = ?. 2850 * 2851 * <p> 2852 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2853 * </p> 2854 * 2855 * @param classNameId the class name id to search with 2856 * @param classPK the class p k to search with 2857 * @param status the status to search with 2858 * @param start the lower bound of the range of message-boards messages to return 2859 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2860 * @param orderByComparator the comparator to order the results by 2861 * @return the ordered range of matching message-boards messages 2862 * @throws SystemException if a system exception occurred 2863 */ 2864 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByC_C_S( 2865 long classNameId, long classPK, int status, int start, int end, 2866 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2867 throws com.liferay.portal.kernel.exception.SystemException { 2868 return getPersistence() 2869 .findByC_C_S(classNameId, classPK, status, start, end, 2870 orderByComparator); 2871 } 2872 2873 /** 2874 * Finds the first message-boards message in the ordered set where classNameId = ? and classPK = ? and status = ?. 2875 * 2876 * <p> 2877 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2878 * </p> 2879 * 2880 * @param classNameId the class name id to search with 2881 * @param classPK the class p k to search with 2882 * @param status the status to search with 2883 * @param orderByComparator the comparator to order the set by 2884 * @return the first matching message-boards message 2885 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2886 * @throws SystemException if a system exception occurred 2887 */ 2888 public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_S_First( 2889 long classNameId, long classPK, int status, 2890 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2891 throws com.liferay.portal.kernel.exception.SystemException, 2892 com.liferay.portlet.messageboards.NoSuchMessageException { 2893 return getPersistence() 2894 .findByC_C_S_First(classNameId, classPK, status, 2895 orderByComparator); 2896 } 2897 2898 /** 2899 * Finds the last message-boards message in the ordered set where classNameId = ? and classPK = ? and status = ?. 2900 * 2901 * <p> 2902 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2903 * </p> 2904 * 2905 * @param classNameId the class name id to search with 2906 * @param classPK the class p k to search with 2907 * @param status the status to search with 2908 * @param orderByComparator the comparator to order the set by 2909 * @return the last matching message-boards message 2910 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 2911 * @throws SystemException if a system exception occurred 2912 */ 2913 public static com.liferay.portlet.messageboards.model.MBMessage findByC_C_S_Last( 2914 long classNameId, long classPK, int status, 2915 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2916 throws com.liferay.portal.kernel.exception.SystemException, 2917 com.liferay.portlet.messageboards.NoSuchMessageException { 2918 return getPersistence() 2919 .findByC_C_S_Last(classNameId, classPK, status, 2920 orderByComparator); 2921 } 2922 2923 /** 2924 * Finds the message-boards messages before and after the current message-boards message in the ordered set where classNameId = ? and classPK = ? and status = ?. 2925 * 2926 * <p> 2927 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2928 * </p> 2929 * 2930 * @param messageId the primary key of the current message-boards message 2931 * @param classNameId the class name id to search with 2932 * @param classPK the class p k to search with 2933 * @param status the status to search with 2934 * @param orderByComparator the comparator to order the set by 2935 * @return the previous, current, and next message-boards message 2936 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 2937 * @throws SystemException if a system exception occurred 2938 */ 2939 public static com.liferay.portlet.messageboards.model.MBMessage[] findByC_C_S_PrevAndNext( 2940 long messageId, long classNameId, long classPK, int status, 2941 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2942 throws com.liferay.portal.kernel.exception.SystemException, 2943 com.liferay.portlet.messageboards.NoSuchMessageException { 2944 return getPersistence() 2945 .findByC_C_S_PrevAndNext(messageId, classNameId, classPK, 2946 status, orderByComparator); 2947 } 2948 2949 /** 2950 * Finds all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ?. 2951 * 2952 * @param groupId the group id to search with 2953 * @param categoryId the category id to search with 2954 * @param threadId the thread id to search with 2955 * @param status the status to search with 2956 * @return the matching message-boards messages 2957 * @throws SystemException if a system exception occurred 2958 */ 2959 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S( 2960 long groupId, long categoryId, long threadId, int status) 2961 throws com.liferay.portal.kernel.exception.SystemException { 2962 return getPersistence() 2963 .findByG_C_T_S(groupId, categoryId, threadId, status); 2964 } 2965 2966 /** 2967 * Finds a range of all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ?. 2968 * 2969 * <p> 2970 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2971 * </p> 2972 * 2973 * @param groupId the group id to search with 2974 * @param categoryId the category id to search with 2975 * @param threadId the thread id to search with 2976 * @param status the status to search with 2977 * @param start the lower bound of the range of message-boards messages to return 2978 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 2979 * @return the range of matching message-boards messages 2980 * @throws SystemException if a system exception occurred 2981 */ 2982 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S( 2983 long groupId, long categoryId, long threadId, int status, int start, 2984 int end) throws com.liferay.portal.kernel.exception.SystemException { 2985 return getPersistence() 2986 .findByG_C_T_S(groupId, categoryId, threadId, status, start, 2987 end); 2988 } 2989 2990 /** 2991 * Finds an ordered range of all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ?. 2992 * 2993 * <p> 2994 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2995 * </p> 2996 * 2997 * @param groupId the group id to search with 2998 * @param categoryId the category id to search with 2999 * @param threadId the thread id to search with 3000 * @param status the status to search with 3001 * @param start the lower bound of the range of message-boards messages to return 3002 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 3003 * @param orderByComparator the comparator to order the results by 3004 * @return the ordered range of matching message-boards messages 3005 * @throws SystemException if a system exception occurred 3006 */ 3007 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findByG_C_T_S( 3008 long groupId, long categoryId, long threadId, int status, int start, 3009 int end, 3010 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3011 throws com.liferay.portal.kernel.exception.SystemException { 3012 return getPersistence() 3013 .findByG_C_T_S(groupId, categoryId, threadId, status, start, 3014 end, orderByComparator); 3015 } 3016 3017 /** 3018 * Finds the first message-boards message in the ordered set where groupId = ? and categoryId = ? and threadId = ? and status = ?. 3019 * 3020 * <p> 3021 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 3022 * </p> 3023 * 3024 * @param groupId the group id to search with 3025 * @param categoryId the category id to search with 3026 * @param threadId the thread id to search with 3027 * @param status the status to search with 3028 * @param orderByComparator the comparator to order the set by 3029 * @return the first matching message-boards message 3030 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 3031 * @throws SystemException if a system exception occurred 3032 */ 3033 public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_S_First( 3034 long groupId, long categoryId, long threadId, int status, 3035 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3036 throws com.liferay.portal.kernel.exception.SystemException, 3037 com.liferay.portlet.messageboards.NoSuchMessageException { 3038 return getPersistence() 3039 .findByG_C_T_S_First(groupId, categoryId, threadId, status, 3040 orderByComparator); 3041 } 3042 3043 /** 3044 * Finds the last message-boards message in the ordered set where groupId = ? and categoryId = ? and threadId = ? and status = ?. 3045 * 3046 * <p> 3047 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 3048 * </p> 3049 * 3050 * @param groupId the group id to search with 3051 * @param categoryId the category id to search with 3052 * @param threadId the thread id to search with 3053 * @param status the status to search with 3054 * @param orderByComparator the comparator to order the set by 3055 * @return the last matching message-boards message 3056 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a matching message-boards message could not be found 3057 * @throws SystemException if a system exception occurred 3058 */ 3059 public static com.liferay.portlet.messageboards.model.MBMessage findByG_C_T_S_Last( 3060 long groupId, long categoryId, long threadId, int status, 3061 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3062 throws com.liferay.portal.kernel.exception.SystemException, 3063 com.liferay.portlet.messageboards.NoSuchMessageException { 3064 return getPersistence() 3065 .findByG_C_T_S_Last(groupId, categoryId, threadId, status, 3066 orderByComparator); 3067 } 3068 3069 /** 3070 * Finds the message-boards messages before and after the current message-boards message in the ordered set where groupId = ? and categoryId = ? and threadId = ? and status = ?. 3071 * 3072 * <p> 3073 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 3074 * </p> 3075 * 3076 * @param messageId the primary key of the current message-boards message 3077 * @param groupId the group id to search with 3078 * @param categoryId the category id to search with 3079 * @param threadId the thread id to search with 3080 * @param status the status to search with 3081 * @param orderByComparator the comparator to order the set by 3082 * @return the previous, current, and next message-boards message 3083 * @throws com.liferay.portlet.messageboards.NoSuchMessageException if a message-boards message with the primary key could not be found 3084 * @throws SystemException if a system exception occurred 3085 */ 3086 public static com.liferay.portlet.messageboards.model.MBMessage[] findByG_C_T_S_PrevAndNext( 3087 long messageId, long groupId, long categoryId, long threadId, 3088 int status, 3089 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3090 throws com.liferay.portal.kernel.exception.SystemException, 3091 com.liferay.portlet.messageboards.NoSuchMessageException { 3092 return getPersistence() 3093 .findByG_C_T_S_PrevAndNext(messageId, groupId, categoryId, 3094 threadId, status, orderByComparator); 3095 } 3096 3097 /** 3098 * Filters by the user's permissions and finds all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ?. 3099 * 3100 * @param groupId the group id to search with 3101 * @param categoryId the category id to search with 3102 * @param threadId the thread id to search with 3103 * @param status the status to search with 3104 * @return the matching message-boards messages that the user has permission to view 3105 * @throws SystemException if a system exception occurred 3106 */ 3107 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S( 3108 long groupId, long categoryId, long threadId, int status) 3109 throws com.liferay.portal.kernel.exception.SystemException { 3110 return getPersistence() 3111 .filterFindByG_C_T_S(groupId, categoryId, threadId, status); 3112 } 3113 3114 /** 3115 * Filters by the user's permissions and finds a range of all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ?. 3116 * 3117 * <p> 3118 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 3119 * </p> 3120 * 3121 * @param groupId the group id to search with 3122 * @param categoryId the category id to search with 3123 * @param threadId the thread id to search with 3124 * @param status the status to search with 3125 * @param start the lower bound of the range of message-boards messages to return 3126 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 3127 * @return the range of matching message-boards messages that the user has permission to view 3128 * @throws SystemException if a system exception occurred 3129 */ 3130 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S( 3131 long groupId, long categoryId, long threadId, int status, int start, 3132 int end) throws com.liferay.portal.kernel.exception.SystemException { 3133 return getPersistence() 3134 .filterFindByG_C_T_S(groupId, categoryId, threadId, status, 3135 start, end); 3136 } 3137 3138 /** 3139 * Filters by the user's permissions and finds an ordered range of all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ?. 3140 * 3141 * <p> 3142 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 3143 * </p> 3144 * 3145 * @param groupId the group id to search with 3146 * @param categoryId the category id to search with 3147 * @param threadId the thread id to search with 3148 * @param status the status to search with 3149 * @param start the lower bound of the range of message-boards messages to return 3150 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 3151 * @param orderByComparator the comparator to order the results by 3152 * @return the ordered range of matching message-boards messages that the user has permission to view 3153 * @throws SystemException if a system exception occurred 3154 */ 3155 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> filterFindByG_C_T_S( 3156 long groupId, long categoryId, long threadId, int status, int start, 3157 int end, 3158 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3159 throws com.liferay.portal.kernel.exception.SystemException { 3160 return getPersistence() 3161 .filterFindByG_C_T_S(groupId, categoryId, threadId, status, 3162 start, end, orderByComparator); 3163 } 3164 3165 /** 3166 * Finds all the message-boards messages. 3167 * 3168 * @return the message-boards messages 3169 * @throws SystemException if a system exception occurred 3170 */ 3171 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll() 3172 throws com.liferay.portal.kernel.exception.SystemException { 3173 return getPersistence().findAll(); 3174 } 3175 3176 /** 3177 * Finds a range of all the message-boards messages. 3178 * 3179 * <p> 3180 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 3181 * </p> 3182 * 3183 * @param start the lower bound of the range of message-boards messages to return 3184 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 3185 * @return the range of message-boards messages 3186 * @throws SystemException if a system exception occurred 3187 */ 3188 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll( 3189 int start, int end) 3190 throws com.liferay.portal.kernel.exception.SystemException { 3191 return getPersistence().findAll(start, end); 3192 } 3193 3194 /** 3195 * Finds an ordered range of all the message-boards messages. 3196 * 3197 * <p> 3198 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 3199 * </p> 3200 * 3201 * @param start the lower bound of the range of message-boards messages to return 3202 * @param end the upper bound of the range of message-boards messages to return (not inclusive) 3203 * @param orderByComparator the comparator to order the results by 3204 * @return the ordered range of message-boards messages 3205 * @throws SystemException if a system exception occurred 3206 */ 3207 public static java.util.List<com.liferay.portlet.messageboards.model.MBMessage> findAll( 3208 int start, int end, 3209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3210 throws com.liferay.portal.kernel.exception.SystemException { 3211 return getPersistence().findAll(start, end, orderByComparator); 3212 } 3213 3214 /** 3215 * Removes all the message-boards messages where uuid = ? from the database. 3216 * 3217 * @param uuid the uuid to search with 3218 * @throws SystemException if a system exception occurred 3219 */ 3220 public static void removeByUuid(java.lang.String uuid) 3221 throws com.liferay.portal.kernel.exception.SystemException { 3222 getPersistence().removeByUuid(uuid); 3223 } 3224 3225 /** 3226 * Removes the message-boards message where uuid = ? and groupId = ? from the database. 3227 * 3228 * @param uuid the uuid to search with 3229 * @param groupId the group id to search with 3230 * @throws SystemException if a system exception occurred 3231 */ 3232 public static void removeByUUID_G(java.lang.String uuid, long groupId) 3233 throws com.liferay.portal.kernel.exception.SystemException, 3234 com.liferay.portlet.messageboards.NoSuchMessageException { 3235 getPersistence().removeByUUID_G(uuid, groupId); 3236 } 3237 3238 /** 3239 * Removes all the message-boards messages where groupId = ? from the database. 3240 * 3241 * @param groupId the group id to search with 3242 * @throws SystemException if a system exception occurred 3243 */ 3244 public static void removeByGroupId(long groupId) 3245 throws com.liferay.portal.kernel.exception.SystemException { 3246 getPersistence().removeByGroupId(groupId); 3247 } 3248 3249 /** 3250 * Removes all the message-boards messages where companyId = ? from the database. 3251 * 3252 * @param companyId the company id to search with 3253 * @throws SystemException if a system exception occurred 3254 */ 3255 public static void removeByCompanyId(long companyId) 3256 throws com.liferay.portal.kernel.exception.SystemException { 3257 getPersistence().removeByCompanyId(companyId); 3258 } 3259 3260 /** 3261 * Removes all the message-boards messages where threadId = ? from the database. 3262 * 3263 * @param threadId the thread id to search with 3264 * @throws SystemException if a system exception occurred 3265 */ 3266 public static void removeByThreadId(long threadId) 3267 throws com.liferay.portal.kernel.exception.SystemException { 3268 getPersistence().removeByThreadId(threadId); 3269 } 3270 3271 /** 3272 * Removes all the message-boards messages where threadId = ? from the database. 3273 * 3274 * @param threadId the thread id to search with 3275 * @throws SystemException if a system exception occurred 3276 */ 3277 public static void removeByThreadReplies(long threadId) 3278 throws com.liferay.portal.kernel.exception.SystemException { 3279 getPersistence().removeByThreadReplies(threadId); 3280 } 3281 3282 /** 3283 * Removes all the message-boards messages where userId = ? from the database. 3284 * 3285 * @param userId the user id to search with 3286 * @throws SystemException if a system exception occurred 3287 */ 3288 public static void removeByUserId(long userId) 3289 throws com.liferay.portal.kernel.exception.SystemException { 3290 getPersistence().removeByUserId(userId); 3291 } 3292 3293 /** 3294 * Removes all the message-boards messages where groupId = ? and userId = ? from the database. 3295 * 3296 * @param groupId the group id to search with 3297 * @param userId the user id to search with 3298 * @throws SystemException if a system exception occurred 3299 */ 3300 public static void removeByG_U(long groupId, long userId) 3301 throws com.liferay.portal.kernel.exception.SystemException { 3302 getPersistence().removeByG_U(groupId, userId); 3303 } 3304 3305 /** 3306 * Removes all the message-boards messages where groupId = ? and categoryId = ? from the database. 3307 * 3308 * @param groupId the group id to search with 3309 * @param categoryId the category id to search with 3310 * @throws SystemException if a system exception occurred 3311 */ 3312 public static void removeByG_C(long groupId, long categoryId) 3313 throws com.liferay.portal.kernel.exception.SystemException { 3314 getPersistence().removeByG_C(groupId, categoryId); 3315 } 3316 3317 /** 3318 * Removes all the message-boards messages where groupId = ? and status = ? from the database. 3319 * 3320 * @param groupId the group id to search with 3321 * @param status the status to search with 3322 * @throws SystemException if a system exception occurred 3323 */ 3324 public static void removeByG_S(long groupId, int status) 3325 throws com.liferay.portal.kernel.exception.SystemException { 3326 getPersistence().removeByG_S(groupId, status); 3327 } 3328 3329 /** 3330 * Removes all the message-boards messages where companyId = ? and status = ? from the database. 3331 * 3332 * @param companyId the company id to search with 3333 * @param status the status to search with 3334 * @throws SystemException if a system exception occurred 3335 */ 3336 public static void removeByC_S(long companyId, int status) 3337 throws com.liferay.portal.kernel.exception.SystemException { 3338 getPersistence().removeByC_S(companyId, status); 3339 } 3340 3341 /** 3342 * Removes all the message-boards messages where classNameId = ? and classPK = ? from the database. 3343 * 3344 * @param classNameId the class name id to search with 3345 * @param classPK the class p k to search with 3346 * @throws SystemException if a system exception occurred 3347 */ 3348 public static void removeByC_C(long classNameId, long classPK) 3349 throws com.liferay.portal.kernel.exception.SystemException { 3350 getPersistence().removeByC_C(classNameId, classPK); 3351 } 3352 3353 /** 3354 * Removes all the message-boards messages where threadId = ? and parentMessageId = ? from the database. 3355 * 3356 * @param threadId the thread id to search with 3357 * @param parentMessageId the parent message id to search with 3358 * @throws SystemException if a system exception occurred 3359 */ 3360 public static void removeByT_P(long threadId, long parentMessageId) 3361 throws com.liferay.portal.kernel.exception.SystemException { 3362 getPersistence().removeByT_P(threadId, parentMessageId); 3363 } 3364 3365 /** 3366 * Removes all the message-boards messages where threadId = ? and status = ? from the database. 3367 * 3368 * @param threadId the thread id to search with 3369 * @param status the status to search with 3370 * @throws SystemException if a system exception occurred 3371 */ 3372 public static void removeByT_S(long threadId, int status) 3373 throws com.liferay.portal.kernel.exception.SystemException { 3374 getPersistence().removeByT_S(threadId, status); 3375 } 3376 3377 /** 3378 * Removes all the message-boards messages where threadId = ? and status = ? from the database. 3379 * 3380 * @param threadId the thread id to search with 3381 * @param status the status to search with 3382 * @throws SystemException if a system exception occurred 3383 */ 3384 public static void removeByTR_S(long threadId, int status) 3385 throws com.liferay.portal.kernel.exception.SystemException { 3386 getPersistence().removeByTR_S(threadId, status); 3387 } 3388 3389 /** 3390 * Removes all the message-boards messages where groupId = ? and userId = ? and status = ? from the database. 3391 * 3392 * @param groupId the group id to search with 3393 * @param userId the user id to search with 3394 * @param status the status to search with 3395 * @throws SystemException if a system exception occurred 3396 */ 3397 public static void removeByG_U_S(long groupId, long userId, int status) 3398 throws com.liferay.portal.kernel.exception.SystemException { 3399 getPersistence().removeByG_U_S(groupId, userId, status); 3400 } 3401 3402 /** 3403 * Removes all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? from the database. 3404 * 3405 * @param groupId the group id to search with 3406 * @param categoryId the category id to search with 3407 * @param threadId the thread id to search with 3408 * @throws SystemException if a system exception occurred 3409 */ 3410 public static void removeByG_C_T(long groupId, long categoryId, 3411 long threadId) 3412 throws com.liferay.portal.kernel.exception.SystemException { 3413 getPersistence().removeByG_C_T(groupId, categoryId, threadId); 3414 } 3415 3416 /** 3417 * Removes all the message-boards messages where groupId = ? and categoryId = ? and status = ? from the database. 3418 * 3419 * @param groupId the group id to search with 3420 * @param categoryId the category id to search with 3421 * @param status the status to search with 3422 * @throws SystemException if a system exception occurred 3423 */ 3424 public static void removeByG_C_S(long groupId, long categoryId, int status) 3425 throws com.liferay.portal.kernel.exception.SystemException { 3426 getPersistence().removeByG_C_S(groupId, categoryId, status); 3427 } 3428 3429 /** 3430 * Removes all the message-boards messages where classNameId = ? and classPK = ? and status = ? from the database. 3431 * 3432 * @param classNameId the class name id to search with 3433 * @param classPK the class p k to search with 3434 * @param status the status to search with 3435 * @throws SystemException if a system exception occurred 3436 */ 3437 public static void removeByC_C_S(long classNameId, long classPK, int status) 3438 throws com.liferay.portal.kernel.exception.SystemException { 3439 getPersistence().removeByC_C_S(classNameId, classPK, status); 3440 } 3441 3442 /** 3443 * Removes all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ? from the database. 3444 * 3445 * @param groupId the group id to search with 3446 * @param categoryId the category id to search with 3447 * @param threadId the thread id to search with 3448 * @param status the status to search with 3449 * @throws SystemException if a system exception occurred 3450 */ 3451 public static void removeByG_C_T_S(long groupId, long categoryId, 3452 long threadId, int status) 3453 throws com.liferay.portal.kernel.exception.SystemException { 3454 getPersistence().removeByG_C_T_S(groupId, categoryId, threadId, status); 3455 } 3456 3457 /** 3458 * Removes all the message-boards messages from the database. 3459 * 3460 * @throws SystemException if a system exception occurred 3461 */ 3462 public static void removeAll() 3463 throws com.liferay.portal.kernel.exception.SystemException { 3464 getPersistence().removeAll(); 3465 } 3466 3467 /** 3468 * Counts all the message-boards messages where uuid = ?. 3469 * 3470 * @param uuid the uuid to search with 3471 * @return the number of matching message-boards messages 3472 * @throws SystemException if a system exception occurred 3473 */ 3474 public static int countByUuid(java.lang.String uuid) 3475 throws com.liferay.portal.kernel.exception.SystemException { 3476 return getPersistence().countByUuid(uuid); 3477 } 3478 3479 /** 3480 * Counts all the message-boards messages where uuid = ? and groupId = ?. 3481 * 3482 * @param uuid the uuid to search with 3483 * @param groupId the group id to search with 3484 * @return the number of matching message-boards messages 3485 * @throws SystemException if a system exception occurred 3486 */ 3487 public static int countByUUID_G(java.lang.String uuid, long groupId) 3488 throws com.liferay.portal.kernel.exception.SystemException { 3489 return getPersistence().countByUUID_G(uuid, groupId); 3490 } 3491 3492 /** 3493 * Counts all the message-boards messages where groupId = ?. 3494 * 3495 * @param groupId the group id to search with 3496 * @return the number of matching message-boards messages 3497 * @throws SystemException if a system exception occurred 3498 */ 3499 public static int countByGroupId(long groupId) 3500 throws com.liferay.portal.kernel.exception.SystemException { 3501 return getPersistence().countByGroupId(groupId); 3502 } 3503 3504 /** 3505 * Filters by the user's permissions and counts all the message-boards messages where groupId = ?. 3506 * 3507 * @param groupId the group id to search with 3508 * @return the number of matching message-boards messages that the user has permission to view 3509 * @throws SystemException if a system exception occurred 3510 */ 3511 public static int filterCountByGroupId(long groupId) 3512 throws com.liferay.portal.kernel.exception.SystemException { 3513 return getPersistence().filterCountByGroupId(groupId); 3514 } 3515 3516 /** 3517 * Counts all the message-boards messages where companyId = ?. 3518 * 3519 * @param companyId the company id to search with 3520 * @return the number of matching message-boards messages 3521 * @throws SystemException if a system exception occurred 3522 */ 3523 public static int countByCompanyId(long companyId) 3524 throws com.liferay.portal.kernel.exception.SystemException { 3525 return getPersistence().countByCompanyId(companyId); 3526 } 3527 3528 /** 3529 * Counts all the message-boards messages where threadId = ?. 3530 * 3531 * @param threadId the thread id to search with 3532 * @return the number of matching message-boards messages 3533 * @throws SystemException if a system exception occurred 3534 */ 3535 public static int countByThreadId(long threadId) 3536 throws com.liferay.portal.kernel.exception.SystemException { 3537 return getPersistence().countByThreadId(threadId); 3538 } 3539 3540 /** 3541 * Counts all the message-boards messages where threadId = ?. 3542 * 3543 * @param threadId the thread id to search with 3544 * @return the number of matching message-boards messages 3545 * @throws SystemException if a system exception occurred 3546 */ 3547 public static int countByThreadReplies(long threadId) 3548 throws com.liferay.portal.kernel.exception.SystemException { 3549 return getPersistence().countByThreadReplies(threadId); 3550 } 3551 3552 /** 3553 * Counts all the message-boards messages where userId = ?. 3554 * 3555 * @param userId the user id to search with 3556 * @return the number of matching message-boards messages 3557 * @throws SystemException if a system exception occurred 3558 */ 3559 public static int countByUserId(long userId) 3560 throws com.liferay.portal.kernel.exception.SystemException { 3561 return getPersistence().countByUserId(userId); 3562 } 3563 3564 /** 3565 * Counts all the message-boards messages where groupId = ? and userId = ?. 3566 * 3567 * @param groupId the group id to search with 3568 * @param userId the user id to search with 3569 * @return the number of matching message-boards messages 3570 * @throws SystemException if a system exception occurred 3571 */ 3572 public static int countByG_U(long groupId, long userId) 3573 throws com.liferay.portal.kernel.exception.SystemException { 3574 return getPersistence().countByG_U(groupId, userId); 3575 } 3576 3577 /** 3578 * Filters by the user's permissions and counts all the message-boards messages where groupId = ? and userId = ?. 3579 * 3580 * @param groupId the group id to search with 3581 * @param userId the user id to search with 3582 * @return the number of matching message-boards messages that the user has permission to view 3583 * @throws SystemException if a system exception occurred 3584 */ 3585 public static int filterCountByG_U(long groupId, long userId) 3586 throws com.liferay.portal.kernel.exception.SystemException { 3587 return getPersistence().filterCountByG_U(groupId, userId); 3588 } 3589 3590 /** 3591 * Counts all the message-boards messages where groupId = ? and categoryId = ?. 3592 * 3593 * @param groupId the group id to search with 3594 * @param categoryId the category id to search with 3595 * @return the number of matching message-boards messages 3596 * @throws SystemException if a system exception occurred 3597 */ 3598 public static int countByG_C(long groupId, long categoryId) 3599 throws com.liferay.portal.kernel.exception.SystemException { 3600 return getPersistence().countByG_C(groupId, categoryId); 3601 } 3602 3603 /** 3604 * Filters by the user's permissions and counts all the message-boards messages where groupId = ? and categoryId = ?. 3605 * 3606 * @param groupId the group id to search with 3607 * @param categoryId the category id to search with 3608 * @return the number of matching message-boards messages that the user has permission to view 3609 * @throws SystemException if a system exception occurred 3610 */ 3611 public static int filterCountByG_C(long groupId, long categoryId) 3612 throws com.liferay.portal.kernel.exception.SystemException { 3613 return getPersistence().filterCountByG_C(groupId, categoryId); 3614 } 3615 3616 /** 3617 * Counts all the message-boards messages where groupId = ? and status = ?. 3618 * 3619 * @param groupId the group id to search with 3620 * @param status the status to search with 3621 * @return the number of matching message-boards messages 3622 * @throws SystemException if a system exception occurred 3623 */ 3624 public static int countByG_S(long groupId, int status) 3625 throws com.liferay.portal.kernel.exception.SystemException { 3626 return getPersistence().countByG_S(groupId, status); 3627 } 3628 3629 /** 3630 * Filters by the user's permissions and counts all the message-boards messages where groupId = ? and status = ?. 3631 * 3632 * @param groupId the group id to search with 3633 * @param status the status to search with 3634 * @return the number of matching message-boards messages that the user has permission to view 3635 * @throws SystemException if a system exception occurred 3636 */ 3637 public static int filterCountByG_S(long groupId, int status) 3638 throws com.liferay.portal.kernel.exception.SystemException { 3639 return getPersistence().filterCountByG_S(groupId, status); 3640 } 3641 3642 /** 3643 * Counts all the message-boards messages where companyId = ? and status = ?. 3644 * 3645 * @param companyId the company id to search with 3646 * @param status the status to search with 3647 * @return the number of matching message-boards messages 3648 * @throws SystemException if a system exception occurred 3649 */ 3650 public static int countByC_S(long companyId, int status) 3651 throws com.liferay.portal.kernel.exception.SystemException { 3652 return getPersistence().countByC_S(companyId, status); 3653 } 3654 3655 /** 3656 * Counts all the message-boards messages where classNameId = ? and classPK = ?. 3657 * 3658 * @param classNameId the class name id to search with 3659 * @param classPK the class p k to search with 3660 * @return the number of matching message-boards messages 3661 * @throws SystemException if a system exception occurred 3662 */ 3663 public static int countByC_C(long classNameId, long classPK) 3664 throws com.liferay.portal.kernel.exception.SystemException { 3665 return getPersistence().countByC_C(classNameId, classPK); 3666 } 3667 3668 /** 3669 * Counts all the message-boards messages where threadId = ? and parentMessageId = ?. 3670 * 3671 * @param threadId the thread id to search with 3672 * @param parentMessageId the parent message id to search with 3673 * @return the number of matching message-boards messages 3674 * @throws SystemException if a system exception occurred 3675 */ 3676 public static int countByT_P(long threadId, long parentMessageId) 3677 throws com.liferay.portal.kernel.exception.SystemException { 3678 return getPersistence().countByT_P(threadId, parentMessageId); 3679 } 3680 3681 /** 3682 * Counts all the message-boards messages where threadId = ? and status = ?. 3683 * 3684 * @param threadId the thread id to search with 3685 * @param status the status to search with 3686 * @return the number of matching message-boards messages 3687 * @throws SystemException if a system exception occurred 3688 */ 3689 public static int countByT_S(long threadId, int status) 3690 throws com.liferay.portal.kernel.exception.SystemException { 3691 return getPersistence().countByT_S(threadId, status); 3692 } 3693 3694 /** 3695 * Counts all the message-boards messages where threadId = ? and status = ?. 3696 * 3697 * @param threadId the thread id to search with 3698 * @param status the status to search with 3699 * @return the number of matching message-boards messages 3700 * @throws SystemException if a system exception occurred 3701 */ 3702 public static int countByTR_S(long threadId, int status) 3703 throws com.liferay.portal.kernel.exception.SystemException { 3704 return getPersistence().countByTR_S(threadId, status); 3705 } 3706 3707 /** 3708 * Counts all the message-boards messages where groupId = ? and userId = ? and status = ?. 3709 * 3710 * @param groupId the group id to search with 3711 * @param userId the user id to search with 3712 * @param status the status to search with 3713 * @return the number of matching message-boards messages 3714 * @throws SystemException if a system exception occurred 3715 */ 3716 public static int countByG_U_S(long groupId, long userId, int status) 3717 throws com.liferay.portal.kernel.exception.SystemException { 3718 return getPersistence().countByG_U_S(groupId, userId, status); 3719 } 3720 3721 /** 3722 * Filters by the user's permissions and counts all the message-boards messages where groupId = ? and userId = ? and status = ?. 3723 * 3724 * @param groupId the group id to search with 3725 * @param userId the user id to search with 3726 * @param status the status to search with 3727 * @return the number of matching message-boards messages that the user has permission to view 3728 * @throws SystemException if a system exception occurred 3729 */ 3730 public static int filterCountByG_U_S(long groupId, long userId, int status) 3731 throws com.liferay.portal.kernel.exception.SystemException { 3732 return getPersistence().filterCountByG_U_S(groupId, userId, status); 3733 } 3734 3735 /** 3736 * Counts all the message-boards messages where groupId = ? and categoryId = ? and threadId = ?. 3737 * 3738 * @param groupId the group id to search with 3739 * @param categoryId the category id to search with 3740 * @param threadId the thread id to search with 3741 * @return the number of matching message-boards messages 3742 * @throws SystemException if a system exception occurred 3743 */ 3744 public static int countByG_C_T(long groupId, long categoryId, long threadId) 3745 throws com.liferay.portal.kernel.exception.SystemException { 3746 return getPersistence().countByG_C_T(groupId, categoryId, threadId); 3747 } 3748 3749 /** 3750 * Filters by the user's permissions and counts all the message-boards messages where groupId = ? and categoryId = ? and threadId = ?. 3751 * 3752 * @param groupId the group id to search with 3753 * @param categoryId the category id to search with 3754 * @param threadId the thread id to search with 3755 * @return the number of matching message-boards messages that the user has permission to view 3756 * @throws SystemException if a system exception occurred 3757 */ 3758 public static int filterCountByG_C_T(long groupId, long categoryId, 3759 long threadId) 3760 throws com.liferay.portal.kernel.exception.SystemException { 3761 return getPersistence().filterCountByG_C_T(groupId, categoryId, threadId); 3762 } 3763 3764 /** 3765 * Counts all the message-boards messages where groupId = ? and categoryId = ? and status = ?. 3766 * 3767 * @param groupId the group id to search with 3768 * @param categoryId the category id to search with 3769 * @param status the status to search with 3770 * @return the number of matching message-boards messages 3771 * @throws SystemException if a system exception occurred 3772 */ 3773 public static int countByG_C_S(long groupId, long categoryId, int status) 3774 throws com.liferay.portal.kernel.exception.SystemException { 3775 return getPersistence().countByG_C_S(groupId, categoryId, status); 3776 } 3777 3778 /** 3779 * Filters by the user's permissions and counts all the message-boards messages where groupId = ? and categoryId = ? and status = ?. 3780 * 3781 * @param groupId the group id to search with 3782 * @param categoryId the category id to search with 3783 * @param status the status to search with 3784 * @return the number of matching message-boards messages that the user has permission to view 3785 * @throws SystemException if a system exception occurred 3786 */ 3787 public static int filterCountByG_C_S(long groupId, long categoryId, 3788 int status) throws com.liferay.portal.kernel.exception.SystemException { 3789 return getPersistence().filterCountByG_C_S(groupId, categoryId, status); 3790 } 3791 3792 /** 3793 * Counts all the message-boards messages where classNameId = ? and classPK = ? and status = ?. 3794 * 3795 * @param classNameId the class name id to search with 3796 * @param classPK the class p k to search with 3797 * @param status the status to search with 3798 * @return the number of matching message-boards messages 3799 * @throws SystemException if a system exception occurred 3800 */ 3801 public static int countByC_C_S(long classNameId, long classPK, int status) 3802 throws com.liferay.portal.kernel.exception.SystemException { 3803 return getPersistence().countByC_C_S(classNameId, classPK, status); 3804 } 3805 3806 /** 3807 * Counts all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ?. 3808 * 3809 * @param groupId the group id to search with 3810 * @param categoryId the category id to search with 3811 * @param threadId the thread id to search with 3812 * @param status the status to search with 3813 * @return the number of matching message-boards messages 3814 * @throws SystemException if a system exception occurred 3815 */ 3816 public static int countByG_C_T_S(long groupId, long categoryId, 3817 long threadId, int status) 3818 throws com.liferay.portal.kernel.exception.SystemException { 3819 return getPersistence() 3820 .countByG_C_T_S(groupId, categoryId, threadId, status); 3821 } 3822 3823 /** 3824 * Filters by the user's permissions and counts all the message-boards messages where groupId = ? and categoryId = ? and threadId = ? and status = ?. 3825 * 3826 * @param groupId the group id to search with 3827 * @param categoryId the category id to search with 3828 * @param threadId the thread id to search with 3829 * @param status the status to search with 3830 * @return the number of matching message-boards messages that the user has permission to view 3831 * @throws SystemException if a system exception occurred 3832 */ 3833 public static int filterCountByG_C_T_S(long groupId, long categoryId, 3834 long threadId, int status) 3835 throws com.liferay.portal.kernel.exception.SystemException { 3836 return getPersistence() 3837 .filterCountByG_C_T_S(groupId, categoryId, threadId, status); 3838 } 3839 3840 /** 3841 * Counts all the message-boards messages. 3842 * 3843 * @return the number of message-boards messages 3844 * @throws SystemException if a system exception occurred 3845 */ 3846 public static int countAll() 3847 throws com.liferay.portal.kernel.exception.SystemException { 3848 return getPersistence().countAll(); 3849 } 3850 3851 public static MBMessagePersistence getPersistence() { 3852 if (_persistence == null) { 3853 _persistence = (MBMessagePersistence)PortalBeanLocatorUtil.locate(MBMessagePersistence.class.getName()); 3854 } 3855 3856 return _persistence; 3857 } 3858 3859 public void setPersistence(MBMessagePersistence persistence) { 3860 _persistence = persistence; 3861 } 3862 3863 private static MBMessagePersistence _persistence; 3864 }