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