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