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