001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.journal.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.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#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static JournalArticle update(JournalArticle journalArticle) 101 throws SystemException { 102 return getPersistence().update(journalArticle); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static JournalArticle update(JournalArticle journalArticle, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(journalArticle, serviceContext); 111 } 112 113 /** 114 * Returns all the journal articles where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching journal articles 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 121 java.lang.String uuid) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByUuid(uuid); 124 } 125 126 /** 127 * Returns a range of all the journal articles where uuid = ?. 128 * 129 * <p> 130 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 131 * </p> 132 * 133 * @param uuid the uuid 134 * @param start the lower bound of the range of journal articles 135 * @param end the upper bound of the range of journal articles (not inclusive) 136 * @return the range of matching journal articles 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 140 java.lang.String uuid, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByUuid(uuid, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the journal articles where uuid = ?. 147 * 148 * <p> 149 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 150 * </p> 151 * 152 * @param uuid the uuid 153 * @param start the lower bound of the range of journal articles 154 * @param end the upper bound of the range of journal articles (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching journal articles 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 160 java.lang.String uuid, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 164 } 165 166 /** 167 * Returns the first journal article in the ordered set where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 171 * @return the first matching journal article 172 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First( 176 java.lang.String uuid, 177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.journal.NoSuchArticleException { 180 return getPersistence().findByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the first journal article in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 189 * @throws SystemException if a system exception occurred 190 */ 191 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First( 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 194 throws com.liferay.portal.kernel.exception.SystemException { 195 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 196 } 197 198 /** 199 * Returns the last journal article in the ordered set where uuid = ?. 200 * 201 * @param uuid the uuid 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching journal article 204 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 205 * @throws SystemException if a system exception occurred 206 */ 207 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last( 208 java.lang.String uuid, 209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 210 throws com.liferay.portal.kernel.exception.SystemException, 211 com.liferay.portlet.journal.NoSuchArticleException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last journal article in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 221 * @throws SystemException if a system exception occurred 222 */ 223 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last( 224 java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 226 throws com.liferay.portal.kernel.exception.SystemException { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the journal articles before and after the current journal article in the ordered set where uuid = ?. 232 * 233 * @param id the primary key of the current journal article 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next journal article 237 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 238 * @throws SystemException if a system exception occurred 239 */ 240 public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext( 241 long id, java.lang.String uuid, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException, 244 com.liferay.portlet.journal.NoSuchArticleException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 247 } 248 249 /** 250 * Removes all the journal articles where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 * @throws SystemException if a system exception occurred 254 */ 255 public static void removeByUuid(java.lang.String uuid) 256 throws com.liferay.portal.kernel.exception.SystemException { 257 getPersistence().removeByUuid(uuid); 258 } 259 260 /** 261 * Returns the number of journal articles where uuid = ?. 262 * 263 * @param uuid the uuid 264 * @return the number of matching journal articles 265 * @throws SystemException if a system exception occurred 266 */ 267 public static int countByUuid(java.lang.String uuid) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 return getPersistence().countByUuid(uuid); 270 } 271 272 /** 273 * Returns the journal article where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @return the matching journal article 278 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G( 282 java.lang.String uuid, long groupId) 283 throws com.liferay.portal.kernel.exception.SystemException, 284 com.liferay.portlet.journal.NoSuchArticleException { 285 return getPersistence().findByUUID_G(uuid, groupId); 286 } 287 288 /** 289 * Returns the journal article where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 290 * 291 * @param uuid the uuid 292 * @param groupId the group ID 293 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 294 * @throws SystemException if a system exception occurred 295 */ 296 public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G( 297 java.lang.String uuid, long groupId) 298 throws com.liferay.portal.kernel.exception.SystemException { 299 return getPersistence().fetchByUUID_G(uuid, groupId); 300 } 301 302 /** 303 * Returns the journal article where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @param retrieveFromCache whether to use the finder cache 308 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 309 * @throws SystemException if a system exception occurred 310 */ 311 public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G( 312 java.lang.String uuid, long groupId, boolean retrieveFromCache) 313 throws com.liferay.portal.kernel.exception.SystemException { 314 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 315 } 316 317 /** 318 * Removes the journal article where uuid = ? and groupId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param groupId the group ID 322 * @return the journal article that was removed 323 * @throws SystemException if a system exception occurred 324 */ 325 public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.journal.NoSuchArticleException { 329 return getPersistence().removeByUUID_G(uuid, groupId); 330 } 331 332 /** 333 * Returns the number of journal articles where uuid = ? and groupId = ?. 334 * 335 * @param uuid the uuid 336 * @param groupId the group ID 337 * @return the number of matching journal articles 338 * @throws SystemException if a system exception occurred 339 */ 340 public static int countByUUID_G(java.lang.String uuid, long groupId) 341 throws com.liferay.portal.kernel.exception.SystemException { 342 return getPersistence().countByUUID_G(uuid, groupId); 343 } 344 345 /** 346 * Returns all the journal articles where uuid = ? and companyId = ?. 347 * 348 * @param uuid the uuid 349 * @param companyId the company ID 350 * @return the matching journal articles 351 * @throws SystemException if a system exception occurred 352 */ 353 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 354 java.lang.String uuid, long companyId) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().findByUuid_C(uuid, companyId); 357 } 358 359 /** 360 * Returns a range of all the journal articles where uuid = ? and companyId = ?. 361 * 362 * <p> 363 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 364 * </p> 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @param start the lower bound of the range of journal articles 369 * @param end the upper bound of the range of journal articles (not inclusive) 370 * @return the range of matching journal articles 371 * @throws SystemException if a system exception occurred 372 */ 373 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 374 java.lang.String uuid, long companyId, int start, int end) 375 throws com.liferay.portal.kernel.exception.SystemException { 376 return getPersistence().findByUuid_C(uuid, companyId, start, end); 377 } 378 379 /** 380 * Returns an ordered range of all the journal articles where uuid = ? and companyId = ?. 381 * 382 * <p> 383 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 384 * </p> 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param start the lower bound of the range of journal articles 389 * @param end the upper bound of the range of journal articles (not inclusive) 390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 391 * @return the ordered range of matching journal articles 392 * @throws SystemException if a system exception occurred 393 */ 394 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 395 java.lang.String uuid, long companyId, int start, int end, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence() 399 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 400 } 401 402 /** 403 * Returns the first journal article in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the first matching journal article 409 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First( 413 java.lang.String uuid, long companyId, 414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 415 throws com.liferay.portal.kernel.exception.SystemException, 416 com.liferay.portlet.journal.NoSuchArticleException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first journal article in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 428 * @throws SystemException if a system exception occurred 429 */ 430 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First( 431 java.lang.String uuid, long companyId, 432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 433 throws com.liferay.portal.kernel.exception.SystemException { 434 return getPersistence() 435 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 436 } 437 438 /** 439 * Returns the last journal article in the ordered set where uuid = ? and companyId = ?. 440 * 441 * @param uuid the uuid 442 * @param companyId the company ID 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the last matching journal article 445 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 446 * @throws SystemException if a system exception occurred 447 */ 448 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last( 449 java.lang.String uuid, long companyId, 450 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 451 throws com.liferay.portal.kernel.exception.SystemException, 452 com.liferay.portlet.journal.NoSuchArticleException { 453 return getPersistence() 454 .findByUuid_C_Last(uuid, companyId, orderByComparator); 455 } 456 457 /** 458 * Returns the last journal article in the ordered set where uuid = ? and companyId = ?. 459 * 460 * @param uuid the uuid 461 * @param companyId the company ID 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 463 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last( 467 java.lang.String uuid, long companyId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence() 471 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 472 } 473 474 /** 475 * Returns the journal articles before and after the current journal article in the ordered set where uuid = ? and companyId = ?. 476 * 477 * @param id the primary key of the current journal article 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the previous, current, and next journal article 482 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 483 * @throws SystemException if a system exception occurred 484 */ 485 public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext( 486 long id, java.lang.String uuid, long companyId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.journal.NoSuchArticleException { 490 return getPersistence() 491 .findByUuid_C_PrevAndNext(id, uuid, companyId, 492 orderByComparator); 493 } 494 495 /** 496 * Removes all the journal articles where uuid = ? and companyId = ? from the database. 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @throws SystemException if a system exception occurred 501 */ 502 public static void removeByUuid_C(java.lang.String uuid, long companyId) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 getPersistence().removeByUuid_C(uuid, companyId); 505 } 506 507 /** 508 * Returns the number of journal articles where uuid = ? and companyId = ?. 509 * 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @return the number of matching journal articles 513 * @throws SystemException if a system exception occurred 514 */ 515 public static int countByUuid_C(java.lang.String uuid, long companyId) 516 throws com.liferay.portal.kernel.exception.SystemException { 517 return getPersistence().countByUuid_C(uuid, companyId); 518 } 519 520 /** 521 * Returns all the journal articles where resourcePrimKey = ?. 522 * 523 * @param resourcePrimKey the resource prim key 524 * @return the matching journal articles 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 528 long resourcePrimKey) 529 throws com.liferay.portal.kernel.exception.SystemException { 530 return getPersistence().findByResourcePrimKey(resourcePrimKey); 531 } 532 533 /** 534 * Returns a range of all the journal articles where resourcePrimKey = ?. 535 * 536 * <p> 537 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 538 * </p> 539 * 540 * @param resourcePrimKey the resource prim key 541 * @param start the lower bound of the range of journal articles 542 * @param end the upper bound of the range of journal articles (not inclusive) 543 * @return the range of matching journal articles 544 * @throws SystemException if a system exception occurred 545 */ 546 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 547 long resourcePrimKey, int start, int end) 548 throws com.liferay.portal.kernel.exception.SystemException { 549 return getPersistence() 550 .findByResourcePrimKey(resourcePrimKey, start, end); 551 } 552 553 /** 554 * Returns an ordered range of all the journal articles where resourcePrimKey = ?. 555 * 556 * <p> 557 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 558 * </p> 559 * 560 * @param resourcePrimKey the resource prim key 561 * @param start the lower bound of the range of journal articles 562 * @param end the upper bound of the range of journal articles (not inclusive) 563 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 564 * @return the ordered range of matching journal articles 565 * @throws SystemException if a system exception occurred 566 */ 567 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 568 long resourcePrimKey, int start, int end, 569 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 570 throws com.liferay.portal.kernel.exception.SystemException { 571 return getPersistence() 572 .findByResourcePrimKey(resourcePrimKey, start, end, 573 orderByComparator); 574 } 575 576 /** 577 * Returns the first journal article in the ordered set where resourcePrimKey = ?. 578 * 579 * @param resourcePrimKey the resource prim key 580 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 581 * @return the first matching journal article 582 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 583 * @throws SystemException if a system exception occurred 584 */ 585 public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First( 586 long resourcePrimKey, 587 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 588 throws com.liferay.portal.kernel.exception.SystemException, 589 com.liferay.portlet.journal.NoSuchArticleException { 590 return getPersistence() 591 .findByResourcePrimKey_First(resourcePrimKey, 592 orderByComparator); 593 } 594 595 /** 596 * Returns the first journal article in the ordered set where resourcePrimKey = ?. 597 * 598 * @param resourcePrimKey the resource prim key 599 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 600 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 601 * @throws SystemException if a system exception occurred 602 */ 603 public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First( 604 long resourcePrimKey, 605 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 606 throws com.liferay.portal.kernel.exception.SystemException { 607 return getPersistence() 608 .fetchByResourcePrimKey_First(resourcePrimKey, 609 orderByComparator); 610 } 611 612 /** 613 * Returns the last journal article in the ordered set where resourcePrimKey = ?. 614 * 615 * @param resourcePrimKey the resource prim key 616 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 617 * @return the last matching journal article 618 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 619 * @throws SystemException if a system exception occurred 620 */ 621 public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last( 622 long resourcePrimKey, 623 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 624 throws com.liferay.portal.kernel.exception.SystemException, 625 com.liferay.portlet.journal.NoSuchArticleException { 626 return getPersistence() 627 .findByResourcePrimKey_Last(resourcePrimKey, 628 orderByComparator); 629 } 630 631 /** 632 * Returns the last journal article in the ordered set where resourcePrimKey = ?. 633 * 634 * @param resourcePrimKey the resource prim key 635 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 636 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 637 * @throws SystemException if a system exception occurred 638 */ 639 public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last( 640 long resourcePrimKey, 641 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 642 throws com.liferay.portal.kernel.exception.SystemException { 643 return getPersistence() 644 .fetchByResourcePrimKey_Last(resourcePrimKey, 645 orderByComparator); 646 } 647 648 /** 649 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ?. 650 * 651 * @param id the primary key of the current journal article 652 * @param resourcePrimKey the resource prim key 653 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 654 * @return the previous, current, and next journal article 655 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 656 * @throws SystemException if a system exception occurred 657 */ 658 public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext( 659 long id, long resourcePrimKey, 660 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 661 throws com.liferay.portal.kernel.exception.SystemException, 662 com.liferay.portlet.journal.NoSuchArticleException { 663 return getPersistence() 664 .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey, 665 orderByComparator); 666 } 667 668 /** 669 * Removes all the journal articles where resourcePrimKey = ? from the database. 670 * 671 * @param resourcePrimKey the resource prim key 672 * @throws SystemException if a system exception occurred 673 */ 674 public static void removeByResourcePrimKey(long resourcePrimKey) 675 throws com.liferay.portal.kernel.exception.SystemException { 676 getPersistence().removeByResourcePrimKey(resourcePrimKey); 677 } 678 679 /** 680 * Returns the number of journal articles where resourcePrimKey = ?. 681 * 682 * @param resourcePrimKey the resource prim key 683 * @return the number of matching journal articles 684 * @throws SystemException if a system exception occurred 685 */ 686 public static int countByResourcePrimKey(long resourcePrimKey) 687 throws com.liferay.portal.kernel.exception.SystemException { 688 return getPersistence().countByResourcePrimKey(resourcePrimKey); 689 } 690 691 /** 692 * Returns all the journal articles where groupId = ?. 693 * 694 * @param groupId the group ID 695 * @return the matching journal articles 696 * @throws SystemException if a system exception occurred 697 */ 698 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 699 long groupId) 700 throws com.liferay.portal.kernel.exception.SystemException { 701 return getPersistence().findByGroupId(groupId); 702 } 703 704 /** 705 * Returns a range of all the journal articles where groupId = ?. 706 * 707 * <p> 708 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 709 * </p> 710 * 711 * @param groupId the group ID 712 * @param start the lower bound of the range of journal articles 713 * @param end the upper bound of the range of journal articles (not inclusive) 714 * @return the range of matching journal articles 715 * @throws SystemException if a system exception occurred 716 */ 717 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 718 long groupId, int start, int end) 719 throws com.liferay.portal.kernel.exception.SystemException { 720 return getPersistence().findByGroupId(groupId, start, end); 721 } 722 723 /** 724 * Returns an ordered range of all the journal articles where groupId = ?. 725 * 726 * <p> 727 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 728 * </p> 729 * 730 * @param groupId the group ID 731 * @param start the lower bound of the range of journal articles 732 * @param end the upper bound of the range of journal articles (not inclusive) 733 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 734 * @return the ordered range of matching journal articles 735 * @throws SystemException if a system exception occurred 736 */ 737 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 738 long groupId, int start, int end, 739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 740 throws com.liferay.portal.kernel.exception.SystemException { 741 return getPersistence() 742 .findByGroupId(groupId, start, end, orderByComparator); 743 } 744 745 /** 746 * Returns the first journal article in the ordered set where groupId = ?. 747 * 748 * @param groupId the group ID 749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 750 * @return the first matching journal article 751 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 752 * @throws SystemException if a system exception occurred 753 */ 754 public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First( 755 long groupId, 756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 757 throws com.liferay.portal.kernel.exception.SystemException, 758 com.liferay.portlet.journal.NoSuchArticleException { 759 return getPersistence().findByGroupId_First(groupId, orderByComparator); 760 } 761 762 /** 763 * Returns the first journal article in the ordered set where groupId = ?. 764 * 765 * @param groupId the group ID 766 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 767 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 768 * @throws SystemException if a system exception occurred 769 */ 770 public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First( 771 long groupId, 772 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 775 } 776 777 /** 778 * Returns the last journal article in the ordered set where groupId = ?. 779 * 780 * @param groupId the group ID 781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 782 * @return the last matching journal article 783 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 784 * @throws SystemException if a system exception occurred 785 */ 786 public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last( 787 long groupId, 788 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 789 throws com.liferay.portal.kernel.exception.SystemException, 790 com.liferay.portlet.journal.NoSuchArticleException { 791 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 792 } 793 794 /** 795 * Returns the last journal article in the ordered set where groupId = ?. 796 * 797 * @param groupId the group ID 798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 799 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 800 * @throws SystemException if a system exception occurred 801 */ 802 public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last( 803 long groupId, 804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 805 throws com.liferay.portal.kernel.exception.SystemException { 806 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 807 } 808 809 /** 810 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ?. 811 * 812 * @param id the primary key of the current journal article 813 * @param groupId the group ID 814 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 815 * @return the previous, current, and next journal article 816 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 817 * @throws SystemException if a system exception occurred 818 */ 819 public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext( 820 long id, long groupId, 821 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 822 throws com.liferay.portal.kernel.exception.SystemException, 823 com.liferay.portlet.journal.NoSuchArticleException { 824 return getPersistence() 825 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 826 } 827 828 /** 829 * Returns all the journal articles that the user has permission to view where groupId = ?. 830 * 831 * @param groupId the group ID 832 * @return the matching journal articles that the user has permission to view 833 * @throws SystemException if a system exception occurred 834 */ 835 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 836 long groupId) 837 throws com.liferay.portal.kernel.exception.SystemException { 838 return getPersistence().filterFindByGroupId(groupId); 839 } 840 841 /** 842 * Returns a range of all the journal articles that the user has permission to view where groupId = ?. 843 * 844 * <p> 845 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 846 * </p> 847 * 848 * @param groupId the group ID 849 * @param start the lower bound of the range of journal articles 850 * @param end the upper bound of the range of journal articles (not inclusive) 851 * @return the range of matching journal articles that the user has permission to view 852 * @throws SystemException if a system exception occurred 853 */ 854 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 855 long groupId, int start, int end) 856 throws com.liferay.portal.kernel.exception.SystemException { 857 return getPersistence().filterFindByGroupId(groupId, start, end); 858 } 859 860 /** 861 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ?. 862 * 863 * <p> 864 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 865 * </p> 866 * 867 * @param groupId the group ID 868 * @param start the lower bound of the range of journal articles 869 * @param end the upper bound of the range of journal articles (not inclusive) 870 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 871 * @return the ordered range of matching journal articles that the user has permission to view 872 * @throws SystemException if a system exception occurred 873 */ 874 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 875 long groupId, int start, int end, 876 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 877 throws com.liferay.portal.kernel.exception.SystemException { 878 return getPersistence() 879 .filterFindByGroupId(groupId, start, end, orderByComparator); 880 } 881 882 /** 883 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ?. 884 * 885 * @param id the primary key of the current journal article 886 * @param groupId the group ID 887 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 888 * @return the previous, current, and next journal article 889 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 890 * @throws SystemException if a system exception occurred 891 */ 892 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext( 893 long id, long groupId, 894 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 895 throws com.liferay.portal.kernel.exception.SystemException, 896 com.liferay.portlet.journal.NoSuchArticleException { 897 return getPersistence() 898 .filterFindByGroupId_PrevAndNext(id, groupId, 899 orderByComparator); 900 } 901 902 /** 903 * Removes all the journal articles where groupId = ? from the database. 904 * 905 * @param groupId the group ID 906 * @throws SystemException if a system exception occurred 907 */ 908 public static void removeByGroupId(long groupId) 909 throws com.liferay.portal.kernel.exception.SystemException { 910 getPersistence().removeByGroupId(groupId); 911 } 912 913 /** 914 * Returns the number of journal articles where groupId = ?. 915 * 916 * @param groupId the group ID 917 * @return the number of matching journal articles 918 * @throws SystemException if a system exception occurred 919 */ 920 public static int countByGroupId(long groupId) 921 throws com.liferay.portal.kernel.exception.SystemException { 922 return getPersistence().countByGroupId(groupId); 923 } 924 925 /** 926 * Returns the number of journal articles that the user has permission to view where groupId = ?. 927 * 928 * @param groupId the group ID 929 * @return the number of matching journal articles that the user has permission to view 930 * @throws SystemException if a system exception occurred 931 */ 932 public static int filterCountByGroupId(long groupId) 933 throws com.liferay.portal.kernel.exception.SystemException { 934 return getPersistence().filterCountByGroupId(groupId); 935 } 936 937 /** 938 * Returns all the journal articles where companyId = ?. 939 * 940 * @param companyId the company ID 941 * @return the matching journal articles 942 * @throws SystemException if a system exception occurred 943 */ 944 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 945 long companyId) 946 throws com.liferay.portal.kernel.exception.SystemException { 947 return getPersistence().findByCompanyId(companyId); 948 } 949 950 /** 951 * Returns a range of all the journal articles where companyId = ?. 952 * 953 * <p> 954 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 955 * </p> 956 * 957 * @param companyId the company ID 958 * @param start the lower bound of the range of journal articles 959 * @param end the upper bound of the range of journal articles (not inclusive) 960 * @return the range of matching journal articles 961 * @throws SystemException if a system exception occurred 962 */ 963 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 964 long companyId, int start, int end) 965 throws com.liferay.portal.kernel.exception.SystemException { 966 return getPersistence().findByCompanyId(companyId, start, end); 967 } 968 969 /** 970 * Returns an ordered range of all the journal articles where companyId = ?. 971 * 972 * <p> 973 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 974 * </p> 975 * 976 * @param companyId the company ID 977 * @param start the lower bound of the range of journal articles 978 * @param end the upper bound of the range of journal articles (not inclusive) 979 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 980 * @return the ordered range of matching journal articles 981 * @throws SystemException if a system exception occurred 982 */ 983 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 984 long companyId, int start, int end, 985 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 986 throws com.liferay.portal.kernel.exception.SystemException { 987 return getPersistence() 988 .findByCompanyId(companyId, start, end, orderByComparator); 989 } 990 991 /** 992 * Returns the first journal article in the ordered set where companyId = ?. 993 * 994 * @param companyId the company ID 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the first matching journal article 997 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 998 * @throws SystemException if a system exception occurred 999 */ 1000 public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First( 1001 long companyId, 1002 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1003 throws com.liferay.portal.kernel.exception.SystemException, 1004 com.liferay.portlet.journal.NoSuchArticleException { 1005 return getPersistence() 1006 .findByCompanyId_First(companyId, orderByComparator); 1007 } 1008 1009 /** 1010 * Returns the first journal article in the ordered set where companyId = ?. 1011 * 1012 * @param companyId the company ID 1013 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1014 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1015 * @throws SystemException if a system exception occurred 1016 */ 1017 public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First( 1018 long companyId, 1019 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1020 throws com.liferay.portal.kernel.exception.SystemException { 1021 return getPersistence() 1022 .fetchByCompanyId_First(companyId, orderByComparator); 1023 } 1024 1025 /** 1026 * Returns the last journal article in the ordered set where companyId = ?. 1027 * 1028 * @param companyId the company ID 1029 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1030 * @return the last matching journal article 1031 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last( 1035 long companyId, 1036 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1037 throws com.liferay.portal.kernel.exception.SystemException, 1038 com.liferay.portlet.journal.NoSuchArticleException { 1039 return getPersistence() 1040 .findByCompanyId_Last(companyId, orderByComparator); 1041 } 1042 1043 /** 1044 * Returns the last journal article in the ordered set where companyId = ?. 1045 * 1046 * @param companyId the company ID 1047 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1048 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1049 * @throws SystemException if a system exception occurred 1050 */ 1051 public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last( 1052 long companyId, 1053 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1054 throws com.liferay.portal.kernel.exception.SystemException { 1055 return getPersistence() 1056 .fetchByCompanyId_Last(companyId, orderByComparator); 1057 } 1058 1059 /** 1060 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ?. 1061 * 1062 * @param id the primary key of the current journal article 1063 * @param companyId the company ID 1064 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1065 * @return the previous, current, and next journal article 1066 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1067 * @throws SystemException if a system exception occurred 1068 */ 1069 public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext( 1070 long id, long companyId, 1071 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1072 throws com.liferay.portal.kernel.exception.SystemException, 1073 com.liferay.portlet.journal.NoSuchArticleException { 1074 return getPersistence() 1075 .findByCompanyId_PrevAndNext(id, companyId, orderByComparator); 1076 } 1077 1078 /** 1079 * Removes all the journal articles where companyId = ? from the database. 1080 * 1081 * @param companyId the company ID 1082 * @throws SystemException if a system exception occurred 1083 */ 1084 public static void removeByCompanyId(long companyId) 1085 throws com.liferay.portal.kernel.exception.SystemException { 1086 getPersistence().removeByCompanyId(companyId); 1087 } 1088 1089 /** 1090 * Returns the number of journal articles where companyId = ?. 1091 * 1092 * @param companyId the company ID 1093 * @return the number of matching journal articles 1094 * @throws SystemException if a system exception occurred 1095 */ 1096 public static int countByCompanyId(long companyId) 1097 throws com.liferay.portal.kernel.exception.SystemException { 1098 return getPersistence().countByCompanyId(companyId); 1099 } 1100 1101 /** 1102 * Returns all the journal articles where structureId = ?. 1103 * 1104 * @param structureId the structure ID 1105 * @return the matching journal articles 1106 * @throws SystemException if a system exception occurred 1107 */ 1108 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1109 java.lang.String structureId) 1110 throws com.liferay.portal.kernel.exception.SystemException { 1111 return getPersistence().findByStructureId(structureId); 1112 } 1113 1114 /** 1115 * Returns a range of all the journal articles where structureId = ?. 1116 * 1117 * <p> 1118 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1119 * </p> 1120 * 1121 * @param structureId the structure ID 1122 * @param start the lower bound of the range of journal articles 1123 * @param end the upper bound of the range of journal articles (not inclusive) 1124 * @return the range of matching journal articles 1125 * @throws SystemException if a system exception occurred 1126 */ 1127 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1128 java.lang.String structureId, int start, int end) 1129 throws com.liferay.portal.kernel.exception.SystemException { 1130 return getPersistence().findByStructureId(structureId, start, end); 1131 } 1132 1133 /** 1134 * Returns an ordered range of all the journal articles where structureId = ?. 1135 * 1136 * <p> 1137 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1138 * </p> 1139 * 1140 * @param structureId the structure ID 1141 * @param start the lower bound of the range of journal articles 1142 * @param end the upper bound of the range of journal articles (not inclusive) 1143 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1144 * @return the ordered range of matching journal articles 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1148 java.lang.String structureId, int start, int end, 1149 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1150 throws com.liferay.portal.kernel.exception.SystemException { 1151 return getPersistence() 1152 .findByStructureId(structureId, start, end, orderByComparator); 1153 } 1154 1155 /** 1156 * Returns the first journal article in the ordered set where structureId = ?. 1157 * 1158 * @param structureId the structure ID 1159 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1160 * @return the first matching journal article 1161 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1162 * @throws SystemException if a system exception occurred 1163 */ 1164 public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First( 1165 java.lang.String structureId, 1166 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1167 throws com.liferay.portal.kernel.exception.SystemException, 1168 com.liferay.portlet.journal.NoSuchArticleException { 1169 return getPersistence() 1170 .findByStructureId_First(structureId, orderByComparator); 1171 } 1172 1173 /** 1174 * Returns the first journal article in the ordered set where structureId = ?. 1175 * 1176 * @param structureId the structure ID 1177 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1178 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1179 * @throws SystemException if a system exception occurred 1180 */ 1181 public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First( 1182 java.lang.String structureId, 1183 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1184 throws com.liferay.portal.kernel.exception.SystemException { 1185 return getPersistence() 1186 .fetchByStructureId_First(structureId, orderByComparator); 1187 } 1188 1189 /** 1190 * Returns the last journal article in the ordered set where structureId = ?. 1191 * 1192 * @param structureId the structure ID 1193 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1194 * @return the last matching journal article 1195 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1196 * @throws SystemException if a system exception occurred 1197 */ 1198 public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last( 1199 java.lang.String structureId, 1200 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1201 throws com.liferay.portal.kernel.exception.SystemException, 1202 com.liferay.portlet.journal.NoSuchArticleException { 1203 return getPersistence() 1204 .findByStructureId_Last(structureId, orderByComparator); 1205 } 1206 1207 /** 1208 * Returns the last journal article in the ordered set where structureId = ?. 1209 * 1210 * @param structureId the structure ID 1211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1212 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1213 * @throws SystemException if a system exception occurred 1214 */ 1215 public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last( 1216 java.lang.String structureId, 1217 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1218 throws com.liferay.portal.kernel.exception.SystemException { 1219 return getPersistence() 1220 .fetchByStructureId_Last(structureId, orderByComparator); 1221 } 1222 1223 /** 1224 * Returns the journal articles before and after the current journal article in the ordered set where structureId = ?. 1225 * 1226 * @param id the primary key of the current journal article 1227 * @param structureId the structure ID 1228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1229 * @return the previous, current, and next journal article 1230 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1231 * @throws SystemException if a system exception occurred 1232 */ 1233 public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext( 1234 long id, java.lang.String structureId, 1235 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1236 throws com.liferay.portal.kernel.exception.SystemException, 1237 com.liferay.portlet.journal.NoSuchArticleException { 1238 return getPersistence() 1239 .findByStructureId_PrevAndNext(id, structureId, 1240 orderByComparator); 1241 } 1242 1243 /** 1244 * Returns all the journal articles where structureId = any ?. 1245 * 1246 * <p> 1247 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1248 * </p> 1249 * 1250 * @param structureIds the structure IDs 1251 * @return the matching journal articles 1252 * @throws SystemException if a system exception occurred 1253 */ 1254 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1255 java.lang.String[] structureIds) 1256 throws com.liferay.portal.kernel.exception.SystemException { 1257 return getPersistence().findByStructureId(structureIds); 1258 } 1259 1260 /** 1261 * Returns a range of all the journal articles where structureId = any ?. 1262 * 1263 * <p> 1264 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1265 * </p> 1266 * 1267 * @param structureIds the structure IDs 1268 * @param start the lower bound of the range of journal articles 1269 * @param end the upper bound of the range of journal articles (not inclusive) 1270 * @return the range of matching journal articles 1271 * @throws SystemException if a system exception occurred 1272 */ 1273 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1274 java.lang.String[] structureIds, int start, int end) 1275 throws com.liferay.portal.kernel.exception.SystemException { 1276 return getPersistence().findByStructureId(structureIds, start, end); 1277 } 1278 1279 /** 1280 * Returns an ordered range of all the journal articles where structureId = any ?. 1281 * 1282 * <p> 1283 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1284 * </p> 1285 * 1286 * @param structureIds the structure IDs 1287 * @param start the lower bound of the range of journal articles 1288 * @param end the upper bound of the range of journal articles (not inclusive) 1289 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1290 * @return the ordered range of matching journal articles 1291 * @throws SystemException if a system exception occurred 1292 */ 1293 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1294 java.lang.String[] structureIds, int start, int end, 1295 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1296 throws com.liferay.portal.kernel.exception.SystemException { 1297 return getPersistence() 1298 .findByStructureId(structureIds, start, end, 1299 orderByComparator); 1300 } 1301 1302 /** 1303 * Removes all the journal articles where structureId = ? from the database. 1304 * 1305 * @param structureId the structure ID 1306 * @throws SystemException if a system exception occurred 1307 */ 1308 public static void removeByStructureId(java.lang.String structureId) 1309 throws com.liferay.portal.kernel.exception.SystemException { 1310 getPersistence().removeByStructureId(structureId); 1311 } 1312 1313 /** 1314 * Returns the number of journal articles where structureId = ?. 1315 * 1316 * @param structureId the structure ID 1317 * @return the number of matching journal articles 1318 * @throws SystemException if a system exception occurred 1319 */ 1320 public static int countByStructureId(java.lang.String structureId) 1321 throws com.liferay.portal.kernel.exception.SystemException { 1322 return getPersistence().countByStructureId(structureId); 1323 } 1324 1325 /** 1326 * Returns the number of journal articles where structureId = any ?. 1327 * 1328 * @param structureIds the structure IDs 1329 * @return the number of matching journal articles 1330 * @throws SystemException if a system exception occurred 1331 */ 1332 public static int countByStructureId(java.lang.String[] structureIds) 1333 throws com.liferay.portal.kernel.exception.SystemException { 1334 return getPersistence().countByStructureId(structureIds); 1335 } 1336 1337 /** 1338 * Returns all the journal articles where templateId = ?. 1339 * 1340 * @param templateId the template ID 1341 * @return the matching journal articles 1342 * @throws SystemException if a system exception occurred 1343 */ 1344 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1345 java.lang.String templateId) 1346 throws com.liferay.portal.kernel.exception.SystemException { 1347 return getPersistence().findByTemplateId(templateId); 1348 } 1349 1350 /** 1351 * Returns a range of all the journal articles where templateId = ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1355 * </p> 1356 * 1357 * @param templateId the template ID 1358 * @param start the lower bound of the range of journal articles 1359 * @param end the upper bound of the range of journal articles (not inclusive) 1360 * @return the range of matching journal articles 1361 * @throws SystemException if a system exception occurred 1362 */ 1363 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1364 java.lang.String templateId, int start, int end) 1365 throws com.liferay.portal.kernel.exception.SystemException { 1366 return getPersistence().findByTemplateId(templateId, start, end); 1367 } 1368 1369 /** 1370 * Returns an ordered range of all the journal articles where templateId = ?. 1371 * 1372 * <p> 1373 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1374 * </p> 1375 * 1376 * @param templateId the template ID 1377 * @param start the lower bound of the range of journal articles 1378 * @param end the upper bound of the range of journal articles (not inclusive) 1379 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1380 * @return the ordered range of matching journal articles 1381 * @throws SystemException if a system exception occurred 1382 */ 1383 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1384 java.lang.String templateId, int start, int end, 1385 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1386 throws com.liferay.portal.kernel.exception.SystemException { 1387 return getPersistence() 1388 .findByTemplateId(templateId, start, end, orderByComparator); 1389 } 1390 1391 /** 1392 * Returns the first journal article in the ordered set where templateId = ?. 1393 * 1394 * @param templateId the template ID 1395 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1396 * @return the first matching journal article 1397 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1398 * @throws SystemException if a system exception occurred 1399 */ 1400 public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First( 1401 java.lang.String templateId, 1402 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1403 throws com.liferay.portal.kernel.exception.SystemException, 1404 com.liferay.portlet.journal.NoSuchArticleException { 1405 return getPersistence() 1406 .findByTemplateId_First(templateId, orderByComparator); 1407 } 1408 1409 /** 1410 * Returns the first journal article in the ordered set where templateId = ?. 1411 * 1412 * @param templateId the template ID 1413 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1414 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1415 * @throws SystemException if a system exception occurred 1416 */ 1417 public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First( 1418 java.lang.String templateId, 1419 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1420 throws com.liferay.portal.kernel.exception.SystemException { 1421 return getPersistence() 1422 .fetchByTemplateId_First(templateId, orderByComparator); 1423 } 1424 1425 /** 1426 * Returns the last journal article in the ordered set where templateId = ?. 1427 * 1428 * @param templateId the template ID 1429 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1430 * @return the last matching journal article 1431 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1432 * @throws SystemException if a system exception occurred 1433 */ 1434 public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last( 1435 java.lang.String templateId, 1436 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1437 throws com.liferay.portal.kernel.exception.SystemException, 1438 com.liferay.portlet.journal.NoSuchArticleException { 1439 return getPersistence() 1440 .findByTemplateId_Last(templateId, orderByComparator); 1441 } 1442 1443 /** 1444 * Returns the last journal article in the ordered set where templateId = ?. 1445 * 1446 * @param templateId the template ID 1447 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1448 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1449 * @throws SystemException if a system exception occurred 1450 */ 1451 public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last( 1452 java.lang.String templateId, 1453 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1454 throws com.liferay.portal.kernel.exception.SystemException { 1455 return getPersistence() 1456 .fetchByTemplateId_Last(templateId, orderByComparator); 1457 } 1458 1459 /** 1460 * Returns the journal articles before and after the current journal article in the ordered set where templateId = ?. 1461 * 1462 * @param id the primary key of the current journal article 1463 * @param templateId the template ID 1464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1465 * @return the previous, current, and next journal article 1466 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1467 * @throws SystemException if a system exception occurred 1468 */ 1469 public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext( 1470 long id, java.lang.String templateId, 1471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1472 throws com.liferay.portal.kernel.exception.SystemException, 1473 com.liferay.portlet.journal.NoSuchArticleException { 1474 return getPersistence() 1475 .findByTemplateId_PrevAndNext(id, templateId, 1476 orderByComparator); 1477 } 1478 1479 /** 1480 * Removes all the journal articles where templateId = ? from the database. 1481 * 1482 * @param templateId the template ID 1483 * @throws SystemException if a system exception occurred 1484 */ 1485 public static void removeByTemplateId(java.lang.String templateId) 1486 throws com.liferay.portal.kernel.exception.SystemException { 1487 getPersistence().removeByTemplateId(templateId); 1488 } 1489 1490 /** 1491 * Returns the number of journal articles where templateId = ?. 1492 * 1493 * @param templateId the template ID 1494 * @return the number of matching journal articles 1495 * @throws SystemException if a system exception occurred 1496 */ 1497 public static int countByTemplateId(java.lang.String templateId) 1498 throws com.liferay.portal.kernel.exception.SystemException { 1499 return getPersistence().countByTemplateId(templateId); 1500 } 1501 1502 /** 1503 * Returns all the journal articles where layoutUuid = ?. 1504 * 1505 * @param layoutUuid the layout uuid 1506 * @return the matching journal articles 1507 * @throws SystemException if a system exception occurred 1508 */ 1509 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1510 java.lang.String layoutUuid) 1511 throws com.liferay.portal.kernel.exception.SystemException { 1512 return getPersistence().findByLayoutUuid(layoutUuid); 1513 } 1514 1515 /** 1516 * Returns a range of all the journal articles where layoutUuid = ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1520 * </p> 1521 * 1522 * @param layoutUuid the layout uuid 1523 * @param start the lower bound of the range of journal articles 1524 * @param end the upper bound of the range of journal articles (not inclusive) 1525 * @return the range of matching journal articles 1526 * @throws SystemException if a system exception occurred 1527 */ 1528 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1529 java.lang.String layoutUuid, int start, int end) 1530 throws com.liferay.portal.kernel.exception.SystemException { 1531 return getPersistence().findByLayoutUuid(layoutUuid, start, end); 1532 } 1533 1534 /** 1535 * Returns an ordered range of all the journal articles where layoutUuid = ?. 1536 * 1537 * <p> 1538 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1539 * </p> 1540 * 1541 * @param layoutUuid the layout uuid 1542 * @param start the lower bound of the range of journal articles 1543 * @param end the upper bound of the range of journal articles (not inclusive) 1544 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1545 * @return the ordered range of matching journal articles 1546 * @throws SystemException if a system exception occurred 1547 */ 1548 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1549 java.lang.String layoutUuid, int start, int end, 1550 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1551 throws com.liferay.portal.kernel.exception.SystemException { 1552 return getPersistence() 1553 .findByLayoutUuid(layoutUuid, start, end, orderByComparator); 1554 } 1555 1556 /** 1557 * Returns the first journal article in the ordered set where layoutUuid = ?. 1558 * 1559 * @param layoutUuid the layout uuid 1560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1561 * @return the first matching journal article 1562 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1563 * @throws SystemException if a system exception occurred 1564 */ 1565 public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First( 1566 java.lang.String layoutUuid, 1567 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1568 throws com.liferay.portal.kernel.exception.SystemException, 1569 com.liferay.portlet.journal.NoSuchArticleException { 1570 return getPersistence() 1571 .findByLayoutUuid_First(layoutUuid, orderByComparator); 1572 } 1573 1574 /** 1575 * Returns the first journal article in the ordered set where layoutUuid = ?. 1576 * 1577 * @param layoutUuid the layout uuid 1578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1579 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1580 * @throws SystemException if a system exception occurred 1581 */ 1582 public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First( 1583 java.lang.String layoutUuid, 1584 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1585 throws com.liferay.portal.kernel.exception.SystemException { 1586 return getPersistence() 1587 .fetchByLayoutUuid_First(layoutUuid, orderByComparator); 1588 } 1589 1590 /** 1591 * Returns the last journal article in the ordered set where layoutUuid = ?. 1592 * 1593 * @param layoutUuid the layout uuid 1594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1595 * @return the last matching journal article 1596 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1597 * @throws SystemException if a system exception occurred 1598 */ 1599 public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last( 1600 java.lang.String layoutUuid, 1601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1602 throws com.liferay.portal.kernel.exception.SystemException, 1603 com.liferay.portlet.journal.NoSuchArticleException { 1604 return getPersistence() 1605 .findByLayoutUuid_Last(layoutUuid, orderByComparator); 1606 } 1607 1608 /** 1609 * Returns the last journal article in the ordered set where layoutUuid = ?. 1610 * 1611 * @param layoutUuid the layout uuid 1612 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1613 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1614 * @throws SystemException if a system exception occurred 1615 */ 1616 public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last( 1617 java.lang.String layoutUuid, 1618 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1619 throws com.liferay.portal.kernel.exception.SystemException { 1620 return getPersistence() 1621 .fetchByLayoutUuid_Last(layoutUuid, orderByComparator); 1622 } 1623 1624 /** 1625 * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = ?. 1626 * 1627 * @param id the primary key of the current journal article 1628 * @param layoutUuid the layout uuid 1629 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1630 * @return the previous, current, and next journal article 1631 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1632 * @throws SystemException if a system exception occurred 1633 */ 1634 public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext( 1635 long id, java.lang.String layoutUuid, 1636 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1637 throws com.liferay.portal.kernel.exception.SystemException, 1638 com.liferay.portlet.journal.NoSuchArticleException { 1639 return getPersistence() 1640 .findByLayoutUuid_PrevAndNext(id, layoutUuid, 1641 orderByComparator); 1642 } 1643 1644 /** 1645 * Removes all the journal articles where layoutUuid = ? from the database. 1646 * 1647 * @param layoutUuid the layout uuid 1648 * @throws SystemException if a system exception occurred 1649 */ 1650 public static void removeByLayoutUuid(java.lang.String layoutUuid) 1651 throws com.liferay.portal.kernel.exception.SystemException { 1652 getPersistence().removeByLayoutUuid(layoutUuid); 1653 } 1654 1655 /** 1656 * Returns the number of journal articles where layoutUuid = ?. 1657 * 1658 * @param layoutUuid the layout uuid 1659 * @return the number of matching journal articles 1660 * @throws SystemException if a system exception occurred 1661 */ 1662 public static int countByLayoutUuid(java.lang.String layoutUuid) 1663 throws com.liferay.portal.kernel.exception.SystemException { 1664 return getPersistence().countByLayoutUuid(layoutUuid); 1665 } 1666 1667 /** 1668 * Returns all the journal articles where smallImageId = ?. 1669 * 1670 * @param smallImageId the small image ID 1671 * @return the matching journal articles 1672 * @throws SystemException if a system exception occurred 1673 */ 1674 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1675 long smallImageId) 1676 throws com.liferay.portal.kernel.exception.SystemException { 1677 return getPersistence().findBySmallImageId(smallImageId); 1678 } 1679 1680 /** 1681 * Returns a range of all the journal articles where smallImageId = ?. 1682 * 1683 * <p> 1684 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1685 * </p> 1686 * 1687 * @param smallImageId the small image ID 1688 * @param start the lower bound of the range of journal articles 1689 * @param end the upper bound of the range of journal articles (not inclusive) 1690 * @return the range of matching journal articles 1691 * @throws SystemException if a system exception occurred 1692 */ 1693 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1694 long smallImageId, int start, int end) 1695 throws com.liferay.portal.kernel.exception.SystemException { 1696 return getPersistence().findBySmallImageId(smallImageId, start, end); 1697 } 1698 1699 /** 1700 * Returns an ordered range of all the journal articles where smallImageId = ?. 1701 * 1702 * <p> 1703 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1704 * </p> 1705 * 1706 * @param smallImageId the small image ID 1707 * @param start the lower bound of the range of journal articles 1708 * @param end the upper bound of the range of journal articles (not inclusive) 1709 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1710 * @return the ordered range of matching journal articles 1711 * @throws SystemException if a system exception occurred 1712 */ 1713 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1714 long smallImageId, int start, int end, 1715 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1716 throws com.liferay.portal.kernel.exception.SystemException { 1717 return getPersistence() 1718 .findBySmallImageId(smallImageId, start, end, 1719 orderByComparator); 1720 } 1721 1722 /** 1723 * Returns the first journal article in the ordered set where smallImageId = ?. 1724 * 1725 * @param smallImageId the small image ID 1726 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1727 * @return the first matching journal article 1728 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1729 * @throws SystemException if a system exception occurred 1730 */ 1731 public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First( 1732 long smallImageId, 1733 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1734 throws com.liferay.portal.kernel.exception.SystemException, 1735 com.liferay.portlet.journal.NoSuchArticleException { 1736 return getPersistence() 1737 .findBySmallImageId_First(smallImageId, orderByComparator); 1738 } 1739 1740 /** 1741 * Returns the first journal article in the ordered set where smallImageId = ?. 1742 * 1743 * @param smallImageId the small image ID 1744 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1745 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1746 * @throws SystemException if a system exception occurred 1747 */ 1748 public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First( 1749 long smallImageId, 1750 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1751 throws com.liferay.portal.kernel.exception.SystemException { 1752 return getPersistence() 1753 .fetchBySmallImageId_First(smallImageId, orderByComparator); 1754 } 1755 1756 /** 1757 * Returns the last journal article in the ordered set where smallImageId = ?. 1758 * 1759 * @param smallImageId the small image ID 1760 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1761 * @return the last matching journal article 1762 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1763 * @throws SystemException if a system exception occurred 1764 */ 1765 public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last( 1766 long smallImageId, 1767 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1768 throws com.liferay.portal.kernel.exception.SystemException, 1769 com.liferay.portlet.journal.NoSuchArticleException { 1770 return getPersistence() 1771 .findBySmallImageId_Last(smallImageId, orderByComparator); 1772 } 1773 1774 /** 1775 * Returns the last journal article in the ordered set where smallImageId = ?. 1776 * 1777 * @param smallImageId the small image ID 1778 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1779 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1780 * @throws SystemException if a system exception occurred 1781 */ 1782 public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last( 1783 long smallImageId, 1784 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1785 throws com.liferay.portal.kernel.exception.SystemException { 1786 return getPersistence() 1787 .fetchBySmallImageId_Last(smallImageId, orderByComparator); 1788 } 1789 1790 /** 1791 * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = ?. 1792 * 1793 * @param id the primary key of the current journal article 1794 * @param smallImageId the small image ID 1795 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1796 * @return the previous, current, and next journal article 1797 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1798 * @throws SystemException if a system exception occurred 1799 */ 1800 public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext( 1801 long id, long smallImageId, 1802 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1803 throws com.liferay.portal.kernel.exception.SystemException, 1804 com.liferay.portlet.journal.NoSuchArticleException { 1805 return getPersistence() 1806 .findBySmallImageId_PrevAndNext(id, smallImageId, 1807 orderByComparator); 1808 } 1809 1810 /** 1811 * Removes all the journal articles where smallImageId = ? from the database. 1812 * 1813 * @param smallImageId the small image ID 1814 * @throws SystemException if a system exception occurred 1815 */ 1816 public static void removeBySmallImageId(long smallImageId) 1817 throws com.liferay.portal.kernel.exception.SystemException { 1818 getPersistence().removeBySmallImageId(smallImageId); 1819 } 1820 1821 /** 1822 * Returns the number of journal articles where smallImageId = ?. 1823 * 1824 * @param smallImageId the small image ID 1825 * @return the number of matching journal articles 1826 * @throws SystemException if a system exception occurred 1827 */ 1828 public static int countBySmallImageId(long smallImageId) 1829 throws com.liferay.portal.kernel.exception.SystemException { 1830 return getPersistence().countBySmallImageId(smallImageId); 1831 } 1832 1833 /** 1834 * Returns all the journal articles where resourcePrimKey = ? and status = ?. 1835 * 1836 * @param resourcePrimKey the resource prim key 1837 * @param status the status 1838 * @return the matching journal articles 1839 * @throws SystemException if a system exception occurred 1840 */ 1841 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 1842 long resourcePrimKey, int status) 1843 throws com.liferay.portal.kernel.exception.SystemException { 1844 return getPersistence().findByR_ST(resourcePrimKey, status); 1845 } 1846 1847 /** 1848 * Returns a range of all the journal articles where resourcePrimKey = ? and status = ?. 1849 * 1850 * <p> 1851 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1852 * </p> 1853 * 1854 * @param resourcePrimKey the resource prim key 1855 * @param status the status 1856 * @param start the lower bound of the range of journal articles 1857 * @param end the upper bound of the range of journal articles (not inclusive) 1858 * @return the range of matching journal articles 1859 * @throws SystemException if a system exception occurred 1860 */ 1861 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 1862 long resourcePrimKey, int status, int start, int end) 1863 throws com.liferay.portal.kernel.exception.SystemException { 1864 return getPersistence().findByR_ST(resourcePrimKey, status, start, end); 1865 } 1866 1867 /** 1868 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and status = ?. 1869 * 1870 * <p> 1871 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1872 * </p> 1873 * 1874 * @param resourcePrimKey the resource prim key 1875 * @param status the status 1876 * @param start the lower bound of the range of journal articles 1877 * @param end the upper bound of the range of journal articles (not inclusive) 1878 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1879 * @return the ordered range of matching journal articles 1880 * @throws SystemException if a system exception occurred 1881 */ 1882 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 1883 long resourcePrimKey, int status, int start, int end, 1884 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1885 throws com.liferay.portal.kernel.exception.SystemException { 1886 return getPersistence() 1887 .findByR_ST(resourcePrimKey, status, start, end, 1888 orderByComparator); 1889 } 1890 1891 /** 1892 * Returns the first journal article in the ordered set where resourcePrimKey = ? and status = ?. 1893 * 1894 * @param resourcePrimKey the resource prim key 1895 * @param status the status 1896 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1897 * @return the first matching journal article 1898 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1899 * @throws SystemException if a system exception occurred 1900 */ 1901 public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First( 1902 long resourcePrimKey, int status, 1903 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1904 throws com.liferay.portal.kernel.exception.SystemException, 1905 com.liferay.portlet.journal.NoSuchArticleException { 1906 return getPersistence() 1907 .findByR_ST_First(resourcePrimKey, status, orderByComparator); 1908 } 1909 1910 /** 1911 * Returns the first journal article in the ordered set where resourcePrimKey = ? and status = ?. 1912 * 1913 * @param resourcePrimKey the resource prim key 1914 * @param status the status 1915 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1916 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1917 * @throws SystemException if a system exception occurred 1918 */ 1919 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First( 1920 long resourcePrimKey, int status, 1921 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1922 throws com.liferay.portal.kernel.exception.SystemException { 1923 return getPersistence() 1924 .fetchByR_ST_First(resourcePrimKey, status, orderByComparator); 1925 } 1926 1927 /** 1928 * Returns the last journal article in the ordered set where resourcePrimKey = ? and status = ?. 1929 * 1930 * @param resourcePrimKey the resource prim key 1931 * @param status the status 1932 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1933 * @return the last matching journal article 1934 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1935 * @throws SystemException if a system exception occurred 1936 */ 1937 public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last( 1938 long resourcePrimKey, int status, 1939 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1940 throws com.liferay.portal.kernel.exception.SystemException, 1941 com.liferay.portlet.journal.NoSuchArticleException { 1942 return getPersistence() 1943 .findByR_ST_Last(resourcePrimKey, status, orderByComparator); 1944 } 1945 1946 /** 1947 * Returns the last journal article in the ordered set where resourcePrimKey = ? and status = ?. 1948 * 1949 * @param resourcePrimKey the resource prim key 1950 * @param status the status 1951 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1952 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1953 * @throws SystemException if a system exception occurred 1954 */ 1955 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last( 1956 long resourcePrimKey, int status, 1957 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1958 throws com.liferay.portal.kernel.exception.SystemException { 1959 return getPersistence() 1960 .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator); 1961 } 1962 1963 /** 1964 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and status = ?. 1965 * 1966 * @param id the primary key of the current journal article 1967 * @param resourcePrimKey the resource prim key 1968 * @param status the status 1969 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1970 * @return the previous, current, and next journal article 1971 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1972 * @throws SystemException if a system exception occurred 1973 */ 1974 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext( 1975 long id, long resourcePrimKey, int status, 1976 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1977 throws com.liferay.portal.kernel.exception.SystemException, 1978 com.liferay.portlet.journal.NoSuchArticleException { 1979 return getPersistence() 1980 .findByR_ST_PrevAndNext(id, resourcePrimKey, status, 1981 orderByComparator); 1982 } 1983 1984 /** 1985 * Removes all the journal articles where resourcePrimKey = ? and status = ? from the database. 1986 * 1987 * @param resourcePrimKey the resource prim key 1988 * @param status the status 1989 * @throws SystemException if a system exception occurred 1990 */ 1991 public static void removeByR_ST(long resourcePrimKey, int status) 1992 throws com.liferay.portal.kernel.exception.SystemException { 1993 getPersistence().removeByR_ST(resourcePrimKey, status); 1994 } 1995 1996 /** 1997 * Returns the number of journal articles where resourcePrimKey = ? and status = ?. 1998 * 1999 * @param resourcePrimKey the resource prim key 2000 * @param status the status 2001 * @return the number of matching journal articles 2002 * @throws SystemException if a system exception occurred 2003 */ 2004 public static int countByR_ST(long resourcePrimKey, int status) 2005 throws com.liferay.portal.kernel.exception.SystemException { 2006 return getPersistence().countByR_ST(resourcePrimKey, status); 2007 } 2008 2009 /** 2010 * Returns all the journal articles where groupId = ? and userId = ?. 2011 * 2012 * @param groupId the group ID 2013 * @param userId the user ID 2014 * @return the matching journal articles 2015 * @throws SystemException if a system exception occurred 2016 */ 2017 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2018 long groupId, long userId) 2019 throws com.liferay.portal.kernel.exception.SystemException { 2020 return getPersistence().findByG_U(groupId, userId); 2021 } 2022 2023 /** 2024 * Returns a range of all the journal articles where groupId = ? and userId = ?. 2025 * 2026 * <p> 2027 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2028 * </p> 2029 * 2030 * @param groupId the group ID 2031 * @param userId the user ID 2032 * @param start the lower bound of the range of journal articles 2033 * @param end the upper bound of the range of journal articles (not inclusive) 2034 * @return the range of matching journal articles 2035 * @throws SystemException if a system exception occurred 2036 */ 2037 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2038 long groupId, long userId, int start, int end) 2039 throws com.liferay.portal.kernel.exception.SystemException { 2040 return getPersistence().findByG_U(groupId, userId, start, end); 2041 } 2042 2043 /** 2044 * Returns an ordered range of all the journal articles where groupId = ? and userId = ?. 2045 * 2046 * <p> 2047 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2048 * </p> 2049 * 2050 * @param groupId the group ID 2051 * @param userId the user ID 2052 * @param start the lower bound of the range of journal articles 2053 * @param end the upper bound of the range of journal articles (not inclusive) 2054 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2055 * @return the ordered range of matching journal articles 2056 * @throws SystemException if a system exception occurred 2057 */ 2058 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2059 long groupId, long userId, int start, int end, 2060 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2061 throws com.liferay.portal.kernel.exception.SystemException { 2062 return getPersistence() 2063 .findByG_U(groupId, userId, start, end, orderByComparator); 2064 } 2065 2066 /** 2067 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2068 * 2069 * @param groupId the group ID 2070 * @param userId the user ID 2071 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2072 * @return the first matching journal article 2073 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2074 * @throws SystemException if a system exception occurred 2075 */ 2076 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First( 2077 long groupId, long userId, 2078 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2079 throws com.liferay.portal.kernel.exception.SystemException, 2080 com.liferay.portlet.journal.NoSuchArticleException { 2081 return getPersistence() 2082 .findByG_U_First(groupId, userId, orderByComparator); 2083 } 2084 2085 /** 2086 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2087 * 2088 * @param groupId the group ID 2089 * @param userId the user ID 2090 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2091 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2092 * @throws SystemException if a system exception occurred 2093 */ 2094 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First( 2095 long groupId, long userId, 2096 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2097 throws com.liferay.portal.kernel.exception.SystemException { 2098 return getPersistence() 2099 .fetchByG_U_First(groupId, userId, orderByComparator); 2100 } 2101 2102 /** 2103 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2104 * 2105 * @param groupId the group ID 2106 * @param userId the user ID 2107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2108 * @return the last matching journal article 2109 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2110 * @throws SystemException if a system exception occurred 2111 */ 2112 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last( 2113 long groupId, long userId, 2114 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2115 throws com.liferay.portal.kernel.exception.SystemException, 2116 com.liferay.portlet.journal.NoSuchArticleException { 2117 return getPersistence() 2118 .findByG_U_Last(groupId, userId, orderByComparator); 2119 } 2120 2121 /** 2122 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2123 * 2124 * @param groupId the group ID 2125 * @param userId the user ID 2126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2127 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2128 * @throws SystemException if a system exception occurred 2129 */ 2130 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last( 2131 long groupId, long userId, 2132 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2133 throws com.liferay.portal.kernel.exception.SystemException { 2134 return getPersistence() 2135 .fetchByG_U_Last(groupId, userId, orderByComparator); 2136 } 2137 2138 /** 2139 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ?. 2140 * 2141 * @param id the primary key of the current journal article 2142 * @param groupId the group ID 2143 * @param userId the user ID 2144 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2145 * @return the previous, current, and next journal article 2146 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2147 * @throws SystemException if a system exception occurred 2148 */ 2149 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext( 2150 long id, long groupId, long userId, 2151 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2152 throws com.liferay.portal.kernel.exception.SystemException, 2153 com.liferay.portlet.journal.NoSuchArticleException { 2154 return getPersistence() 2155 .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator); 2156 } 2157 2158 /** 2159 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2160 * 2161 * @param groupId the group ID 2162 * @param userId the user ID 2163 * @return the matching journal articles that the user has permission to view 2164 * @throws SystemException if a system exception occurred 2165 */ 2166 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2167 long groupId, long userId) 2168 throws com.liferay.portal.kernel.exception.SystemException { 2169 return getPersistence().filterFindByG_U(groupId, userId); 2170 } 2171 2172 /** 2173 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2177 * </p> 2178 * 2179 * @param groupId the group ID 2180 * @param userId the user ID 2181 * @param start the lower bound of the range of journal articles 2182 * @param end the upper bound of the range of journal articles (not inclusive) 2183 * @return the range of matching journal articles that the user has permission to view 2184 * @throws SystemException if a system exception occurred 2185 */ 2186 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2187 long groupId, long userId, int start, int end) 2188 throws com.liferay.portal.kernel.exception.SystemException { 2189 return getPersistence().filterFindByG_U(groupId, userId, start, end); 2190 } 2191 2192 /** 2193 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ?. 2194 * 2195 * <p> 2196 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2197 * </p> 2198 * 2199 * @param groupId the group ID 2200 * @param userId the user ID 2201 * @param start the lower bound of the range of journal articles 2202 * @param end the upper bound of the range of journal articles (not inclusive) 2203 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2204 * @return the ordered range of matching journal articles that the user has permission to view 2205 * @throws SystemException if a system exception occurred 2206 */ 2207 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2208 long groupId, long userId, int start, int end, 2209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2210 throws com.liferay.portal.kernel.exception.SystemException { 2211 return getPersistence() 2212 .filterFindByG_U(groupId, userId, start, end, 2213 orderByComparator); 2214 } 2215 2216 /** 2217 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and userId = ?. 2218 * 2219 * @param id the primary key of the current journal article 2220 * @param groupId the group ID 2221 * @param userId the user ID 2222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2223 * @return the previous, current, and next journal article 2224 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2225 * @throws SystemException if a system exception occurred 2226 */ 2227 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext( 2228 long id, long groupId, long userId, 2229 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2230 throws com.liferay.portal.kernel.exception.SystemException, 2231 com.liferay.portlet.journal.NoSuchArticleException { 2232 return getPersistence() 2233 .filterFindByG_U_PrevAndNext(id, groupId, userId, 2234 orderByComparator); 2235 } 2236 2237 /** 2238 * Removes all the journal articles where groupId = ? and userId = ? from the database. 2239 * 2240 * @param groupId the group ID 2241 * @param userId the user ID 2242 * @throws SystemException if a system exception occurred 2243 */ 2244 public static void removeByG_U(long groupId, long userId) 2245 throws com.liferay.portal.kernel.exception.SystemException { 2246 getPersistence().removeByG_U(groupId, userId); 2247 } 2248 2249 /** 2250 * Returns the number of journal articles where groupId = ? and userId = ?. 2251 * 2252 * @param groupId the group ID 2253 * @param userId the user ID 2254 * @return the number of matching journal articles 2255 * @throws SystemException if a system exception occurred 2256 */ 2257 public static int countByG_U(long groupId, long userId) 2258 throws com.liferay.portal.kernel.exception.SystemException { 2259 return getPersistence().countByG_U(groupId, userId); 2260 } 2261 2262 /** 2263 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ?. 2264 * 2265 * @param groupId the group ID 2266 * @param userId the user ID 2267 * @return the number of matching journal articles that the user has permission to view 2268 * @throws SystemException if a system exception occurred 2269 */ 2270 public static int filterCountByG_U(long groupId, long userId) 2271 throws com.liferay.portal.kernel.exception.SystemException { 2272 return getPersistence().filterCountByG_U(groupId, userId); 2273 } 2274 2275 /** 2276 * Returns all the journal articles where groupId = ? and folderId = ?. 2277 * 2278 * @param groupId the group ID 2279 * @param folderId the folder ID 2280 * @return the matching journal articles 2281 * @throws SystemException if a system exception occurred 2282 */ 2283 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2284 long groupId, long folderId) 2285 throws com.liferay.portal.kernel.exception.SystemException { 2286 return getPersistence().findByG_F(groupId, folderId); 2287 } 2288 2289 /** 2290 * Returns a range of all the journal articles where groupId = ? and folderId = ?. 2291 * 2292 * <p> 2293 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2294 * </p> 2295 * 2296 * @param groupId the group ID 2297 * @param folderId the folder ID 2298 * @param start the lower bound of the range of journal articles 2299 * @param end the upper bound of the range of journal articles (not inclusive) 2300 * @return the range of matching journal articles 2301 * @throws SystemException if a system exception occurred 2302 */ 2303 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2304 long groupId, long folderId, int start, int end) 2305 throws com.liferay.portal.kernel.exception.SystemException { 2306 return getPersistence().findByG_F(groupId, folderId, start, end); 2307 } 2308 2309 /** 2310 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ?. 2311 * 2312 * <p> 2313 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2314 * </p> 2315 * 2316 * @param groupId the group ID 2317 * @param folderId the folder ID 2318 * @param start the lower bound of the range of journal articles 2319 * @param end the upper bound of the range of journal articles (not inclusive) 2320 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2321 * @return the ordered range of matching journal articles 2322 * @throws SystemException if a system exception occurred 2323 */ 2324 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2325 long groupId, long folderId, int start, int end, 2326 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2327 throws com.liferay.portal.kernel.exception.SystemException { 2328 return getPersistence() 2329 .findByG_F(groupId, folderId, start, end, orderByComparator); 2330 } 2331 2332 /** 2333 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2334 * 2335 * @param groupId the group ID 2336 * @param folderId the folder ID 2337 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2338 * @return the first matching journal article 2339 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2340 * @throws SystemException if a system exception occurred 2341 */ 2342 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First( 2343 long groupId, long folderId, 2344 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2345 throws com.liferay.portal.kernel.exception.SystemException, 2346 com.liferay.portlet.journal.NoSuchArticleException { 2347 return getPersistence() 2348 .findByG_F_First(groupId, folderId, orderByComparator); 2349 } 2350 2351 /** 2352 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2353 * 2354 * @param groupId the group ID 2355 * @param folderId the folder ID 2356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2357 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2358 * @throws SystemException if a system exception occurred 2359 */ 2360 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First( 2361 long groupId, long folderId, 2362 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2363 throws com.liferay.portal.kernel.exception.SystemException { 2364 return getPersistence() 2365 .fetchByG_F_First(groupId, folderId, orderByComparator); 2366 } 2367 2368 /** 2369 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2370 * 2371 * @param groupId the group ID 2372 * @param folderId the folder ID 2373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2374 * @return the last matching journal article 2375 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2376 * @throws SystemException if a system exception occurred 2377 */ 2378 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last( 2379 long groupId, long folderId, 2380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2381 throws com.liferay.portal.kernel.exception.SystemException, 2382 com.liferay.portlet.journal.NoSuchArticleException { 2383 return getPersistence() 2384 .findByG_F_Last(groupId, folderId, orderByComparator); 2385 } 2386 2387 /** 2388 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2389 * 2390 * @param groupId the group ID 2391 * @param folderId the folder ID 2392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2393 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2394 * @throws SystemException if a system exception occurred 2395 */ 2396 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last( 2397 long groupId, long folderId, 2398 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2399 throws com.liferay.portal.kernel.exception.SystemException { 2400 return getPersistence() 2401 .fetchByG_F_Last(groupId, folderId, orderByComparator); 2402 } 2403 2404 /** 2405 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ?. 2406 * 2407 * @param id the primary key of the current journal article 2408 * @param groupId the group ID 2409 * @param folderId the folder ID 2410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2411 * @return the previous, current, and next journal article 2412 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2413 * @throws SystemException if a system exception occurred 2414 */ 2415 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext( 2416 long id, long groupId, long folderId, 2417 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2418 throws com.liferay.portal.kernel.exception.SystemException, 2419 com.liferay.portlet.journal.NoSuchArticleException { 2420 return getPersistence() 2421 .findByG_F_PrevAndNext(id, groupId, folderId, 2422 orderByComparator); 2423 } 2424 2425 /** 2426 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2427 * 2428 * @param groupId the group ID 2429 * @param folderId the folder ID 2430 * @return the matching journal articles that the user has permission to view 2431 * @throws SystemException if a system exception occurred 2432 */ 2433 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2434 long groupId, long folderId) 2435 throws com.liferay.portal.kernel.exception.SystemException { 2436 return getPersistence().filterFindByG_F(groupId, folderId); 2437 } 2438 2439 /** 2440 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2441 * 2442 * <p> 2443 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2444 * </p> 2445 * 2446 * @param groupId the group ID 2447 * @param folderId the folder ID 2448 * @param start the lower bound of the range of journal articles 2449 * @param end the upper bound of the range of journal articles (not inclusive) 2450 * @return the range of matching journal articles that the user has permission to view 2451 * @throws SystemException if a system exception occurred 2452 */ 2453 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2454 long groupId, long folderId, int start, int end) 2455 throws com.liferay.portal.kernel.exception.SystemException { 2456 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 2457 } 2458 2459 /** 2460 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ?. 2461 * 2462 * <p> 2463 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2464 * </p> 2465 * 2466 * @param groupId the group ID 2467 * @param folderId the folder ID 2468 * @param start the lower bound of the range of journal articles 2469 * @param end the upper bound of the range of journal articles (not inclusive) 2470 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2471 * @return the ordered range of matching journal articles that the user has permission to view 2472 * @throws SystemException if a system exception occurred 2473 */ 2474 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2475 long groupId, long folderId, int start, int end, 2476 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2477 throws com.liferay.portal.kernel.exception.SystemException { 2478 return getPersistence() 2479 .filterFindByG_F(groupId, folderId, start, end, 2480 orderByComparator); 2481 } 2482 2483 /** 2484 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and folderId = ?. 2485 * 2486 * @param id the primary key of the current journal article 2487 * @param groupId the group ID 2488 * @param folderId the folder ID 2489 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2490 * @return the previous, current, and next journal article 2491 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2492 * @throws SystemException if a system exception occurred 2493 */ 2494 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext( 2495 long id, long groupId, long folderId, 2496 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2497 throws com.liferay.portal.kernel.exception.SystemException, 2498 com.liferay.portlet.journal.NoSuchArticleException { 2499 return getPersistence() 2500 .filterFindByG_F_PrevAndNext(id, groupId, folderId, 2501 orderByComparator); 2502 } 2503 2504 /** 2505 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2506 * 2507 * @param groupId the group ID 2508 * @param folderIds the folder IDs 2509 * @return the matching journal articles that the user has permission to view 2510 * @throws SystemException if a system exception occurred 2511 */ 2512 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2513 long groupId, long[] folderIds) 2514 throws com.liferay.portal.kernel.exception.SystemException { 2515 return getPersistence().filterFindByG_F(groupId, folderIds); 2516 } 2517 2518 /** 2519 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2520 * 2521 * <p> 2522 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2523 * </p> 2524 * 2525 * @param groupId the group ID 2526 * @param folderIds the folder IDs 2527 * @param start the lower bound of the range of journal articles 2528 * @param end the upper bound of the range of journal articles (not inclusive) 2529 * @return the range of matching journal articles that the user has permission to view 2530 * @throws SystemException if a system exception occurred 2531 */ 2532 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2533 long groupId, long[] folderIds, int start, int end) 2534 throws com.liferay.portal.kernel.exception.SystemException { 2535 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 2536 } 2537 2538 /** 2539 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2540 * 2541 * <p> 2542 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2543 * </p> 2544 * 2545 * @param groupId the group ID 2546 * @param folderIds the folder IDs 2547 * @param start the lower bound of the range of journal articles 2548 * @param end the upper bound of the range of journal articles (not inclusive) 2549 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2550 * @return the ordered range of matching journal articles that the user has permission to view 2551 * @throws SystemException if a system exception occurred 2552 */ 2553 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2554 long groupId, long[] folderIds, int start, int end, 2555 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2556 throws com.liferay.portal.kernel.exception.SystemException { 2557 return getPersistence() 2558 .filterFindByG_F(groupId, folderIds, start, end, 2559 orderByComparator); 2560 } 2561 2562 /** 2563 * Returns all the journal articles where groupId = ? and folderId = any ?. 2564 * 2565 * <p> 2566 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2567 * </p> 2568 * 2569 * @param groupId the group ID 2570 * @param folderIds the folder IDs 2571 * @return the matching journal articles 2572 * @throws SystemException if a system exception occurred 2573 */ 2574 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2575 long groupId, long[] folderIds) 2576 throws com.liferay.portal.kernel.exception.SystemException { 2577 return getPersistence().findByG_F(groupId, folderIds); 2578 } 2579 2580 /** 2581 * Returns a range of all the journal articles where groupId = ? and folderId = any ?. 2582 * 2583 * <p> 2584 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2585 * </p> 2586 * 2587 * @param groupId the group ID 2588 * @param folderIds the folder IDs 2589 * @param start the lower bound of the range of journal articles 2590 * @param end the upper bound of the range of journal articles (not inclusive) 2591 * @return the range of matching journal articles 2592 * @throws SystemException if a system exception occurred 2593 */ 2594 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2595 long groupId, long[] folderIds, int start, int end) 2596 throws com.liferay.portal.kernel.exception.SystemException { 2597 return getPersistence().findByG_F(groupId, folderIds, start, end); 2598 } 2599 2600 /** 2601 * Returns an ordered range of all the journal articles where groupId = ? and folderId = any ?. 2602 * 2603 * <p> 2604 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2605 * </p> 2606 * 2607 * @param groupId the group ID 2608 * @param folderIds the folder IDs 2609 * @param start the lower bound of the range of journal articles 2610 * @param end the upper bound of the range of journal articles (not inclusive) 2611 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2612 * @return the ordered range of matching journal articles 2613 * @throws SystemException if a system exception occurred 2614 */ 2615 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2616 long groupId, long[] folderIds, int start, int end, 2617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2618 throws com.liferay.portal.kernel.exception.SystemException { 2619 return getPersistence() 2620 .findByG_F(groupId, folderIds, start, end, orderByComparator); 2621 } 2622 2623 /** 2624 * Removes all the journal articles where groupId = ? and folderId = ? from the database. 2625 * 2626 * @param groupId the group ID 2627 * @param folderId the folder ID 2628 * @throws SystemException if a system exception occurred 2629 */ 2630 public static void removeByG_F(long groupId, long folderId) 2631 throws com.liferay.portal.kernel.exception.SystemException { 2632 getPersistence().removeByG_F(groupId, folderId); 2633 } 2634 2635 /** 2636 * Returns the number of journal articles where groupId = ? and folderId = ?. 2637 * 2638 * @param groupId the group ID 2639 * @param folderId the folder ID 2640 * @return the number of matching journal articles 2641 * @throws SystemException if a system exception occurred 2642 */ 2643 public static int countByG_F(long groupId, long folderId) 2644 throws com.liferay.portal.kernel.exception.SystemException { 2645 return getPersistence().countByG_F(groupId, folderId); 2646 } 2647 2648 /** 2649 * Returns the number of journal articles where groupId = ? and folderId = any ?. 2650 * 2651 * @param groupId the group ID 2652 * @param folderIds the folder IDs 2653 * @return the number of matching journal articles 2654 * @throws SystemException if a system exception occurred 2655 */ 2656 public static int countByG_F(long groupId, long[] folderIds) 2657 throws com.liferay.portal.kernel.exception.SystemException { 2658 return getPersistence().countByG_F(groupId, folderIds); 2659 } 2660 2661 /** 2662 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ?. 2663 * 2664 * @param groupId the group ID 2665 * @param folderId the folder ID 2666 * @return the number of matching journal articles that the user has permission to view 2667 * @throws SystemException if a system exception occurred 2668 */ 2669 public static int filterCountByG_F(long groupId, long folderId) 2670 throws com.liferay.portal.kernel.exception.SystemException { 2671 return getPersistence().filterCountByG_F(groupId, folderId); 2672 } 2673 2674 /** 2675 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2676 * 2677 * @param groupId the group ID 2678 * @param folderIds the folder IDs 2679 * @return the number of matching journal articles that the user has permission to view 2680 * @throws SystemException if a system exception occurred 2681 */ 2682 public static int filterCountByG_F(long groupId, long[] folderIds) 2683 throws com.liferay.portal.kernel.exception.SystemException { 2684 return getPersistence().filterCountByG_F(groupId, folderIds); 2685 } 2686 2687 /** 2688 * Returns all the journal articles where groupId = ? and articleId = ?. 2689 * 2690 * @param groupId the group ID 2691 * @param articleId the article ID 2692 * @return the matching journal articles 2693 * @throws SystemException if a system exception occurred 2694 */ 2695 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2696 long groupId, java.lang.String articleId) 2697 throws com.liferay.portal.kernel.exception.SystemException { 2698 return getPersistence().findByG_A(groupId, articleId); 2699 } 2700 2701 /** 2702 * Returns a range of all the journal articles where groupId = ? and articleId = ?. 2703 * 2704 * <p> 2705 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2706 * </p> 2707 * 2708 * @param groupId the group ID 2709 * @param articleId the article ID 2710 * @param start the lower bound of the range of journal articles 2711 * @param end the upper bound of the range of journal articles (not inclusive) 2712 * @return the range of matching journal articles 2713 * @throws SystemException if a system exception occurred 2714 */ 2715 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2716 long groupId, java.lang.String articleId, int start, int end) 2717 throws com.liferay.portal.kernel.exception.SystemException { 2718 return getPersistence().findByG_A(groupId, articleId, start, end); 2719 } 2720 2721 /** 2722 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ?. 2723 * 2724 * <p> 2725 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2726 * </p> 2727 * 2728 * @param groupId the group ID 2729 * @param articleId the article ID 2730 * @param start the lower bound of the range of journal articles 2731 * @param end the upper bound of the range of journal articles (not inclusive) 2732 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2733 * @return the ordered range of matching journal articles 2734 * @throws SystemException if a system exception occurred 2735 */ 2736 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2737 long groupId, java.lang.String articleId, int start, int end, 2738 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2739 throws com.liferay.portal.kernel.exception.SystemException { 2740 return getPersistence() 2741 .findByG_A(groupId, articleId, start, end, orderByComparator); 2742 } 2743 2744 /** 2745 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 2746 * 2747 * @param groupId the group ID 2748 * @param articleId the article ID 2749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2750 * @return the first matching journal article 2751 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2752 * @throws SystemException if a system exception occurred 2753 */ 2754 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First( 2755 long groupId, java.lang.String articleId, 2756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2757 throws com.liferay.portal.kernel.exception.SystemException, 2758 com.liferay.portlet.journal.NoSuchArticleException { 2759 return getPersistence() 2760 .findByG_A_First(groupId, articleId, orderByComparator); 2761 } 2762 2763 /** 2764 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 2765 * 2766 * @param groupId the group ID 2767 * @param articleId the article ID 2768 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2769 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2770 * @throws SystemException if a system exception occurred 2771 */ 2772 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First( 2773 long groupId, java.lang.String articleId, 2774 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2775 throws com.liferay.portal.kernel.exception.SystemException { 2776 return getPersistence() 2777 .fetchByG_A_First(groupId, articleId, orderByComparator); 2778 } 2779 2780 /** 2781 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 2782 * 2783 * @param groupId the group ID 2784 * @param articleId the article ID 2785 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2786 * @return the last matching journal article 2787 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2788 * @throws SystemException if a system exception occurred 2789 */ 2790 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last( 2791 long groupId, java.lang.String articleId, 2792 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2793 throws com.liferay.portal.kernel.exception.SystemException, 2794 com.liferay.portlet.journal.NoSuchArticleException { 2795 return getPersistence() 2796 .findByG_A_Last(groupId, articleId, orderByComparator); 2797 } 2798 2799 /** 2800 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 2801 * 2802 * @param groupId the group ID 2803 * @param articleId the article ID 2804 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2805 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2806 * @throws SystemException if a system exception occurred 2807 */ 2808 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last( 2809 long groupId, java.lang.String articleId, 2810 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2811 throws com.liferay.portal.kernel.exception.SystemException { 2812 return getPersistence() 2813 .fetchByG_A_Last(groupId, articleId, orderByComparator); 2814 } 2815 2816 /** 2817 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ?. 2818 * 2819 * @param id the primary key of the current journal article 2820 * @param groupId the group ID 2821 * @param articleId the article ID 2822 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2823 * @return the previous, current, and next journal article 2824 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2825 * @throws SystemException if a system exception occurred 2826 */ 2827 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext( 2828 long id, long groupId, java.lang.String articleId, 2829 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2830 throws com.liferay.portal.kernel.exception.SystemException, 2831 com.liferay.portlet.journal.NoSuchArticleException { 2832 return getPersistence() 2833 .findByG_A_PrevAndNext(id, groupId, articleId, 2834 orderByComparator); 2835 } 2836 2837 /** 2838 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 2839 * 2840 * @param groupId the group ID 2841 * @param articleId the article ID 2842 * @return the matching journal articles that the user has permission to view 2843 * @throws SystemException if a system exception occurred 2844 */ 2845 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 2846 long groupId, java.lang.String articleId) 2847 throws com.liferay.portal.kernel.exception.SystemException { 2848 return getPersistence().filterFindByG_A(groupId, articleId); 2849 } 2850 2851 /** 2852 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 2853 * 2854 * <p> 2855 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2856 * </p> 2857 * 2858 * @param groupId the group ID 2859 * @param articleId the article ID 2860 * @param start the lower bound of the range of journal articles 2861 * @param end the upper bound of the range of journal articles (not inclusive) 2862 * @return the range of matching journal articles that the user has permission to view 2863 * @throws SystemException if a system exception occurred 2864 */ 2865 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 2866 long groupId, java.lang.String articleId, int start, int end) 2867 throws com.liferay.portal.kernel.exception.SystemException { 2868 return getPersistence().filterFindByG_A(groupId, articleId, start, end); 2869 } 2870 2871 /** 2872 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ?. 2873 * 2874 * <p> 2875 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2876 * </p> 2877 * 2878 * @param groupId the group ID 2879 * @param articleId the article ID 2880 * @param start the lower bound of the range of journal articles 2881 * @param end the upper bound of the range of journal articles (not inclusive) 2882 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2883 * @return the ordered range of matching journal articles that the user has permission to view 2884 * @throws SystemException if a system exception occurred 2885 */ 2886 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 2887 long groupId, java.lang.String articleId, int start, int end, 2888 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2889 throws com.liferay.portal.kernel.exception.SystemException { 2890 return getPersistence() 2891 .filterFindByG_A(groupId, articleId, start, end, 2892 orderByComparator); 2893 } 2894 2895 /** 2896 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and articleId = ?. 2897 * 2898 * @param id the primary key of the current journal article 2899 * @param groupId the group ID 2900 * @param articleId the article ID 2901 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2902 * @return the previous, current, and next journal article 2903 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2904 * @throws SystemException if a system exception occurred 2905 */ 2906 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext( 2907 long id, long groupId, java.lang.String articleId, 2908 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2909 throws com.liferay.portal.kernel.exception.SystemException, 2910 com.liferay.portlet.journal.NoSuchArticleException { 2911 return getPersistence() 2912 .filterFindByG_A_PrevAndNext(id, groupId, articleId, 2913 orderByComparator); 2914 } 2915 2916 /** 2917 * Removes all the journal articles where groupId = ? and articleId = ? from the database. 2918 * 2919 * @param groupId the group ID 2920 * @param articleId the article ID 2921 * @throws SystemException if a system exception occurred 2922 */ 2923 public static void removeByG_A(long groupId, java.lang.String articleId) 2924 throws com.liferay.portal.kernel.exception.SystemException { 2925 getPersistence().removeByG_A(groupId, articleId); 2926 } 2927 2928 /** 2929 * Returns the number of journal articles where groupId = ? and articleId = ?. 2930 * 2931 * @param groupId the group ID 2932 * @param articleId the article ID 2933 * @return the number of matching journal articles 2934 * @throws SystemException if a system exception occurred 2935 */ 2936 public static int countByG_A(long groupId, java.lang.String articleId) 2937 throws com.liferay.portal.kernel.exception.SystemException { 2938 return getPersistence().countByG_A(groupId, articleId); 2939 } 2940 2941 /** 2942 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ?. 2943 * 2944 * @param groupId the group ID 2945 * @param articleId the article ID 2946 * @return the number of matching journal articles that the user has permission to view 2947 * @throws SystemException if a system exception occurred 2948 */ 2949 public static int filterCountByG_A(long groupId, java.lang.String articleId) 2950 throws com.liferay.portal.kernel.exception.SystemException { 2951 return getPersistence().filterCountByG_A(groupId, articleId); 2952 } 2953 2954 /** 2955 * Returns all the journal articles where groupId = ? and urlTitle = ?. 2956 * 2957 * @param groupId the group ID 2958 * @param urlTitle the url title 2959 * @return the matching journal articles 2960 * @throws SystemException if a system exception occurred 2961 */ 2962 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 2963 long groupId, java.lang.String urlTitle) 2964 throws com.liferay.portal.kernel.exception.SystemException { 2965 return getPersistence().findByG_UT(groupId, urlTitle); 2966 } 2967 2968 /** 2969 * Returns a range of all the journal articles where groupId = ? and urlTitle = ?. 2970 * 2971 * <p> 2972 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2973 * </p> 2974 * 2975 * @param groupId the group ID 2976 * @param urlTitle the url title 2977 * @param start the lower bound of the range of journal articles 2978 * @param end the upper bound of the range of journal articles (not inclusive) 2979 * @return the range of matching journal articles 2980 * @throws SystemException if a system exception occurred 2981 */ 2982 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 2983 long groupId, java.lang.String urlTitle, int start, int end) 2984 throws com.liferay.portal.kernel.exception.SystemException { 2985 return getPersistence().findByG_UT(groupId, urlTitle, start, end); 2986 } 2987 2988 /** 2989 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ?. 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. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2993 * </p> 2994 * 2995 * @param groupId the group ID 2996 * @param urlTitle the url title 2997 * @param start the lower bound of the range of journal articles 2998 * @param end the upper bound of the range of journal articles (not inclusive) 2999 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3000 * @return the ordered range of matching journal articles 3001 * @throws SystemException if a system exception occurred 3002 */ 3003 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3004 long groupId, java.lang.String urlTitle, int start, int end, 3005 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3006 throws com.liferay.portal.kernel.exception.SystemException { 3007 return getPersistence() 3008 .findByG_UT(groupId, urlTitle, start, end, orderByComparator); 3009 } 3010 3011 /** 3012 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3013 * 3014 * @param groupId the group ID 3015 * @param urlTitle the url title 3016 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3017 * @return the first matching journal article 3018 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3019 * @throws SystemException if a system exception occurred 3020 */ 3021 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First( 3022 long groupId, java.lang.String urlTitle, 3023 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3024 throws com.liferay.portal.kernel.exception.SystemException, 3025 com.liferay.portlet.journal.NoSuchArticleException { 3026 return getPersistence() 3027 .findByG_UT_First(groupId, urlTitle, orderByComparator); 3028 } 3029 3030 /** 3031 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3032 * 3033 * @param groupId the group ID 3034 * @param urlTitle the url title 3035 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3036 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3037 * @throws SystemException if a system exception occurred 3038 */ 3039 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First( 3040 long groupId, java.lang.String urlTitle, 3041 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3042 throws com.liferay.portal.kernel.exception.SystemException { 3043 return getPersistence() 3044 .fetchByG_UT_First(groupId, urlTitle, orderByComparator); 3045 } 3046 3047 /** 3048 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3049 * 3050 * @param groupId the group ID 3051 * @param urlTitle the url title 3052 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3053 * @return the last matching journal article 3054 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3055 * @throws SystemException if a system exception occurred 3056 */ 3057 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last( 3058 long groupId, java.lang.String urlTitle, 3059 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3060 throws com.liferay.portal.kernel.exception.SystemException, 3061 com.liferay.portlet.journal.NoSuchArticleException { 3062 return getPersistence() 3063 .findByG_UT_Last(groupId, urlTitle, orderByComparator); 3064 } 3065 3066 /** 3067 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3068 * 3069 * @param groupId the group ID 3070 * @param urlTitle the url title 3071 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3072 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3073 * @throws SystemException if a system exception occurred 3074 */ 3075 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last( 3076 long groupId, java.lang.String urlTitle, 3077 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3078 throws com.liferay.portal.kernel.exception.SystemException { 3079 return getPersistence() 3080 .fetchByG_UT_Last(groupId, urlTitle, orderByComparator); 3081 } 3082 3083 /** 3084 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ?. 3085 * 3086 * @param id the primary key of the current journal article 3087 * @param groupId the group ID 3088 * @param urlTitle the url title 3089 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3090 * @return the previous, current, and next journal article 3091 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3092 * @throws SystemException if a system exception occurred 3093 */ 3094 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext( 3095 long id, long groupId, java.lang.String urlTitle, 3096 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3097 throws com.liferay.portal.kernel.exception.SystemException, 3098 com.liferay.portlet.journal.NoSuchArticleException { 3099 return getPersistence() 3100 .findByG_UT_PrevAndNext(id, groupId, urlTitle, 3101 orderByComparator); 3102 } 3103 3104 /** 3105 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3106 * 3107 * @param groupId the group ID 3108 * @param urlTitle the url title 3109 * @return the matching journal articles that the user has permission to view 3110 * @throws SystemException if a system exception occurred 3111 */ 3112 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3113 long groupId, java.lang.String urlTitle) 3114 throws com.liferay.portal.kernel.exception.SystemException { 3115 return getPersistence().filterFindByG_UT(groupId, urlTitle); 3116 } 3117 3118 /** 3119 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3120 * 3121 * <p> 3122 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3123 * </p> 3124 * 3125 * @param groupId the group ID 3126 * @param urlTitle the url title 3127 * @param start the lower bound of the range of journal articles 3128 * @param end the upper bound of the range of journal articles (not inclusive) 3129 * @return the range of matching journal articles that the user has permission to view 3130 * @throws SystemException if a system exception occurred 3131 */ 3132 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3133 long groupId, java.lang.String urlTitle, int start, int end) 3134 throws com.liferay.portal.kernel.exception.SystemException { 3135 return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end); 3136 } 3137 3138 /** 3139 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ?. 3140 * 3141 * <p> 3142 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3143 * </p> 3144 * 3145 * @param groupId the group ID 3146 * @param urlTitle the url title 3147 * @param start the lower bound of the range of journal articles 3148 * @param end the upper bound of the range of journal articles (not inclusive) 3149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3150 * @return the ordered range of matching journal articles that the user has permission to view 3151 * @throws SystemException if a system exception occurred 3152 */ 3153 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3154 long groupId, java.lang.String urlTitle, int start, int end, 3155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3156 throws com.liferay.portal.kernel.exception.SystemException { 3157 return getPersistence() 3158 .filterFindByG_UT(groupId, urlTitle, start, end, 3159 orderByComparator); 3160 } 3161 3162 /** 3163 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3164 * 3165 * @param id the primary key of the current journal article 3166 * @param groupId the group ID 3167 * @param urlTitle the url title 3168 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3169 * @return the previous, current, and next journal article 3170 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3171 * @throws SystemException if a system exception occurred 3172 */ 3173 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext( 3174 long id, long groupId, java.lang.String urlTitle, 3175 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3176 throws com.liferay.portal.kernel.exception.SystemException, 3177 com.liferay.portlet.journal.NoSuchArticleException { 3178 return getPersistence() 3179 .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle, 3180 orderByComparator); 3181 } 3182 3183 /** 3184 * Removes all the journal articles where groupId = ? and urlTitle = ? from the database. 3185 * 3186 * @param groupId the group ID 3187 * @param urlTitle the url title 3188 * @throws SystemException if a system exception occurred 3189 */ 3190 public static void removeByG_UT(long groupId, java.lang.String urlTitle) 3191 throws com.liferay.portal.kernel.exception.SystemException { 3192 getPersistence().removeByG_UT(groupId, urlTitle); 3193 } 3194 3195 /** 3196 * Returns the number of journal articles where groupId = ? and urlTitle = ?. 3197 * 3198 * @param groupId the group ID 3199 * @param urlTitle the url title 3200 * @return the number of matching journal articles 3201 * @throws SystemException if a system exception occurred 3202 */ 3203 public static int countByG_UT(long groupId, java.lang.String urlTitle) 3204 throws com.liferay.portal.kernel.exception.SystemException { 3205 return getPersistence().countByG_UT(groupId, urlTitle); 3206 } 3207 3208 /** 3209 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3210 * 3211 * @param groupId the group ID 3212 * @param urlTitle the url title 3213 * @return the number of matching journal articles that the user has permission to view 3214 * @throws SystemException if a system exception occurred 3215 */ 3216 public static int filterCountByG_UT(long groupId, java.lang.String urlTitle) 3217 throws com.liferay.portal.kernel.exception.SystemException { 3218 return getPersistence().filterCountByG_UT(groupId, urlTitle); 3219 } 3220 3221 /** 3222 * Returns all the journal articles where groupId = ? and structureId = ?. 3223 * 3224 * @param groupId the group ID 3225 * @param structureId the structure ID 3226 * @return the matching journal articles 3227 * @throws SystemException if a system exception occurred 3228 */ 3229 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3230 long groupId, java.lang.String structureId) 3231 throws com.liferay.portal.kernel.exception.SystemException { 3232 return getPersistence().findByG_S(groupId, structureId); 3233 } 3234 3235 /** 3236 * Returns a range of all the journal articles where groupId = ? and structureId = ?. 3237 * 3238 * <p> 3239 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3240 * </p> 3241 * 3242 * @param groupId the group ID 3243 * @param structureId the structure ID 3244 * @param start the lower bound of the range of journal articles 3245 * @param end the upper bound of the range of journal articles (not inclusive) 3246 * @return the range of matching journal articles 3247 * @throws SystemException if a system exception occurred 3248 */ 3249 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3250 long groupId, java.lang.String structureId, int start, int end) 3251 throws com.liferay.portal.kernel.exception.SystemException { 3252 return getPersistence().findByG_S(groupId, structureId, start, end); 3253 } 3254 3255 /** 3256 * Returns an ordered range of all the journal articles where groupId = ? and structureId = ?. 3257 * 3258 * <p> 3259 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3260 * </p> 3261 * 3262 * @param groupId the group ID 3263 * @param structureId the structure ID 3264 * @param start the lower bound of the range of journal articles 3265 * @param end the upper bound of the range of journal articles (not inclusive) 3266 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3267 * @return the ordered range of matching journal articles 3268 * @throws SystemException if a system exception occurred 3269 */ 3270 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3271 long groupId, java.lang.String structureId, int start, int end, 3272 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3273 throws com.liferay.portal.kernel.exception.SystemException { 3274 return getPersistence() 3275 .findByG_S(groupId, structureId, start, end, 3276 orderByComparator); 3277 } 3278 3279 /** 3280 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3281 * 3282 * @param groupId the group ID 3283 * @param structureId the structure ID 3284 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3285 * @return the first matching journal article 3286 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3287 * @throws SystemException if a system exception occurred 3288 */ 3289 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First( 3290 long groupId, java.lang.String structureId, 3291 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3292 throws com.liferay.portal.kernel.exception.SystemException, 3293 com.liferay.portlet.journal.NoSuchArticleException { 3294 return getPersistence() 3295 .findByG_S_First(groupId, structureId, orderByComparator); 3296 } 3297 3298 /** 3299 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3300 * 3301 * @param groupId the group ID 3302 * @param structureId the structure ID 3303 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3304 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3305 * @throws SystemException if a system exception occurred 3306 */ 3307 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First( 3308 long groupId, java.lang.String structureId, 3309 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3310 throws com.liferay.portal.kernel.exception.SystemException { 3311 return getPersistence() 3312 .fetchByG_S_First(groupId, structureId, orderByComparator); 3313 } 3314 3315 /** 3316 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3317 * 3318 * @param groupId the group ID 3319 * @param structureId the structure ID 3320 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3321 * @return the last matching journal article 3322 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3323 * @throws SystemException if a system exception occurred 3324 */ 3325 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last( 3326 long groupId, java.lang.String structureId, 3327 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3328 throws com.liferay.portal.kernel.exception.SystemException, 3329 com.liferay.portlet.journal.NoSuchArticleException { 3330 return getPersistence() 3331 .findByG_S_Last(groupId, structureId, orderByComparator); 3332 } 3333 3334 /** 3335 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3336 * 3337 * @param groupId the group ID 3338 * @param structureId the structure ID 3339 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3340 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3341 * @throws SystemException if a system exception occurred 3342 */ 3343 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last( 3344 long groupId, java.lang.String structureId, 3345 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3346 throws com.liferay.portal.kernel.exception.SystemException { 3347 return getPersistence() 3348 .fetchByG_S_Last(groupId, structureId, orderByComparator); 3349 } 3350 3351 /** 3352 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and structureId = ?. 3353 * 3354 * @param id the primary key of the current journal article 3355 * @param groupId the group ID 3356 * @param structureId the structure ID 3357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3358 * @return the previous, current, and next journal article 3359 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3360 * @throws SystemException if a system exception occurred 3361 */ 3362 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext( 3363 long id, long groupId, java.lang.String structureId, 3364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3365 throws com.liferay.portal.kernel.exception.SystemException, 3366 com.liferay.portlet.journal.NoSuchArticleException { 3367 return getPersistence() 3368 .findByG_S_PrevAndNext(id, groupId, structureId, 3369 orderByComparator); 3370 } 3371 3372 /** 3373 * Returns all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3374 * 3375 * @param groupId the group ID 3376 * @param structureId the structure ID 3377 * @return the matching journal articles that the user has permission to view 3378 * @throws SystemException if a system exception occurred 3379 */ 3380 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3381 long groupId, java.lang.String structureId) 3382 throws com.liferay.portal.kernel.exception.SystemException { 3383 return getPersistence().filterFindByG_S(groupId, structureId); 3384 } 3385 3386 /** 3387 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3388 * 3389 * <p> 3390 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3391 * </p> 3392 * 3393 * @param groupId the group ID 3394 * @param structureId the structure ID 3395 * @param start the lower bound of the range of journal articles 3396 * @param end the upper bound of the range of journal articles (not inclusive) 3397 * @return the range of matching journal articles that the user has permission to view 3398 * @throws SystemException if a system exception occurred 3399 */ 3400 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3401 long groupId, java.lang.String structureId, int start, int end) 3402 throws com.liferay.portal.kernel.exception.SystemException { 3403 return getPersistence().filterFindByG_S(groupId, structureId, start, end); 3404 } 3405 3406 /** 3407 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and structureId = ?. 3408 * 3409 * <p> 3410 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3411 * </p> 3412 * 3413 * @param groupId the group ID 3414 * @param structureId the structure ID 3415 * @param start the lower bound of the range of journal articles 3416 * @param end the upper bound of the range of journal articles (not inclusive) 3417 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3418 * @return the ordered range of matching journal articles that the user has permission to view 3419 * @throws SystemException if a system exception occurred 3420 */ 3421 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3422 long groupId, java.lang.String structureId, int start, int end, 3423 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3424 throws com.liferay.portal.kernel.exception.SystemException { 3425 return getPersistence() 3426 .filterFindByG_S(groupId, structureId, start, end, 3427 orderByComparator); 3428 } 3429 3430 /** 3431 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and structureId = ?. 3432 * 3433 * @param id the primary key of the current journal article 3434 * @param groupId the group ID 3435 * @param structureId the structure ID 3436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3437 * @return the previous, current, and next journal article 3438 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3439 * @throws SystemException if a system exception occurred 3440 */ 3441 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext( 3442 long id, long groupId, java.lang.String structureId, 3443 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3444 throws com.liferay.portal.kernel.exception.SystemException, 3445 com.liferay.portlet.journal.NoSuchArticleException { 3446 return getPersistence() 3447 .filterFindByG_S_PrevAndNext(id, groupId, structureId, 3448 orderByComparator); 3449 } 3450 3451 /** 3452 * Removes all the journal articles where groupId = ? and structureId = ? from the database. 3453 * 3454 * @param groupId the group ID 3455 * @param structureId the structure ID 3456 * @throws SystemException if a system exception occurred 3457 */ 3458 public static void removeByG_S(long groupId, java.lang.String structureId) 3459 throws com.liferay.portal.kernel.exception.SystemException { 3460 getPersistence().removeByG_S(groupId, structureId); 3461 } 3462 3463 /** 3464 * Returns the number of journal articles where groupId = ? and structureId = ?. 3465 * 3466 * @param groupId the group ID 3467 * @param structureId the structure ID 3468 * @return the number of matching journal articles 3469 * @throws SystemException if a system exception occurred 3470 */ 3471 public static int countByG_S(long groupId, java.lang.String structureId) 3472 throws com.liferay.portal.kernel.exception.SystemException { 3473 return getPersistence().countByG_S(groupId, structureId); 3474 } 3475 3476 /** 3477 * Returns the number of journal articles that the user has permission to view where groupId = ? and structureId = ?. 3478 * 3479 * @param groupId the group ID 3480 * @param structureId the structure ID 3481 * @return the number of matching journal articles that the user has permission to view 3482 * @throws SystemException if a system exception occurred 3483 */ 3484 public static int filterCountByG_S(long groupId, 3485 java.lang.String structureId) 3486 throws com.liferay.portal.kernel.exception.SystemException { 3487 return getPersistence().filterCountByG_S(groupId, structureId); 3488 } 3489 3490 /** 3491 * Returns all the journal articles where groupId = ? and templateId = ?. 3492 * 3493 * @param groupId the group ID 3494 * @param templateId the template ID 3495 * @return the matching journal articles 3496 * @throws SystemException if a system exception occurred 3497 */ 3498 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3499 long groupId, java.lang.String templateId) 3500 throws com.liferay.portal.kernel.exception.SystemException { 3501 return getPersistence().findByG_T(groupId, templateId); 3502 } 3503 3504 /** 3505 * Returns a range of all the journal articles where groupId = ? and templateId = ?. 3506 * 3507 * <p> 3508 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3509 * </p> 3510 * 3511 * @param groupId the group ID 3512 * @param templateId the template ID 3513 * @param start the lower bound of the range of journal articles 3514 * @param end the upper bound of the range of journal articles (not inclusive) 3515 * @return the range of matching journal articles 3516 * @throws SystemException if a system exception occurred 3517 */ 3518 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3519 long groupId, java.lang.String templateId, int start, int end) 3520 throws com.liferay.portal.kernel.exception.SystemException { 3521 return getPersistence().findByG_T(groupId, templateId, start, end); 3522 } 3523 3524 /** 3525 * Returns an ordered range of all the journal articles where groupId = ? and templateId = ?. 3526 * 3527 * <p> 3528 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3529 * </p> 3530 * 3531 * @param groupId the group ID 3532 * @param templateId the template ID 3533 * @param start the lower bound of the range of journal articles 3534 * @param end the upper bound of the range of journal articles (not inclusive) 3535 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3536 * @return the ordered range of matching journal articles 3537 * @throws SystemException if a system exception occurred 3538 */ 3539 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3540 long groupId, java.lang.String templateId, int start, int end, 3541 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3542 throws com.liferay.portal.kernel.exception.SystemException { 3543 return getPersistence() 3544 .findByG_T(groupId, templateId, start, end, orderByComparator); 3545 } 3546 3547 /** 3548 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3549 * 3550 * @param groupId the group ID 3551 * @param templateId the template ID 3552 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3553 * @return the first matching journal article 3554 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3555 * @throws SystemException if a system exception occurred 3556 */ 3557 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First( 3558 long groupId, java.lang.String templateId, 3559 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3560 throws com.liferay.portal.kernel.exception.SystemException, 3561 com.liferay.portlet.journal.NoSuchArticleException { 3562 return getPersistence() 3563 .findByG_T_First(groupId, templateId, orderByComparator); 3564 } 3565 3566 /** 3567 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3568 * 3569 * @param groupId the group ID 3570 * @param templateId the template ID 3571 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3572 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3573 * @throws SystemException if a system exception occurred 3574 */ 3575 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First( 3576 long groupId, java.lang.String templateId, 3577 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3578 throws com.liferay.portal.kernel.exception.SystemException { 3579 return getPersistence() 3580 .fetchByG_T_First(groupId, templateId, orderByComparator); 3581 } 3582 3583 /** 3584 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3585 * 3586 * @param groupId the group ID 3587 * @param templateId the template ID 3588 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3589 * @return the last matching journal article 3590 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3591 * @throws SystemException if a system exception occurred 3592 */ 3593 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last( 3594 long groupId, java.lang.String templateId, 3595 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3596 throws com.liferay.portal.kernel.exception.SystemException, 3597 com.liferay.portlet.journal.NoSuchArticleException { 3598 return getPersistence() 3599 .findByG_T_Last(groupId, templateId, orderByComparator); 3600 } 3601 3602 /** 3603 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3604 * 3605 * @param groupId the group ID 3606 * @param templateId the template ID 3607 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3608 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3609 * @throws SystemException if a system exception occurred 3610 */ 3611 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last( 3612 long groupId, java.lang.String templateId, 3613 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3614 throws com.liferay.portal.kernel.exception.SystemException { 3615 return getPersistence() 3616 .fetchByG_T_Last(groupId, templateId, orderByComparator); 3617 } 3618 3619 /** 3620 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and templateId = ?. 3621 * 3622 * @param id the primary key of the current journal article 3623 * @param groupId the group ID 3624 * @param templateId the template ID 3625 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3626 * @return the previous, current, and next journal article 3627 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3628 * @throws SystemException if a system exception occurred 3629 */ 3630 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext( 3631 long id, long groupId, java.lang.String templateId, 3632 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3633 throws com.liferay.portal.kernel.exception.SystemException, 3634 com.liferay.portlet.journal.NoSuchArticleException { 3635 return getPersistence() 3636 .findByG_T_PrevAndNext(id, groupId, templateId, 3637 orderByComparator); 3638 } 3639 3640 /** 3641 * Returns all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3642 * 3643 * @param groupId the group ID 3644 * @param templateId the template ID 3645 * @return the matching journal articles that the user has permission to view 3646 * @throws SystemException if a system exception occurred 3647 */ 3648 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3649 long groupId, java.lang.String templateId) 3650 throws com.liferay.portal.kernel.exception.SystemException { 3651 return getPersistence().filterFindByG_T(groupId, templateId); 3652 } 3653 3654 /** 3655 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3656 * 3657 * <p> 3658 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3659 * </p> 3660 * 3661 * @param groupId the group ID 3662 * @param templateId the template ID 3663 * @param start the lower bound of the range of journal articles 3664 * @param end the upper bound of the range of journal articles (not inclusive) 3665 * @return the range of matching journal articles that the user has permission to view 3666 * @throws SystemException if a system exception occurred 3667 */ 3668 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3669 long groupId, java.lang.String templateId, int start, int end) 3670 throws com.liferay.portal.kernel.exception.SystemException { 3671 return getPersistence().filterFindByG_T(groupId, templateId, start, end); 3672 } 3673 3674 /** 3675 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and templateId = ?. 3676 * 3677 * <p> 3678 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3679 * </p> 3680 * 3681 * @param groupId the group ID 3682 * @param templateId the template ID 3683 * @param start the lower bound of the range of journal articles 3684 * @param end the upper bound of the range of journal articles (not inclusive) 3685 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3686 * @return the ordered range of matching journal articles that the user has permission to view 3687 * @throws SystemException if a system exception occurred 3688 */ 3689 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3690 long groupId, java.lang.String templateId, int start, int end, 3691 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3692 throws com.liferay.portal.kernel.exception.SystemException { 3693 return getPersistence() 3694 .filterFindByG_T(groupId, templateId, start, end, 3695 orderByComparator); 3696 } 3697 3698 /** 3699 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and templateId = ?. 3700 * 3701 * @param id the primary key of the current journal article 3702 * @param groupId the group ID 3703 * @param templateId the template ID 3704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3705 * @return the previous, current, and next journal article 3706 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3707 * @throws SystemException if a system exception occurred 3708 */ 3709 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext( 3710 long id, long groupId, java.lang.String templateId, 3711 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3712 throws com.liferay.portal.kernel.exception.SystemException, 3713 com.liferay.portlet.journal.NoSuchArticleException { 3714 return getPersistence() 3715 .filterFindByG_T_PrevAndNext(id, groupId, templateId, 3716 orderByComparator); 3717 } 3718 3719 /** 3720 * Removes all the journal articles where groupId = ? and templateId = ? from the database. 3721 * 3722 * @param groupId the group ID 3723 * @param templateId the template ID 3724 * @throws SystemException if a system exception occurred 3725 */ 3726 public static void removeByG_T(long groupId, java.lang.String templateId) 3727 throws com.liferay.portal.kernel.exception.SystemException { 3728 getPersistence().removeByG_T(groupId, templateId); 3729 } 3730 3731 /** 3732 * Returns the number of journal articles where groupId = ? and templateId = ?. 3733 * 3734 * @param groupId the group ID 3735 * @param templateId the template ID 3736 * @return the number of matching journal articles 3737 * @throws SystemException if a system exception occurred 3738 */ 3739 public static int countByG_T(long groupId, java.lang.String templateId) 3740 throws com.liferay.portal.kernel.exception.SystemException { 3741 return getPersistence().countByG_T(groupId, templateId); 3742 } 3743 3744 /** 3745 * Returns the number of journal articles that the user has permission to view where groupId = ? and templateId = ?. 3746 * 3747 * @param groupId the group ID 3748 * @param templateId the template ID 3749 * @return the number of matching journal articles that the user has permission to view 3750 * @throws SystemException if a system exception occurred 3751 */ 3752 public static int filterCountByG_T(long groupId, java.lang.String templateId) 3753 throws com.liferay.portal.kernel.exception.SystemException { 3754 return getPersistence().filterCountByG_T(groupId, templateId); 3755 } 3756 3757 /** 3758 * Returns all the journal articles where groupId = ? and layoutUuid = ?. 3759 * 3760 * @param groupId the group ID 3761 * @param layoutUuid the layout uuid 3762 * @return the matching journal articles 3763 * @throws SystemException if a system exception occurred 3764 */ 3765 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3766 long groupId, java.lang.String layoutUuid) 3767 throws com.liferay.portal.kernel.exception.SystemException { 3768 return getPersistence().findByG_L(groupId, layoutUuid); 3769 } 3770 3771 /** 3772 * Returns a range of all the journal articles where groupId = ? and layoutUuid = ?. 3773 * 3774 * <p> 3775 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3776 * </p> 3777 * 3778 * @param groupId the group ID 3779 * @param layoutUuid the layout uuid 3780 * @param start the lower bound of the range of journal articles 3781 * @param end the upper bound of the range of journal articles (not inclusive) 3782 * @return the range of matching journal articles 3783 * @throws SystemException if a system exception occurred 3784 */ 3785 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3786 long groupId, java.lang.String layoutUuid, int start, int end) 3787 throws com.liferay.portal.kernel.exception.SystemException { 3788 return getPersistence().findByG_L(groupId, layoutUuid, start, end); 3789 } 3790 3791 /** 3792 * Returns an ordered range of all the journal articles where groupId = ? and layoutUuid = ?. 3793 * 3794 * <p> 3795 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3796 * </p> 3797 * 3798 * @param groupId the group ID 3799 * @param layoutUuid the layout uuid 3800 * @param start the lower bound of the range of journal articles 3801 * @param end the upper bound of the range of journal articles (not inclusive) 3802 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3803 * @return the ordered range of matching journal articles 3804 * @throws SystemException if a system exception occurred 3805 */ 3806 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3807 long groupId, java.lang.String layoutUuid, int start, int end, 3808 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3809 throws com.liferay.portal.kernel.exception.SystemException { 3810 return getPersistence() 3811 .findByG_L(groupId, layoutUuid, start, end, orderByComparator); 3812 } 3813 3814 /** 3815 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 3816 * 3817 * @param groupId the group ID 3818 * @param layoutUuid the layout uuid 3819 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3820 * @return the first matching journal article 3821 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3822 * @throws SystemException if a system exception occurred 3823 */ 3824 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First( 3825 long groupId, java.lang.String layoutUuid, 3826 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3827 throws com.liferay.portal.kernel.exception.SystemException, 3828 com.liferay.portlet.journal.NoSuchArticleException { 3829 return getPersistence() 3830 .findByG_L_First(groupId, layoutUuid, orderByComparator); 3831 } 3832 3833 /** 3834 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 3835 * 3836 * @param groupId the group ID 3837 * @param layoutUuid the layout uuid 3838 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3839 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3840 * @throws SystemException if a system exception occurred 3841 */ 3842 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First( 3843 long groupId, java.lang.String layoutUuid, 3844 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3845 throws com.liferay.portal.kernel.exception.SystemException { 3846 return getPersistence() 3847 .fetchByG_L_First(groupId, layoutUuid, orderByComparator); 3848 } 3849 3850 /** 3851 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 3852 * 3853 * @param groupId the group ID 3854 * @param layoutUuid the layout uuid 3855 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3856 * @return the last matching journal article 3857 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3858 * @throws SystemException if a system exception occurred 3859 */ 3860 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last( 3861 long groupId, java.lang.String layoutUuid, 3862 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3863 throws com.liferay.portal.kernel.exception.SystemException, 3864 com.liferay.portlet.journal.NoSuchArticleException { 3865 return getPersistence() 3866 .findByG_L_Last(groupId, layoutUuid, orderByComparator); 3867 } 3868 3869 /** 3870 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 3871 * 3872 * @param groupId the group ID 3873 * @param layoutUuid the layout uuid 3874 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3875 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3876 * @throws SystemException if a system exception occurred 3877 */ 3878 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last( 3879 long groupId, java.lang.String layoutUuid, 3880 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3881 throws com.liferay.portal.kernel.exception.SystemException { 3882 return getPersistence() 3883 .fetchByG_L_Last(groupId, layoutUuid, orderByComparator); 3884 } 3885 3886 /** 3887 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and layoutUuid = ?. 3888 * 3889 * @param id the primary key of the current journal article 3890 * @param groupId the group ID 3891 * @param layoutUuid the layout uuid 3892 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3893 * @return the previous, current, and next journal article 3894 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3895 * @throws SystemException if a system exception occurred 3896 */ 3897 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext( 3898 long id, long groupId, java.lang.String layoutUuid, 3899 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3900 throws com.liferay.portal.kernel.exception.SystemException, 3901 com.liferay.portlet.journal.NoSuchArticleException { 3902 return getPersistence() 3903 .findByG_L_PrevAndNext(id, groupId, layoutUuid, 3904 orderByComparator); 3905 } 3906 3907 /** 3908 * Returns all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 3909 * 3910 * @param groupId the group ID 3911 * @param layoutUuid the layout uuid 3912 * @return the matching journal articles that the user has permission to view 3913 * @throws SystemException if a system exception occurred 3914 */ 3915 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 3916 long groupId, java.lang.String layoutUuid) 3917 throws com.liferay.portal.kernel.exception.SystemException { 3918 return getPersistence().filterFindByG_L(groupId, layoutUuid); 3919 } 3920 3921 /** 3922 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 3923 * 3924 * <p> 3925 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3926 * </p> 3927 * 3928 * @param groupId the group ID 3929 * @param layoutUuid the layout uuid 3930 * @param start the lower bound of the range of journal articles 3931 * @param end the upper bound of the range of journal articles (not inclusive) 3932 * @return the range of matching journal articles that the user has permission to view 3933 * @throws SystemException if a system exception occurred 3934 */ 3935 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 3936 long groupId, java.lang.String layoutUuid, int start, int end) 3937 throws com.liferay.portal.kernel.exception.SystemException { 3938 return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end); 3939 } 3940 3941 /** 3942 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and layoutUuid = ?. 3943 * 3944 * <p> 3945 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3946 * </p> 3947 * 3948 * @param groupId the group ID 3949 * @param layoutUuid the layout uuid 3950 * @param start the lower bound of the range of journal articles 3951 * @param end the upper bound of the range of journal articles (not inclusive) 3952 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3953 * @return the ordered range of matching journal articles that the user has permission to view 3954 * @throws SystemException if a system exception occurred 3955 */ 3956 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 3957 long groupId, java.lang.String layoutUuid, int start, int end, 3958 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3959 throws com.liferay.portal.kernel.exception.SystemException { 3960 return getPersistence() 3961 .filterFindByG_L(groupId, layoutUuid, start, end, 3962 orderByComparator); 3963 } 3964 3965 /** 3966 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 3967 * 3968 * @param id the primary key of the current journal article 3969 * @param groupId the group ID 3970 * @param layoutUuid the layout uuid 3971 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3972 * @return the previous, current, and next journal article 3973 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3974 * @throws SystemException if a system exception occurred 3975 */ 3976 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext( 3977 long id, long groupId, java.lang.String layoutUuid, 3978 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3979 throws com.liferay.portal.kernel.exception.SystemException, 3980 com.liferay.portlet.journal.NoSuchArticleException { 3981 return getPersistence() 3982 .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid, 3983 orderByComparator); 3984 } 3985 3986 /** 3987 * Removes all the journal articles where groupId = ? and layoutUuid = ? from the database. 3988 * 3989 * @param groupId the group ID 3990 * @param layoutUuid the layout uuid 3991 * @throws SystemException if a system exception occurred 3992 */ 3993 public static void removeByG_L(long groupId, java.lang.String layoutUuid) 3994 throws com.liferay.portal.kernel.exception.SystemException { 3995 getPersistence().removeByG_L(groupId, layoutUuid); 3996 } 3997 3998 /** 3999 * Returns the number of journal articles where groupId = ? and layoutUuid = ?. 4000 * 4001 * @param groupId the group ID 4002 * @param layoutUuid the layout uuid 4003 * @return the number of matching journal articles 4004 * @throws SystemException if a system exception occurred 4005 */ 4006 public static int countByG_L(long groupId, java.lang.String layoutUuid) 4007 throws com.liferay.portal.kernel.exception.SystemException { 4008 return getPersistence().countByG_L(groupId, layoutUuid); 4009 } 4010 4011 /** 4012 * Returns the number of journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4013 * 4014 * @param groupId the group ID 4015 * @param layoutUuid the layout uuid 4016 * @return the number of matching journal articles that the user has permission to view 4017 * @throws SystemException if a system exception occurred 4018 */ 4019 public static int filterCountByG_L(long groupId, java.lang.String layoutUuid) 4020 throws com.liferay.portal.kernel.exception.SystemException { 4021 return getPersistence().filterCountByG_L(groupId, layoutUuid); 4022 } 4023 4024 /** 4025 * Returns all the journal articles where groupId = ? and status = ?. 4026 * 4027 * @param groupId the group ID 4028 * @param status the status 4029 * @return the matching journal articles 4030 * @throws SystemException if a system exception occurred 4031 */ 4032 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4033 long groupId, int status) 4034 throws com.liferay.portal.kernel.exception.SystemException { 4035 return getPersistence().findByG_ST(groupId, status); 4036 } 4037 4038 /** 4039 * Returns a range of all the journal articles where groupId = ? and status = ?. 4040 * 4041 * <p> 4042 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4043 * </p> 4044 * 4045 * @param groupId the group ID 4046 * @param status the status 4047 * @param start the lower bound of the range of journal articles 4048 * @param end the upper bound of the range of journal articles (not inclusive) 4049 * @return the range of matching journal articles 4050 * @throws SystemException if a system exception occurred 4051 */ 4052 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4053 long groupId, int status, int start, int end) 4054 throws com.liferay.portal.kernel.exception.SystemException { 4055 return getPersistence().findByG_ST(groupId, status, start, end); 4056 } 4057 4058 /** 4059 * Returns an ordered range of all the journal articles where groupId = ? and status = ?. 4060 * 4061 * <p> 4062 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4063 * </p> 4064 * 4065 * @param groupId the group ID 4066 * @param status the status 4067 * @param start the lower bound of the range of journal articles 4068 * @param end the upper bound of the range of journal articles (not inclusive) 4069 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4070 * @return the ordered range of matching journal articles 4071 * @throws SystemException if a system exception occurred 4072 */ 4073 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4074 long groupId, int status, int start, int end, 4075 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4076 throws com.liferay.portal.kernel.exception.SystemException { 4077 return getPersistence() 4078 .findByG_ST(groupId, status, start, end, orderByComparator); 4079 } 4080 4081 /** 4082 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4083 * 4084 * @param groupId the group ID 4085 * @param status the status 4086 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4087 * @return the first matching journal article 4088 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4089 * @throws SystemException if a system exception occurred 4090 */ 4091 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First( 4092 long groupId, int status, 4093 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4094 throws com.liferay.portal.kernel.exception.SystemException, 4095 com.liferay.portlet.journal.NoSuchArticleException { 4096 return getPersistence() 4097 .findByG_ST_First(groupId, status, orderByComparator); 4098 } 4099 4100 /** 4101 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4102 * 4103 * @param groupId the group ID 4104 * @param status the status 4105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4106 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4107 * @throws SystemException if a system exception occurred 4108 */ 4109 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First( 4110 long groupId, int status, 4111 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4112 throws com.liferay.portal.kernel.exception.SystemException { 4113 return getPersistence() 4114 .fetchByG_ST_First(groupId, status, orderByComparator); 4115 } 4116 4117 /** 4118 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4119 * 4120 * @param groupId the group ID 4121 * @param status the status 4122 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4123 * @return the last matching journal article 4124 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4125 * @throws SystemException if a system exception occurred 4126 */ 4127 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last( 4128 long groupId, int status, 4129 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4130 throws com.liferay.portal.kernel.exception.SystemException, 4131 com.liferay.portlet.journal.NoSuchArticleException { 4132 return getPersistence() 4133 .findByG_ST_Last(groupId, status, orderByComparator); 4134 } 4135 4136 /** 4137 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4138 * 4139 * @param groupId the group ID 4140 * @param status the status 4141 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4142 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4143 * @throws SystemException if a system exception occurred 4144 */ 4145 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last( 4146 long groupId, int status, 4147 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4148 throws com.liferay.portal.kernel.exception.SystemException { 4149 return getPersistence() 4150 .fetchByG_ST_Last(groupId, status, orderByComparator); 4151 } 4152 4153 /** 4154 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and status = ?. 4155 * 4156 * @param id the primary key of the current journal article 4157 * @param groupId the group ID 4158 * @param status the status 4159 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4160 * @return the previous, current, and next journal article 4161 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4162 * @throws SystemException if a system exception occurred 4163 */ 4164 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext( 4165 long id, long groupId, int status, 4166 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4167 throws com.liferay.portal.kernel.exception.SystemException, 4168 com.liferay.portlet.journal.NoSuchArticleException { 4169 return getPersistence() 4170 .findByG_ST_PrevAndNext(id, groupId, status, 4171 orderByComparator); 4172 } 4173 4174 /** 4175 * Returns all the journal articles that the user has permission to view where groupId = ? and status = ?. 4176 * 4177 * @param groupId the group ID 4178 * @param status the status 4179 * @return the matching journal articles that the user has permission to view 4180 * @throws SystemException if a system exception occurred 4181 */ 4182 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4183 long groupId, int status) 4184 throws com.liferay.portal.kernel.exception.SystemException { 4185 return getPersistence().filterFindByG_ST(groupId, status); 4186 } 4187 4188 /** 4189 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and status = ?. 4190 * 4191 * <p> 4192 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4193 * </p> 4194 * 4195 * @param groupId the group ID 4196 * @param status the status 4197 * @param start the lower bound of the range of journal articles 4198 * @param end the upper bound of the range of journal articles (not inclusive) 4199 * @return the range of matching journal articles that the user has permission to view 4200 * @throws SystemException if a system exception occurred 4201 */ 4202 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4203 long groupId, int status, int start, int end) 4204 throws com.liferay.portal.kernel.exception.SystemException { 4205 return getPersistence().filterFindByG_ST(groupId, status, start, end); 4206 } 4207 4208 /** 4209 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and status = ?. 4210 * 4211 * <p> 4212 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4213 * </p> 4214 * 4215 * @param groupId the group ID 4216 * @param status the status 4217 * @param start the lower bound of the range of journal articles 4218 * @param end the upper bound of the range of journal articles (not inclusive) 4219 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4220 * @return the ordered range of matching journal articles that the user has permission to view 4221 * @throws SystemException if a system exception occurred 4222 */ 4223 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4224 long groupId, int status, int start, int end, 4225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4226 throws com.liferay.portal.kernel.exception.SystemException { 4227 return getPersistence() 4228 .filterFindByG_ST(groupId, status, start, end, 4229 orderByComparator); 4230 } 4231 4232 /** 4233 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and status = ?. 4234 * 4235 * @param id the primary key of the current journal article 4236 * @param groupId the group ID 4237 * @param status the status 4238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4239 * @return the previous, current, and next journal article 4240 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4241 * @throws SystemException if a system exception occurred 4242 */ 4243 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext( 4244 long id, long groupId, int status, 4245 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4246 throws com.liferay.portal.kernel.exception.SystemException, 4247 com.liferay.portlet.journal.NoSuchArticleException { 4248 return getPersistence() 4249 .filterFindByG_ST_PrevAndNext(id, groupId, status, 4250 orderByComparator); 4251 } 4252 4253 /** 4254 * Removes all the journal articles where groupId = ? and status = ? from the database. 4255 * 4256 * @param groupId the group ID 4257 * @param status the status 4258 * @throws SystemException if a system exception occurred 4259 */ 4260 public static void removeByG_ST(long groupId, int status) 4261 throws com.liferay.portal.kernel.exception.SystemException { 4262 getPersistence().removeByG_ST(groupId, status); 4263 } 4264 4265 /** 4266 * Returns the number of journal articles where groupId = ? and status = ?. 4267 * 4268 * @param groupId the group ID 4269 * @param status the status 4270 * @return the number of matching journal articles 4271 * @throws SystemException if a system exception occurred 4272 */ 4273 public static int countByG_ST(long groupId, int status) 4274 throws com.liferay.portal.kernel.exception.SystemException { 4275 return getPersistence().countByG_ST(groupId, status); 4276 } 4277 4278 /** 4279 * Returns the number of journal articles that the user has permission to view where groupId = ? and status = ?. 4280 * 4281 * @param groupId the group ID 4282 * @param status the status 4283 * @return the number of matching journal articles that the user has permission to view 4284 * @throws SystemException if a system exception occurred 4285 */ 4286 public static int filterCountByG_ST(long groupId, int status) 4287 throws com.liferay.portal.kernel.exception.SystemException { 4288 return getPersistence().filterCountByG_ST(groupId, status); 4289 } 4290 4291 /** 4292 * Returns all the journal articles where companyId = ? and version = ?. 4293 * 4294 * @param companyId the company ID 4295 * @param version the version 4296 * @return the matching journal articles 4297 * @throws SystemException if a system exception occurred 4298 */ 4299 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4300 long companyId, double version) 4301 throws com.liferay.portal.kernel.exception.SystemException { 4302 return getPersistence().findByC_V(companyId, version); 4303 } 4304 4305 /** 4306 * Returns a range of all the journal articles where companyId = ? and version = ?. 4307 * 4308 * <p> 4309 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4310 * </p> 4311 * 4312 * @param companyId the company ID 4313 * @param version the version 4314 * @param start the lower bound of the range of journal articles 4315 * @param end the upper bound of the range of journal articles (not inclusive) 4316 * @return the range of matching journal articles 4317 * @throws SystemException if a system exception occurred 4318 */ 4319 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4320 long companyId, double version, int start, int end) 4321 throws com.liferay.portal.kernel.exception.SystemException { 4322 return getPersistence().findByC_V(companyId, version, start, end); 4323 } 4324 4325 /** 4326 * Returns an ordered range of all the journal articles where companyId = ? and version = ?. 4327 * 4328 * <p> 4329 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4330 * </p> 4331 * 4332 * @param companyId the company ID 4333 * @param version the version 4334 * @param start the lower bound of the range of journal articles 4335 * @param end the upper bound of the range of journal articles (not inclusive) 4336 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4337 * @return the ordered range of matching journal articles 4338 * @throws SystemException if a system exception occurred 4339 */ 4340 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4341 long companyId, double version, int start, int end, 4342 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4343 throws com.liferay.portal.kernel.exception.SystemException { 4344 return getPersistence() 4345 .findByC_V(companyId, version, start, end, orderByComparator); 4346 } 4347 4348 /** 4349 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 4350 * 4351 * @param companyId the company ID 4352 * @param version the version 4353 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4354 * @return the first matching journal article 4355 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4356 * @throws SystemException if a system exception occurred 4357 */ 4358 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First( 4359 long companyId, double version, 4360 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4361 throws com.liferay.portal.kernel.exception.SystemException, 4362 com.liferay.portlet.journal.NoSuchArticleException { 4363 return getPersistence() 4364 .findByC_V_First(companyId, version, orderByComparator); 4365 } 4366 4367 /** 4368 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 4369 * 4370 * @param companyId the company ID 4371 * @param version the version 4372 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4373 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4374 * @throws SystemException if a system exception occurred 4375 */ 4376 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First( 4377 long companyId, double version, 4378 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4379 throws com.liferay.portal.kernel.exception.SystemException { 4380 return getPersistence() 4381 .fetchByC_V_First(companyId, version, orderByComparator); 4382 } 4383 4384 /** 4385 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 4386 * 4387 * @param companyId the company ID 4388 * @param version the version 4389 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4390 * @return the last matching journal article 4391 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4392 * @throws SystemException if a system exception occurred 4393 */ 4394 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last( 4395 long companyId, double version, 4396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4397 throws com.liferay.portal.kernel.exception.SystemException, 4398 com.liferay.portlet.journal.NoSuchArticleException { 4399 return getPersistence() 4400 .findByC_V_Last(companyId, version, orderByComparator); 4401 } 4402 4403 /** 4404 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 4405 * 4406 * @param companyId the company ID 4407 * @param version the version 4408 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4409 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4410 * @throws SystemException if a system exception occurred 4411 */ 4412 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last( 4413 long companyId, double version, 4414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4415 throws com.liferay.portal.kernel.exception.SystemException { 4416 return getPersistence() 4417 .fetchByC_V_Last(companyId, version, orderByComparator); 4418 } 4419 4420 /** 4421 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ?. 4422 * 4423 * @param id the primary key of the current journal article 4424 * @param companyId the company ID 4425 * @param version the version 4426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4427 * @return the previous, current, and next journal article 4428 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4429 * @throws SystemException if a system exception occurred 4430 */ 4431 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext( 4432 long id, long companyId, double version, 4433 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4434 throws com.liferay.portal.kernel.exception.SystemException, 4435 com.liferay.portlet.journal.NoSuchArticleException { 4436 return getPersistence() 4437 .findByC_V_PrevAndNext(id, companyId, version, 4438 orderByComparator); 4439 } 4440 4441 /** 4442 * Removes all the journal articles where companyId = ? and version = ? from the database. 4443 * 4444 * @param companyId the company ID 4445 * @param version the version 4446 * @throws SystemException if a system exception occurred 4447 */ 4448 public static void removeByC_V(long companyId, double version) 4449 throws com.liferay.portal.kernel.exception.SystemException { 4450 getPersistence().removeByC_V(companyId, version); 4451 } 4452 4453 /** 4454 * Returns the number of journal articles where companyId = ? and version = ?. 4455 * 4456 * @param companyId the company ID 4457 * @param version the version 4458 * @return the number of matching journal articles 4459 * @throws SystemException if a system exception occurred 4460 */ 4461 public static int countByC_V(long companyId, double version) 4462 throws com.liferay.portal.kernel.exception.SystemException { 4463 return getPersistence().countByC_V(companyId, version); 4464 } 4465 4466 /** 4467 * Returns all the journal articles where companyId = ? and status = ?. 4468 * 4469 * @param companyId the company ID 4470 * @param status the status 4471 * @return the matching journal articles 4472 * @throws SystemException if a system exception occurred 4473 */ 4474 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4475 long companyId, int status) 4476 throws com.liferay.portal.kernel.exception.SystemException { 4477 return getPersistence().findByC_ST(companyId, status); 4478 } 4479 4480 /** 4481 * Returns a range of all the journal articles where companyId = ? and status = ?. 4482 * 4483 * <p> 4484 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4485 * </p> 4486 * 4487 * @param companyId the company ID 4488 * @param status the status 4489 * @param start the lower bound of the range of journal articles 4490 * @param end the upper bound of the range of journal articles (not inclusive) 4491 * @return the range of matching journal articles 4492 * @throws SystemException if a system exception occurred 4493 */ 4494 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4495 long companyId, int status, int start, int end) 4496 throws com.liferay.portal.kernel.exception.SystemException { 4497 return getPersistence().findByC_ST(companyId, status, start, end); 4498 } 4499 4500 /** 4501 * Returns an ordered range of all the journal articles where companyId = ? and status = ?. 4502 * 4503 * <p> 4504 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4505 * </p> 4506 * 4507 * @param companyId the company ID 4508 * @param status the status 4509 * @param start the lower bound of the range of journal articles 4510 * @param end the upper bound of the range of journal articles (not inclusive) 4511 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4512 * @return the ordered range of matching journal articles 4513 * @throws SystemException if a system exception occurred 4514 */ 4515 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4516 long companyId, int status, int start, int end, 4517 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4518 throws com.liferay.portal.kernel.exception.SystemException { 4519 return getPersistence() 4520 .findByC_ST(companyId, status, start, end, orderByComparator); 4521 } 4522 4523 /** 4524 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 4525 * 4526 * @param companyId the company ID 4527 * @param status the status 4528 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4529 * @return the first matching journal article 4530 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4531 * @throws SystemException if a system exception occurred 4532 */ 4533 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First( 4534 long companyId, int status, 4535 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4536 throws com.liferay.portal.kernel.exception.SystemException, 4537 com.liferay.portlet.journal.NoSuchArticleException { 4538 return getPersistence() 4539 .findByC_ST_First(companyId, status, orderByComparator); 4540 } 4541 4542 /** 4543 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 4544 * 4545 * @param companyId the company ID 4546 * @param status the status 4547 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4548 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4549 * @throws SystemException if a system exception occurred 4550 */ 4551 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First( 4552 long companyId, int status, 4553 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4554 throws com.liferay.portal.kernel.exception.SystemException { 4555 return getPersistence() 4556 .fetchByC_ST_First(companyId, status, orderByComparator); 4557 } 4558 4559 /** 4560 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 4561 * 4562 * @param companyId the company ID 4563 * @param status the status 4564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4565 * @return the last matching journal article 4566 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4567 * @throws SystemException if a system exception occurred 4568 */ 4569 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last( 4570 long companyId, int status, 4571 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4572 throws com.liferay.portal.kernel.exception.SystemException, 4573 com.liferay.portlet.journal.NoSuchArticleException { 4574 return getPersistence() 4575 .findByC_ST_Last(companyId, status, orderByComparator); 4576 } 4577 4578 /** 4579 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 4580 * 4581 * @param companyId the company ID 4582 * @param status the status 4583 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4584 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4585 * @throws SystemException if a system exception occurred 4586 */ 4587 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last( 4588 long companyId, int status, 4589 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4590 throws com.liferay.portal.kernel.exception.SystemException { 4591 return getPersistence() 4592 .fetchByC_ST_Last(companyId, status, orderByComparator); 4593 } 4594 4595 /** 4596 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status = ?. 4597 * 4598 * @param id the primary key of the current journal article 4599 * @param companyId the company ID 4600 * @param status the status 4601 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4602 * @return the previous, current, and next journal article 4603 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4604 * @throws SystemException if a system exception occurred 4605 */ 4606 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext( 4607 long id, long companyId, int status, 4608 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4609 throws com.liferay.portal.kernel.exception.SystemException, 4610 com.liferay.portlet.journal.NoSuchArticleException { 4611 return getPersistence() 4612 .findByC_ST_PrevAndNext(id, companyId, status, 4613 orderByComparator); 4614 } 4615 4616 /** 4617 * Removes all the journal articles where companyId = ? and status = ? from the database. 4618 * 4619 * @param companyId the company ID 4620 * @param status the status 4621 * @throws SystemException if a system exception occurred 4622 */ 4623 public static void removeByC_ST(long companyId, int status) 4624 throws com.liferay.portal.kernel.exception.SystemException { 4625 getPersistence().removeByC_ST(companyId, status); 4626 } 4627 4628 /** 4629 * Returns the number of journal articles where companyId = ? and status = ?. 4630 * 4631 * @param companyId the company ID 4632 * @param status the status 4633 * @return the number of matching journal articles 4634 * @throws SystemException if a system exception occurred 4635 */ 4636 public static int countByC_ST(long companyId, int status) 4637 throws com.liferay.portal.kernel.exception.SystemException { 4638 return getPersistence().countByC_ST(companyId, status); 4639 } 4640 4641 /** 4642 * Returns all the journal articles where displayDate < ? and status = ?. 4643 * 4644 * @param displayDate the display date 4645 * @param status the status 4646 * @return the matching journal articles 4647 * @throws SystemException if a system exception occurred 4648 */ 4649 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 4650 java.util.Date displayDate, int status) 4651 throws com.liferay.portal.kernel.exception.SystemException { 4652 return getPersistence().findByLtD_S(displayDate, status); 4653 } 4654 4655 /** 4656 * Returns a range of all the journal articles where displayDate < ? and status = ?. 4657 * 4658 * <p> 4659 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4660 * </p> 4661 * 4662 * @param displayDate the display date 4663 * @param status the status 4664 * @param start the lower bound of the range of journal articles 4665 * @param end the upper bound of the range of journal articles (not inclusive) 4666 * @return the range of matching journal articles 4667 * @throws SystemException if a system exception occurred 4668 */ 4669 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 4670 java.util.Date displayDate, int status, int start, int end) 4671 throws com.liferay.portal.kernel.exception.SystemException { 4672 return getPersistence().findByLtD_S(displayDate, status, start, end); 4673 } 4674 4675 /** 4676 * Returns an ordered range of all the journal articles where displayDate < ? and status = ?. 4677 * 4678 * <p> 4679 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4680 * </p> 4681 * 4682 * @param displayDate the display date 4683 * @param status the status 4684 * @param start the lower bound of the range of journal articles 4685 * @param end the upper bound of the range of journal articles (not inclusive) 4686 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4687 * @return the ordered range of matching journal articles 4688 * @throws SystemException if a system exception occurred 4689 */ 4690 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 4691 java.util.Date displayDate, int status, int start, int end, 4692 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4693 throws com.liferay.portal.kernel.exception.SystemException { 4694 return getPersistence() 4695 .findByLtD_S(displayDate, status, start, end, 4696 orderByComparator); 4697 } 4698 4699 /** 4700 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 4701 * 4702 * @param displayDate the display date 4703 * @param status the status 4704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4705 * @return the first matching journal article 4706 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4707 * @throws SystemException if a system exception occurred 4708 */ 4709 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First( 4710 java.util.Date displayDate, int status, 4711 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4712 throws com.liferay.portal.kernel.exception.SystemException, 4713 com.liferay.portlet.journal.NoSuchArticleException { 4714 return getPersistence() 4715 .findByLtD_S_First(displayDate, status, orderByComparator); 4716 } 4717 4718 /** 4719 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 4720 * 4721 * @param displayDate the display date 4722 * @param status the status 4723 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4724 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4725 * @throws SystemException if a system exception occurred 4726 */ 4727 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First( 4728 java.util.Date displayDate, int status, 4729 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4730 throws com.liferay.portal.kernel.exception.SystemException { 4731 return getPersistence() 4732 .fetchByLtD_S_First(displayDate, status, orderByComparator); 4733 } 4734 4735 /** 4736 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 4737 * 4738 * @param displayDate the display date 4739 * @param status the status 4740 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4741 * @return the last matching journal article 4742 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4743 * @throws SystemException if a system exception occurred 4744 */ 4745 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_Last( 4746 java.util.Date displayDate, int status, 4747 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4748 throws com.liferay.portal.kernel.exception.SystemException, 4749 com.liferay.portlet.journal.NoSuchArticleException { 4750 return getPersistence() 4751 .findByLtD_S_Last(displayDate, status, orderByComparator); 4752 } 4753 4754 /** 4755 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 4756 * 4757 * @param displayDate the display date 4758 * @param status the status 4759 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4760 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4761 * @throws SystemException if a system exception occurred 4762 */ 4763 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last( 4764 java.util.Date displayDate, int status, 4765 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4766 throws com.liferay.portal.kernel.exception.SystemException { 4767 return getPersistence() 4768 .fetchByLtD_S_Last(displayDate, status, orderByComparator); 4769 } 4770 4771 /** 4772 * Returns the journal articles before and after the current journal article in the ordered set where displayDate < ? and status = ?. 4773 * 4774 * @param id the primary key of the current journal article 4775 * @param displayDate the display date 4776 * @param status the status 4777 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4778 * @return the previous, current, and next journal article 4779 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4780 * @throws SystemException if a system exception occurred 4781 */ 4782 public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext( 4783 long id, java.util.Date displayDate, int status, 4784 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4785 throws com.liferay.portal.kernel.exception.SystemException, 4786 com.liferay.portlet.journal.NoSuchArticleException { 4787 return getPersistence() 4788 .findByLtD_S_PrevAndNext(id, displayDate, status, 4789 orderByComparator); 4790 } 4791 4792 /** 4793 * Removes all the journal articles where displayDate < ? and status = ? from the database. 4794 * 4795 * @param displayDate the display date 4796 * @param status the status 4797 * @throws SystemException if a system exception occurred 4798 */ 4799 public static void removeByLtD_S(java.util.Date displayDate, int status) 4800 throws com.liferay.portal.kernel.exception.SystemException { 4801 getPersistence().removeByLtD_S(displayDate, status); 4802 } 4803 4804 /** 4805 * Returns the number of journal articles where displayDate < ? and status = ?. 4806 * 4807 * @param displayDate the display date 4808 * @param status the status 4809 * @return the number of matching journal articles 4810 * @throws SystemException if a system exception occurred 4811 */ 4812 public static int countByLtD_S(java.util.Date displayDate, int status) 4813 throws com.liferay.portal.kernel.exception.SystemException { 4814 return getPersistence().countByLtD_S(displayDate, status); 4815 } 4816 4817 /** 4818 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 4819 * 4820 * @param resourcePrimKey the resource prim key 4821 * @param indexable the indexable 4822 * @param status the status 4823 * @return the matching journal articles 4824 * @throws SystemException if a system exception occurred 4825 */ 4826 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 4827 long resourcePrimKey, boolean indexable, int status) 4828 throws com.liferay.portal.kernel.exception.SystemException { 4829 return getPersistence().findByR_I_S(resourcePrimKey, indexable, status); 4830 } 4831 4832 /** 4833 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 4834 * 4835 * <p> 4836 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4837 * </p> 4838 * 4839 * @param resourcePrimKey the resource prim key 4840 * @param indexable the indexable 4841 * @param status the status 4842 * @param start the lower bound of the range of journal articles 4843 * @param end the upper bound of the range of journal articles (not inclusive) 4844 * @return the range of matching journal articles 4845 * @throws SystemException if a system exception occurred 4846 */ 4847 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 4848 long resourcePrimKey, boolean indexable, int status, int start, int end) 4849 throws com.liferay.portal.kernel.exception.SystemException { 4850 return getPersistence() 4851 .findByR_I_S(resourcePrimKey, indexable, status, start, end); 4852 } 4853 4854 /** 4855 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 4856 * 4857 * <p> 4858 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4859 * </p> 4860 * 4861 * @param resourcePrimKey the resource prim key 4862 * @param indexable the indexable 4863 * @param status the status 4864 * @param start the lower bound of the range of journal articles 4865 * @param end the upper bound of the range of journal articles (not inclusive) 4866 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4867 * @return the ordered range of matching journal articles 4868 * @throws SystemException if a system exception occurred 4869 */ 4870 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 4871 long resourcePrimKey, boolean indexable, int status, int start, 4872 int end, 4873 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4874 throws com.liferay.portal.kernel.exception.SystemException { 4875 return getPersistence() 4876 .findByR_I_S(resourcePrimKey, indexable, status, start, end, 4877 orderByComparator); 4878 } 4879 4880 /** 4881 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 4882 * 4883 * @param resourcePrimKey the resource prim key 4884 * @param indexable the indexable 4885 * @param status the status 4886 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4887 * @return the first matching journal article 4888 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4889 * @throws SystemException if a system exception occurred 4890 */ 4891 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First( 4892 long resourcePrimKey, boolean indexable, int status, 4893 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4894 throws com.liferay.portal.kernel.exception.SystemException, 4895 com.liferay.portlet.journal.NoSuchArticleException { 4896 return getPersistence() 4897 .findByR_I_S_First(resourcePrimKey, indexable, status, 4898 orderByComparator); 4899 } 4900 4901 /** 4902 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 4903 * 4904 * @param resourcePrimKey the resource prim key 4905 * @param indexable the indexable 4906 * @param status the status 4907 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4908 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4909 * @throws SystemException if a system exception occurred 4910 */ 4911 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First( 4912 long resourcePrimKey, boolean indexable, int status, 4913 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4914 throws com.liferay.portal.kernel.exception.SystemException { 4915 return getPersistence() 4916 .fetchByR_I_S_First(resourcePrimKey, indexable, status, 4917 orderByComparator); 4918 } 4919 4920 /** 4921 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 4922 * 4923 * @param resourcePrimKey the resource prim key 4924 * @param indexable the indexable 4925 * @param status the status 4926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4927 * @return the last matching journal article 4928 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4929 * @throws SystemException if a system exception occurred 4930 */ 4931 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last( 4932 long resourcePrimKey, boolean indexable, int status, 4933 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4934 throws com.liferay.portal.kernel.exception.SystemException, 4935 com.liferay.portlet.journal.NoSuchArticleException { 4936 return getPersistence() 4937 .findByR_I_S_Last(resourcePrimKey, indexable, status, 4938 orderByComparator); 4939 } 4940 4941 /** 4942 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 4943 * 4944 * @param resourcePrimKey the resource prim key 4945 * @param indexable the indexable 4946 * @param status the status 4947 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4948 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4949 * @throws SystemException if a system exception occurred 4950 */ 4951 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last( 4952 long resourcePrimKey, boolean indexable, int status, 4953 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4954 throws com.liferay.portal.kernel.exception.SystemException { 4955 return getPersistence() 4956 .fetchByR_I_S_Last(resourcePrimKey, indexable, status, 4957 orderByComparator); 4958 } 4959 4960 /** 4961 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 4962 * 4963 * @param id the primary key of the current journal article 4964 * @param resourcePrimKey the resource prim key 4965 * @param indexable the indexable 4966 * @param status the status 4967 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4968 * @return the previous, current, and next journal article 4969 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4970 * @throws SystemException if a system exception occurred 4971 */ 4972 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext( 4973 long id, long resourcePrimKey, boolean indexable, int status, 4974 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4975 throws com.liferay.portal.kernel.exception.SystemException, 4976 com.liferay.portlet.journal.NoSuchArticleException { 4977 return getPersistence() 4978 .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable, 4979 status, orderByComparator); 4980 } 4981 4982 /** 4983 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 4984 * 4985 * <p> 4986 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4987 * </p> 4988 * 4989 * @param resourcePrimKey the resource prim key 4990 * @param indexable the indexable 4991 * @param statuses the statuses 4992 * @return the matching journal articles 4993 * @throws SystemException if a system exception occurred 4994 */ 4995 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 4996 long resourcePrimKey, boolean indexable, int[] statuses) 4997 throws com.liferay.portal.kernel.exception.SystemException { 4998 return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses); 4999 } 5000 5001 /** 5002 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5003 * 5004 * <p> 5005 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5006 * </p> 5007 * 5008 * @param resourcePrimKey the resource prim key 5009 * @param indexable the indexable 5010 * @param statuses the statuses 5011 * @param start the lower bound of the range of journal articles 5012 * @param end the upper bound of the range of journal articles (not inclusive) 5013 * @return the range of matching journal articles 5014 * @throws SystemException if a system exception occurred 5015 */ 5016 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5017 long resourcePrimKey, boolean indexable, int[] statuses, int start, 5018 int end) throws com.liferay.portal.kernel.exception.SystemException { 5019 return getPersistence() 5020 .findByR_I_S(resourcePrimKey, indexable, statuses, start, end); 5021 } 5022 5023 /** 5024 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5025 * 5026 * <p> 5027 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5028 * </p> 5029 * 5030 * @param resourcePrimKey the resource prim key 5031 * @param indexable the indexable 5032 * @param statuses the statuses 5033 * @param start the lower bound of the range of journal articles 5034 * @param end the upper bound of the range of journal articles (not inclusive) 5035 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5036 * @return the ordered range of matching journal articles 5037 * @throws SystemException if a system exception occurred 5038 */ 5039 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5040 long resourcePrimKey, boolean indexable, int[] statuses, int start, 5041 int end, 5042 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5043 throws com.liferay.portal.kernel.exception.SystemException { 5044 return getPersistence() 5045 .findByR_I_S(resourcePrimKey, indexable, statuses, start, 5046 end, orderByComparator); 5047 } 5048 5049 /** 5050 * Removes all the journal articles where resourcePrimKey = ? and indexable = ? and status = ? from the database. 5051 * 5052 * @param resourcePrimKey the resource prim key 5053 * @param indexable the indexable 5054 * @param status the status 5055 * @throws SystemException if a system exception occurred 5056 */ 5057 public static void removeByR_I_S(long resourcePrimKey, boolean indexable, 5058 int status) throws com.liferay.portal.kernel.exception.SystemException { 5059 getPersistence().removeByR_I_S(resourcePrimKey, indexable, status); 5060 } 5061 5062 /** 5063 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5064 * 5065 * @param resourcePrimKey the resource prim key 5066 * @param indexable the indexable 5067 * @param status the status 5068 * @return the number of matching journal articles 5069 * @throws SystemException if a system exception occurred 5070 */ 5071 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 5072 int status) throws com.liferay.portal.kernel.exception.SystemException { 5073 return getPersistence().countByR_I_S(resourcePrimKey, indexable, status); 5074 } 5075 5076 /** 5077 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5078 * 5079 * @param resourcePrimKey the resource prim key 5080 * @param indexable the indexable 5081 * @param statuses the statuses 5082 * @return the number of matching journal articles 5083 * @throws SystemException if a system exception occurred 5084 */ 5085 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 5086 int[] statuses) 5087 throws com.liferay.portal.kernel.exception.SystemException { 5088 return getPersistence() 5089 .countByR_I_S(resourcePrimKey, indexable, statuses); 5090 } 5091 5092 /** 5093 * Returns all the journal articles where groupId = ? and folderId = ? and status = ?. 5094 * 5095 * @param groupId the group ID 5096 * @param folderId the folder ID 5097 * @param status the status 5098 * @return the matching journal articles 5099 * @throws SystemException if a system exception occurred 5100 */ 5101 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5102 long groupId, long folderId, int status) 5103 throws com.liferay.portal.kernel.exception.SystemException { 5104 return getPersistence().findByG_F_ST(groupId, folderId, status); 5105 } 5106 5107 /** 5108 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = ?. 5109 * 5110 * <p> 5111 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5112 * </p> 5113 * 5114 * @param groupId the group ID 5115 * @param folderId the folder ID 5116 * @param status the status 5117 * @param start the lower bound of the range of journal articles 5118 * @param end the upper bound of the range of journal articles (not inclusive) 5119 * @return the range of matching journal articles 5120 * @throws SystemException if a system exception occurred 5121 */ 5122 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5123 long groupId, long folderId, int status, int start, int end) 5124 throws com.liferay.portal.kernel.exception.SystemException { 5125 return getPersistence() 5126 .findByG_F_ST(groupId, folderId, status, start, end); 5127 } 5128 5129 /** 5130 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = ?. 5131 * 5132 * <p> 5133 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5134 * </p> 5135 * 5136 * @param groupId the group ID 5137 * @param folderId the folder ID 5138 * @param status the status 5139 * @param start the lower bound of the range of journal articles 5140 * @param end the upper bound of the range of journal articles (not inclusive) 5141 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5142 * @return the ordered range of matching journal articles 5143 * @throws SystemException if a system exception occurred 5144 */ 5145 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5146 long groupId, long folderId, int status, int start, int end, 5147 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5148 throws com.liferay.portal.kernel.exception.SystemException { 5149 return getPersistence() 5150 .findByG_F_ST(groupId, folderId, status, start, end, 5151 orderByComparator); 5152 } 5153 5154 /** 5155 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5156 * 5157 * @param groupId the group ID 5158 * @param folderId the folder ID 5159 * @param status the status 5160 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5161 * @return the first matching journal article 5162 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5163 * @throws SystemException if a system exception occurred 5164 */ 5165 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First( 5166 long groupId, long folderId, int status, 5167 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5168 throws com.liferay.portal.kernel.exception.SystemException, 5169 com.liferay.portlet.journal.NoSuchArticleException { 5170 return getPersistence() 5171 .findByG_F_ST_First(groupId, folderId, status, 5172 orderByComparator); 5173 } 5174 5175 /** 5176 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5177 * 5178 * @param groupId the group ID 5179 * @param folderId the folder ID 5180 * @param status the status 5181 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5182 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5183 * @throws SystemException if a system exception occurred 5184 */ 5185 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First( 5186 long groupId, long folderId, int status, 5187 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5188 throws com.liferay.portal.kernel.exception.SystemException { 5189 return getPersistence() 5190 .fetchByG_F_ST_First(groupId, folderId, status, 5191 orderByComparator); 5192 } 5193 5194 /** 5195 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5196 * 5197 * @param groupId the group ID 5198 * @param folderId the folder ID 5199 * @param status the status 5200 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5201 * @return the last matching journal article 5202 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5203 * @throws SystemException if a system exception occurred 5204 */ 5205 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last( 5206 long groupId, long folderId, int status, 5207 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5208 throws com.liferay.portal.kernel.exception.SystemException, 5209 com.liferay.portlet.journal.NoSuchArticleException { 5210 return getPersistence() 5211 .findByG_F_ST_Last(groupId, folderId, status, 5212 orderByComparator); 5213 } 5214 5215 /** 5216 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5217 * 5218 * @param groupId the group ID 5219 * @param folderId the folder ID 5220 * @param status the status 5221 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5222 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5223 * @throws SystemException if a system exception occurred 5224 */ 5225 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last( 5226 long groupId, long folderId, int status, 5227 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5228 throws com.liferay.portal.kernel.exception.SystemException { 5229 return getPersistence() 5230 .fetchByG_F_ST_Last(groupId, folderId, status, 5231 orderByComparator); 5232 } 5233 5234 /** 5235 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5236 * 5237 * @param id the primary key of the current journal article 5238 * @param groupId the group ID 5239 * @param folderId the folder ID 5240 * @param status the status 5241 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5242 * @return the previous, current, and next journal article 5243 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5244 * @throws SystemException if a system exception occurred 5245 */ 5246 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext( 5247 long id, long groupId, long folderId, int status, 5248 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5249 throws com.liferay.portal.kernel.exception.SystemException, 5250 com.liferay.portlet.journal.NoSuchArticleException { 5251 return getPersistence() 5252 .findByG_F_ST_PrevAndNext(id, groupId, folderId, status, 5253 orderByComparator); 5254 } 5255 5256 /** 5257 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5258 * 5259 * @param groupId the group ID 5260 * @param folderId the folder ID 5261 * @param status the status 5262 * @return the matching journal articles that the user has permission to view 5263 * @throws SystemException if a system exception occurred 5264 */ 5265 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5266 long groupId, long folderId, int status) 5267 throws com.liferay.portal.kernel.exception.SystemException { 5268 return getPersistence().filterFindByG_F_ST(groupId, folderId, status); 5269 } 5270 5271 /** 5272 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5273 * 5274 * <p> 5275 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5276 * </p> 5277 * 5278 * @param groupId the group ID 5279 * @param folderId the folder ID 5280 * @param status the status 5281 * @param start the lower bound of the range of journal articles 5282 * @param end the upper bound of the range of journal articles (not inclusive) 5283 * @return the range of matching journal articles that the user has permission to view 5284 * @throws SystemException if a system exception occurred 5285 */ 5286 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5287 long groupId, long folderId, int status, int start, int end) 5288 throws com.liferay.portal.kernel.exception.SystemException { 5289 return getPersistence() 5290 .filterFindByG_F_ST(groupId, folderId, status, start, end); 5291 } 5292 5293 /** 5294 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 5295 * 5296 * <p> 5297 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5298 * </p> 5299 * 5300 * @param groupId the group ID 5301 * @param folderId the folder ID 5302 * @param status the status 5303 * @param start the lower bound of the range of journal articles 5304 * @param end the upper bound of the range of journal articles (not inclusive) 5305 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5306 * @return the ordered range of matching journal articles that the user has permission to view 5307 * @throws SystemException if a system exception occurred 5308 */ 5309 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5310 long groupId, long folderId, int status, int start, int end, 5311 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5312 throws com.liferay.portal.kernel.exception.SystemException { 5313 return getPersistence() 5314 .filterFindByG_F_ST(groupId, folderId, status, start, end, 5315 orderByComparator); 5316 } 5317 5318 /** 5319 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5320 * 5321 * @param id the primary key of the current journal article 5322 * @param groupId the group ID 5323 * @param folderId the folder ID 5324 * @param status the status 5325 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5326 * @return the previous, current, and next journal article 5327 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5328 * @throws SystemException if a system exception occurred 5329 */ 5330 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext( 5331 long id, long groupId, long folderId, int status, 5332 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5333 throws com.liferay.portal.kernel.exception.SystemException, 5334 com.liferay.portlet.journal.NoSuchArticleException { 5335 return getPersistence() 5336 .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId, 5337 status, orderByComparator); 5338 } 5339 5340 /** 5341 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5342 * 5343 * @param groupId the group ID 5344 * @param folderId the folder ID 5345 * @param statuses the statuses 5346 * @return the matching journal articles that the user has permission to view 5347 * @throws SystemException if a system exception occurred 5348 */ 5349 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5350 long groupId, long folderId, int[] statuses) 5351 throws com.liferay.portal.kernel.exception.SystemException { 5352 return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses); 5353 } 5354 5355 /** 5356 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5357 * 5358 * <p> 5359 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5360 * </p> 5361 * 5362 * @param groupId the group ID 5363 * @param folderId the folder ID 5364 * @param statuses the statuses 5365 * @param start the lower bound of the range of journal articles 5366 * @param end the upper bound of the range of journal articles (not inclusive) 5367 * @return the range of matching journal articles that the user has permission to view 5368 * @throws SystemException if a system exception occurred 5369 */ 5370 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5371 long groupId, long folderId, int[] statuses, int start, int end) 5372 throws com.liferay.portal.kernel.exception.SystemException { 5373 return getPersistence() 5374 .filterFindByG_F_ST(groupId, folderId, statuses, start, end); 5375 } 5376 5377 /** 5378 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5379 * 5380 * <p> 5381 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5382 * </p> 5383 * 5384 * @param groupId the group ID 5385 * @param folderId the folder ID 5386 * @param statuses the statuses 5387 * @param start the lower bound of the range of journal articles 5388 * @param end the upper bound of the range of journal articles (not inclusive) 5389 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5390 * @return the ordered range of matching journal articles that the user has permission to view 5391 * @throws SystemException if a system exception occurred 5392 */ 5393 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5394 long groupId, long folderId, int[] statuses, int start, int end, 5395 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5396 throws com.liferay.portal.kernel.exception.SystemException { 5397 return getPersistence() 5398 .filterFindByG_F_ST(groupId, folderId, statuses, start, end, 5399 orderByComparator); 5400 } 5401 5402 /** 5403 * Returns all the journal articles where groupId = ? and folderId = ? and status = any ?. 5404 * 5405 * <p> 5406 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5407 * </p> 5408 * 5409 * @param groupId the group ID 5410 * @param folderId the folder ID 5411 * @param statuses the statuses 5412 * @return the matching journal articles 5413 * @throws SystemException if a system exception occurred 5414 */ 5415 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5416 long groupId, long folderId, int[] statuses) 5417 throws com.liferay.portal.kernel.exception.SystemException { 5418 return getPersistence().findByG_F_ST(groupId, folderId, statuses); 5419 } 5420 5421 /** 5422 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 5423 * 5424 * <p> 5425 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5426 * </p> 5427 * 5428 * @param groupId the group ID 5429 * @param folderId the folder ID 5430 * @param statuses the statuses 5431 * @param start the lower bound of the range of journal articles 5432 * @param end the upper bound of the range of journal articles (not inclusive) 5433 * @return the range of matching journal articles 5434 * @throws SystemException if a system exception occurred 5435 */ 5436 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5437 long groupId, long folderId, int[] statuses, int start, int end) 5438 throws com.liferay.portal.kernel.exception.SystemException { 5439 return getPersistence() 5440 .findByG_F_ST(groupId, folderId, statuses, start, end); 5441 } 5442 5443 /** 5444 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 5445 * 5446 * <p> 5447 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5448 * </p> 5449 * 5450 * @param groupId the group ID 5451 * @param folderId the folder ID 5452 * @param statuses the statuses 5453 * @param start the lower bound of the range of journal articles 5454 * @param end the upper bound of the range of journal articles (not inclusive) 5455 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5456 * @return the ordered range of matching journal articles 5457 * @throws SystemException if a system exception occurred 5458 */ 5459 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5460 long groupId, long folderId, int[] statuses, int start, int end, 5461 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5462 throws com.liferay.portal.kernel.exception.SystemException { 5463 return getPersistence() 5464 .findByG_F_ST(groupId, folderId, statuses, start, end, 5465 orderByComparator); 5466 } 5467 5468 /** 5469 * Removes all the journal articles where groupId = ? and folderId = ? and status = ? from the database. 5470 * 5471 * @param groupId the group ID 5472 * @param folderId the folder ID 5473 * @param status the status 5474 * @throws SystemException if a system exception occurred 5475 */ 5476 public static void removeByG_F_ST(long groupId, long folderId, int status) 5477 throws com.liferay.portal.kernel.exception.SystemException { 5478 getPersistence().removeByG_F_ST(groupId, folderId, status); 5479 } 5480 5481 /** 5482 * Returns the number of journal articles where groupId = ? and folderId = ? and status = ?. 5483 * 5484 * @param groupId the group ID 5485 * @param folderId the folder ID 5486 * @param status the status 5487 * @return the number of matching journal articles 5488 * @throws SystemException if a system exception occurred 5489 */ 5490 public static int countByG_F_ST(long groupId, long folderId, int status) 5491 throws com.liferay.portal.kernel.exception.SystemException { 5492 return getPersistence().countByG_F_ST(groupId, folderId, status); 5493 } 5494 5495 /** 5496 * Returns the number of journal articles where groupId = ? and folderId = ? and status = any ?. 5497 * 5498 * @param groupId the group ID 5499 * @param folderId the folder ID 5500 * @param statuses the statuses 5501 * @return the number of matching journal articles 5502 * @throws SystemException if a system exception occurred 5503 */ 5504 public static int countByG_F_ST(long groupId, long folderId, int[] statuses) 5505 throws com.liferay.portal.kernel.exception.SystemException { 5506 return getPersistence().countByG_F_ST(groupId, folderId, statuses); 5507 } 5508 5509 /** 5510 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5511 * 5512 * @param groupId the group ID 5513 * @param folderId the folder ID 5514 * @param status the status 5515 * @return the number of matching journal articles that the user has permission to view 5516 * @throws SystemException if a system exception occurred 5517 */ 5518 public static int filterCountByG_F_ST(long groupId, long folderId, 5519 int status) throws com.liferay.portal.kernel.exception.SystemException { 5520 return getPersistence().filterCountByG_F_ST(groupId, folderId, status); 5521 } 5522 5523 /** 5524 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5525 * 5526 * @param groupId the group ID 5527 * @param folderId the folder ID 5528 * @param statuses the statuses 5529 * @return the number of matching journal articles that the user has permission to view 5530 * @throws SystemException if a system exception occurred 5531 */ 5532 public static int filterCountByG_F_ST(long groupId, long folderId, 5533 int[] statuses) 5534 throws com.liferay.portal.kernel.exception.SystemException { 5535 return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses); 5536 } 5537 5538 /** 5539 * Returns all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5540 * 5541 * @param groupId the group ID 5542 * @param classNameId the class name ID 5543 * @param classPK the class p k 5544 * @return the matching journal articles 5545 * @throws SystemException if a system exception occurred 5546 */ 5547 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5548 long groupId, long classNameId, long classPK) 5549 throws com.liferay.portal.kernel.exception.SystemException { 5550 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 5551 } 5552 5553 /** 5554 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5555 * 5556 * <p> 5557 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5558 * </p> 5559 * 5560 * @param groupId the group ID 5561 * @param classNameId the class name ID 5562 * @param classPK the class p k 5563 * @param start the lower bound of the range of journal articles 5564 * @param end the upper bound of the range of journal articles (not inclusive) 5565 * @return the range of matching journal articles 5566 * @throws SystemException if a system exception occurred 5567 */ 5568 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5569 long groupId, long classNameId, long classPK, int start, int end) 5570 throws com.liferay.portal.kernel.exception.SystemException { 5571 return getPersistence() 5572 .findByG_C_C(groupId, classNameId, classPK, start, end); 5573 } 5574 5575 /** 5576 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5577 * 5578 * <p> 5579 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5580 * </p> 5581 * 5582 * @param groupId the group ID 5583 * @param classNameId the class name ID 5584 * @param classPK the class p k 5585 * @param start the lower bound of the range of journal articles 5586 * @param end the upper bound of the range of journal articles (not inclusive) 5587 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5588 * @return the ordered range of matching journal articles 5589 * @throws SystemException if a system exception occurred 5590 */ 5591 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5592 long groupId, long classNameId, long classPK, int start, int end, 5593 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5594 throws com.liferay.portal.kernel.exception.SystemException { 5595 return getPersistence() 5596 .findByG_C_C(groupId, classNameId, classPK, start, end, 5597 orderByComparator); 5598 } 5599 5600 /** 5601 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5602 * 5603 * @param groupId the group ID 5604 * @param classNameId the class name ID 5605 * @param classPK the class p k 5606 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5607 * @return the first matching journal article 5608 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5609 * @throws SystemException if a system exception occurred 5610 */ 5611 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First( 5612 long groupId, long classNameId, long classPK, 5613 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5614 throws com.liferay.portal.kernel.exception.SystemException, 5615 com.liferay.portlet.journal.NoSuchArticleException { 5616 return getPersistence() 5617 .findByG_C_C_First(groupId, classNameId, classPK, 5618 orderByComparator); 5619 } 5620 5621 /** 5622 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5623 * 5624 * @param groupId the group ID 5625 * @param classNameId the class name ID 5626 * @param classPK the class p k 5627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5628 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5629 * @throws SystemException if a system exception occurred 5630 */ 5631 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First( 5632 long groupId, long classNameId, long classPK, 5633 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5634 throws com.liferay.portal.kernel.exception.SystemException { 5635 return getPersistence() 5636 .fetchByG_C_C_First(groupId, classNameId, classPK, 5637 orderByComparator); 5638 } 5639 5640 /** 5641 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5642 * 5643 * @param groupId the group ID 5644 * @param classNameId the class name ID 5645 * @param classPK the class p k 5646 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5647 * @return the last matching journal article 5648 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5649 * @throws SystemException if a system exception occurred 5650 */ 5651 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last( 5652 long groupId, long classNameId, long classPK, 5653 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5654 throws com.liferay.portal.kernel.exception.SystemException, 5655 com.liferay.portlet.journal.NoSuchArticleException { 5656 return getPersistence() 5657 .findByG_C_C_Last(groupId, classNameId, classPK, 5658 orderByComparator); 5659 } 5660 5661 /** 5662 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5663 * 5664 * @param groupId the group ID 5665 * @param classNameId the class name ID 5666 * @param classPK the class p k 5667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5668 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5669 * @throws SystemException if a system exception occurred 5670 */ 5671 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last( 5672 long groupId, long classNameId, long classPK, 5673 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5674 throws com.liferay.portal.kernel.exception.SystemException { 5675 return getPersistence() 5676 .fetchByG_C_C_Last(groupId, classNameId, classPK, 5677 orderByComparator); 5678 } 5679 5680 /** 5681 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5682 * 5683 * @param id the primary key of the current journal article 5684 * @param groupId the group ID 5685 * @param classNameId the class name ID 5686 * @param classPK the class p k 5687 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5688 * @return the previous, current, and next journal article 5689 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5690 * @throws SystemException if a system exception occurred 5691 */ 5692 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext( 5693 long id, long groupId, long classNameId, long classPK, 5694 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5695 throws com.liferay.portal.kernel.exception.SystemException, 5696 com.liferay.portlet.journal.NoSuchArticleException { 5697 return getPersistence() 5698 .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK, 5699 orderByComparator); 5700 } 5701 5702 /** 5703 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5704 * 5705 * @param groupId the group ID 5706 * @param classNameId the class name ID 5707 * @param classPK the class p k 5708 * @return the matching journal articles that the user has permission to view 5709 * @throws SystemException if a system exception occurred 5710 */ 5711 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5712 long groupId, long classNameId, long classPK) 5713 throws com.liferay.portal.kernel.exception.SystemException { 5714 return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK); 5715 } 5716 5717 /** 5718 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5719 * 5720 * <p> 5721 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5722 * </p> 5723 * 5724 * @param groupId the group ID 5725 * @param classNameId the class name ID 5726 * @param classPK the class p k 5727 * @param start the lower bound of the range of journal articles 5728 * @param end the upper bound of the range of journal articles (not inclusive) 5729 * @return the range of matching journal articles that the user has permission to view 5730 * @throws SystemException if a system exception occurred 5731 */ 5732 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5733 long groupId, long classNameId, long classPK, int start, int end) 5734 throws com.liferay.portal.kernel.exception.SystemException { 5735 return getPersistence() 5736 .filterFindByG_C_C(groupId, classNameId, classPK, start, end); 5737 } 5738 5739 /** 5740 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and classPK = ?. 5741 * 5742 * <p> 5743 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5744 * </p> 5745 * 5746 * @param groupId the group ID 5747 * @param classNameId the class name ID 5748 * @param classPK the class p k 5749 * @param start the lower bound of the range of journal articles 5750 * @param end the upper bound of the range of journal articles (not inclusive) 5751 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5752 * @return the ordered range of matching journal articles that the user has permission to view 5753 * @throws SystemException if a system exception occurred 5754 */ 5755 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5756 long groupId, long classNameId, long classPK, int start, int end, 5757 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5758 throws com.liferay.portal.kernel.exception.SystemException { 5759 return getPersistence() 5760 .filterFindByG_C_C(groupId, classNameId, classPK, start, 5761 end, orderByComparator); 5762 } 5763 5764 /** 5765 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5766 * 5767 * @param id the primary key of the current journal article 5768 * @param groupId the group ID 5769 * @param classNameId the class name ID 5770 * @param classPK the class p k 5771 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5772 * @return the previous, current, and next journal article 5773 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5774 * @throws SystemException if a system exception occurred 5775 */ 5776 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext( 5777 long id, long groupId, long classNameId, long classPK, 5778 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5779 throws com.liferay.portal.kernel.exception.SystemException, 5780 com.liferay.portlet.journal.NoSuchArticleException { 5781 return getPersistence() 5782 .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId, 5783 classPK, orderByComparator); 5784 } 5785 5786 /** 5787 * Removes all the journal articles where groupId = ? and classNameId = ? and classPK = ? from the database. 5788 * 5789 * @param groupId the group ID 5790 * @param classNameId the class name ID 5791 * @param classPK the class p k 5792 * @throws SystemException if a system exception occurred 5793 */ 5794 public static void removeByG_C_C(long groupId, long classNameId, 5795 long classPK) 5796 throws com.liferay.portal.kernel.exception.SystemException { 5797 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 5798 } 5799 5800 /** 5801 * Returns the number of journal articles where groupId = ? and classNameId = ? and classPK = ?. 5802 * 5803 * @param groupId the group ID 5804 * @param classNameId the class name ID 5805 * @param classPK the class p k 5806 * @return the number of matching journal articles 5807 * @throws SystemException if a system exception occurred 5808 */ 5809 public static int countByG_C_C(long groupId, long classNameId, long classPK) 5810 throws com.liferay.portal.kernel.exception.SystemException { 5811 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 5812 } 5813 5814 /** 5815 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5816 * 5817 * @param groupId the group ID 5818 * @param classNameId the class name ID 5819 * @param classPK the class p k 5820 * @return the number of matching journal articles that the user has permission to view 5821 * @throws SystemException if a system exception occurred 5822 */ 5823 public static int filterCountByG_C_C(long groupId, long classNameId, 5824 long classPK) 5825 throws com.liferay.portal.kernel.exception.SystemException { 5826 return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK); 5827 } 5828 5829 /** 5830 * Returns the journal article where groupId = ? and classNameId = ? and structureId = ? or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 5831 * 5832 * @param groupId the group ID 5833 * @param classNameId the class name ID 5834 * @param structureId the structure ID 5835 * @return the matching journal article 5836 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5837 * @throws SystemException if a system exception occurred 5838 */ 5839 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S( 5840 long groupId, long classNameId, java.lang.String structureId) 5841 throws com.liferay.portal.kernel.exception.SystemException, 5842 com.liferay.portlet.journal.NoSuchArticleException { 5843 return getPersistence().findByG_C_S(groupId, classNameId, structureId); 5844 } 5845 5846 /** 5847 * Returns the journal article where groupId = ? and classNameId = ? and structureId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 5848 * 5849 * @param groupId the group ID 5850 * @param classNameId the class name ID 5851 * @param structureId the structure ID 5852 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 5853 * @throws SystemException if a system exception occurred 5854 */ 5855 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 5856 long groupId, long classNameId, java.lang.String structureId) 5857 throws com.liferay.portal.kernel.exception.SystemException { 5858 return getPersistence().fetchByG_C_S(groupId, classNameId, structureId); 5859 } 5860 5861 /** 5862 * Returns the journal article where groupId = ? and classNameId = ? and structureId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 5863 * 5864 * @param groupId the group ID 5865 * @param classNameId the class name ID 5866 * @param structureId the structure ID 5867 * @param retrieveFromCache whether to use the finder cache 5868 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 5869 * @throws SystemException if a system exception occurred 5870 */ 5871 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 5872 long groupId, long classNameId, java.lang.String structureId, 5873 boolean retrieveFromCache) 5874 throws com.liferay.portal.kernel.exception.SystemException { 5875 return getPersistence() 5876 .fetchByG_C_S(groupId, classNameId, structureId, 5877 retrieveFromCache); 5878 } 5879 5880 /** 5881 * Removes the journal article where groupId = ? and classNameId = ? and structureId = ? from the database. 5882 * 5883 * @param groupId the group ID 5884 * @param classNameId the class name ID 5885 * @param structureId the structure ID 5886 * @return the journal article that was removed 5887 * @throws SystemException if a system exception occurred 5888 */ 5889 public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S( 5890 long groupId, long classNameId, java.lang.String structureId) 5891 throws com.liferay.portal.kernel.exception.SystemException, 5892 com.liferay.portlet.journal.NoSuchArticleException { 5893 return getPersistence().removeByG_C_S(groupId, classNameId, structureId); 5894 } 5895 5896 /** 5897 * Returns the number of journal articles where groupId = ? and classNameId = ? and structureId = ?. 5898 * 5899 * @param groupId the group ID 5900 * @param classNameId the class name ID 5901 * @param structureId the structure ID 5902 * @return the number of matching journal articles 5903 * @throws SystemException if a system exception occurred 5904 */ 5905 public static int countByG_C_S(long groupId, long classNameId, 5906 java.lang.String structureId) 5907 throws com.liferay.portal.kernel.exception.SystemException { 5908 return getPersistence().countByG_C_S(groupId, classNameId, structureId); 5909 } 5910 5911 /** 5912 * Returns all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5913 * 5914 * @param groupId the group ID 5915 * @param classNameId the class name ID 5916 * @param templateId the template ID 5917 * @return the matching journal articles 5918 * @throws SystemException if a system exception occurred 5919 */ 5920 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5921 long groupId, long classNameId, java.lang.String templateId) 5922 throws com.liferay.portal.kernel.exception.SystemException { 5923 return getPersistence().findByG_C_T(groupId, classNameId, templateId); 5924 } 5925 5926 /** 5927 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5928 * 5929 * <p> 5930 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5931 * </p> 5932 * 5933 * @param groupId the group ID 5934 * @param classNameId the class name ID 5935 * @param templateId the template ID 5936 * @param start the lower bound of the range of journal articles 5937 * @param end the upper bound of the range of journal articles (not inclusive) 5938 * @return the range of matching journal articles 5939 * @throws SystemException if a system exception occurred 5940 */ 5941 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5942 long groupId, long classNameId, java.lang.String templateId, int start, 5943 int end) throws com.liferay.portal.kernel.exception.SystemException { 5944 return getPersistence() 5945 .findByG_C_T(groupId, classNameId, templateId, start, end); 5946 } 5947 5948 /** 5949 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5950 * 5951 * <p> 5952 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5953 * </p> 5954 * 5955 * @param groupId the group ID 5956 * @param classNameId the class name ID 5957 * @param templateId the template ID 5958 * @param start the lower bound of the range of journal articles 5959 * @param end the upper bound of the range of journal articles (not inclusive) 5960 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5961 * @return the ordered range of matching journal articles 5962 * @throws SystemException if a system exception occurred 5963 */ 5964 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5965 long groupId, long classNameId, java.lang.String templateId, int start, 5966 int end, 5967 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5968 throws com.liferay.portal.kernel.exception.SystemException { 5969 return getPersistence() 5970 .findByG_C_T(groupId, classNameId, templateId, start, end, 5971 orderByComparator); 5972 } 5973 5974 /** 5975 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5976 * 5977 * @param groupId the group ID 5978 * @param classNameId the class name ID 5979 * @param templateId the template ID 5980 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5981 * @return the first matching journal article 5982 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5983 * @throws SystemException if a system exception occurred 5984 */ 5985 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First( 5986 long groupId, long classNameId, java.lang.String templateId, 5987 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5988 throws com.liferay.portal.kernel.exception.SystemException, 5989 com.liferay.portlet.journal.NoSuchArticleException { 5990 return getPersistence() 5991 .findByG_C_T_First(groupId, classNameId, templateId, 5992 orderByComparator); 5993 } 5994 5995 /** 5996 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5997 * 5998 * @param groupId the group ID 5999 * @param classNameId the class name ID 6000 * @param templateId the template ID 6001 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6002 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6003 * @throws SystemException if a system exception occurred 6004 */ 6005 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First( 6006 long groupId, long classNameId, java.lang.String templateId, 6007 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6008 throws com.liferay.portal.kernel.exception.SystemException { 6009 return getPersistence() 6010 .fetchByG_C_T_First(groupId, classNameId, templateId, 6011 orderByComparator); 6012 } 6013 6014 /** 6015 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6016 * 6017 * @param groupId the group ID 6018 * @param classNameId the class name ID 6019 * @param templateId the template ID 6020 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6021 * @return the last matching journal article 6022 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6023 * @throws SystemException if a system exception occurred 6024 */ 6025 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last( 6026 long groupId, long classNameId, java.lang.String templateId, 6027 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6028 throws com.liferay.portal.kernel.exception.SystemException, 6029 com.liferay.portlet.journal.NoSuchArticleException { 6030 return getPersistence() 6031 .findByG_C_T_Last(groupId, classNameId, templateId, 6032 orderByComparator); 6033 } 6034 6035 /** 6036 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6037 * 6038 * @param groupId the group ID 6039 * @param classNameId the class name ID 6040 * @param templateId the template ID 6041 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6042 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6043 * @throws SystemException if a system exception occurred 6044 */ 6045 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last( 6046 long groupId, long classNameId, java.lang.String templateId, 6047 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6048 throws com.liferay.portal.kernel.exception.SystemException { 6049 return getPersistence() 6050 .fetchByG_C_T_Last(groupId, classNameId, templateId, 6051 orderByComparator); 6052 } 6053 6054 /** 6055 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6056 * 6057 * @param id the primary key of the current journal article 6058 * @param groupId the group ID 6059 * @param classNameId the class name ID 6060 * @param templateId the template ID 6061 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6062 * @return the previous, current, and next journal article 6063 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6064 * @throws SystemException if a system exception occurred 6065 */ 6066 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext( 6067 long id, long groupId, long classNameId, java.lang.String templateId, 6068 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6069 throws com.liferay.portal.kernel.exception.SystemException, 6070 com.liferay.portlet.journal.NoSuchArticleException { 6071 return getPersistence() 6072 .findByG_C_T_PrevAndNext(id, groupId, classNameId, 6073 templateId, orderByComparator); 6074 } 6075 6076 /** 6077 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6078 * 6079 * @param groupId the group ID 6080 * @param classNameId the class name ID 6081 * @param templateId the template ID 6082 * @return the matching journal articles that the user has permission to view 6083 * @throws SystemException if a system exception occurred 6084 */ 6085 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6086 long groupId, long classNameId, java.lang.String templateId) 6087 throws com.liferay.portal.kernel.exception.SystemException { 6088 return getPersistence() 6089 .filterFindByG_C_T(groupId, classNameId, templateId); 6090 } 6091 6092 /** 6093 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6094 * 6095 * <p> 6096 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6097 * </p> 6098 * 6099 * @param groupId the group ID 6100 * @param classNameId the class name ID 6101 * @param templateId the template ID 6102 * @param start the lower bound of the range of journal articles 6103 * @param end the upper bound of the range of journal articles (not inclusive) 6104 * @return the range of matching journal articles that the user has permission to view 6105 * @throws SystemException if a system exception occurred 6106 */ 6107 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6108 long groupId, long classNameId, java.lang.String templateId, int start, 6109 int end) throws com.liferay.portal.kernel.exception.SystemException { 6110 return getPersistence() 6111 .filterFindByG_C_T(groupId, classNameId, templateId, start, 6112 end); 6113 } 6114 6115 /** 6116 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and templateId = ?. 6117 * 6118 * <p> 6119 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6120 * </p> 6121 * 6122 * @param groupId the group ID 6123 * @param classNameId the class name ID 6124 * @param templateId the template ID 6125 * @param start the lower bound of the range of journal articles 6126 * @param end the upper bound of the range of journal articles (not inclusive) 6127 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6128 * @return the ordered range of matching journal articles that the user has permission to view 6129 * @throws SystemException if a system exception occurred 6130 */ 6131 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6132 long groupId, long classNameId, java.lang.String templateId, int start, 6133 int end, 6134 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6135 throws com.liferay.portal.kernel.exception.SystemException { 6136 return getPersistence() 6137 .filterFindByG_C_T(groupId, classNameId, templateId, start, 6138 end, orderByComparator); 6139 } 6140 6141 /** 6142 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6143 * 6144 * @param id the primary key of the current journal article 6145 * @param groupId the group ID 6146 * @param classNameId the class name ID 6147 * @param templateId the template ID 6148 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6149 * @return the previous, current, and next journal article 6150 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6151 * @throws SystemException if a system exception occurred 6152 */ 6153 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext( 6154 long id, long groupId, long classNameId, java.lang.String templateId, 6155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6156 throws com.liferay.portal.kernel.exception.SystemException, 6157 com.liferay.portlet.journal.NoSuchArticleException { 6158 return getPersistence() 6159 .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId, 6160 templateId, orderByComparator); 6161 } 6162 6163 /** 6164 * Removes all the journal articles where groupId = ? and classNameId = ? and templateId = ? from the database. 6165 * 6166 * @param groupId the group ID 6167 * @param classNameId the class name ID 6168 * @param templateId the template ID 6169 * @throws SystemException if a system exception occurred 6170 */ 6171 public static void removeByG_C_T(long groupId, long classNameId, 6172 java.lang.String templateId) 6173 throws com.liferay.portal.kernel.exception.SystemException { 6174 getPersistence().removeByG_C_T(groupId, classNameId, templateId); 6175 } 6176 6177 /** 6178 * Returns the number of journal articles where groupId = ? and classNameId = ? and templateId = ?. 6179 * 6180 * @param groupId the group ID 6181 * @param classNameId the class name ID 6182 * @param templateId the template ID 6183 * @return the number of matching journal articles 6184 * @throws SystemException if a system exception occurred 6185 */ 6186 public static int countByG_C_T(long groupId, long classNameId, 6187 java.lang.String templateId) 6188 throws com.liferay.portal.kernel.exception.SystemException { 6189 return getPersistence().countByG_C_T(groupId, classNameId, templateId); 6190 } 6191 6192 /** 6193 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6194 * 6195 * @param groupId the group ID 6196 * @param classNameId the class name ID 6197 * @param templateId the template ID 6198 * @return the number of matching journal articles that the user has permission to view 6199 * @throws SystemException if a system exception occurred 6200 */ 6201 public static int filterCountByG_C_T(long groupId, long classNameId, 6202 java.lang.String templateId) 6203 throws com.liferay.portal.kernel.exception.SystemException { 6204 return getPersistence() 6205 .filterCountByG_C_T(groupId, classNameId, templateId); 6206 } 6207 6208 /** 6209 * Returns all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6210 * 6211 * @param groupId the group ID 6212 * @param classNameId the class name ID 6213 * @param layoutUuid the layout uuid 6214 * @return the matching journal articles 6215 * @throws SystemException if a system exception occurred 6216 */ 6217 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6218 long groupId, long classNameId, java.lang.String layoutUuid) 6219 throws com.liferay.portal.kernel.exception.SystemException { 6220 return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid); 6221 } 6222 6223 /** 6224 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6225 * 6226 * <p> 6227 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6228 * </p> 6229 * 6230 * @param groupId the group ID 6231 * @param classNameId the class name ID 6232 * @param layoutUuid the layout uuid 6233 * @param start the lower bound of the range of journal articles 6234 * @param end the upper bound of the range of journal articles (not inclusive) 6235 * @return the range of matching journal articles 6236 * @throws SystemException if a system exception occurred 6237 */ 6238 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6239 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6240 int end) throws com.liferay.portal.kernel.exception.SystemException { 6241 return getPersistence() 6242 .findByG_C_L(groupId, classNameId, layoutUuid, start, end); 6243 } 6244 6245 /** 6246 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6247 * 6248 * <p> 6249 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6250 * </p> 6251 * 6252 * @param groupId the group ID 6253 * @param classNameId the class name ID 6254 * @param layoutUuid the layout uuid 6255 * @param start the lower bound of the range of journal articles 6256 * @param end the upper bound of the range of journal articles (not inclusive) 6257 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6258 * @return the ordered range of matching journal articles 6259 * @throws SystemException if a system exception occurred 6260 */ 6261 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6262 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6263 int end, 6264 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6265 throws com.liferay.portal.kernel.exception.SystemException { 6266 return getPersistence() 6267 .findByG_C_L(groupId, classNameId, layoutUuid, start, end, 6268 orderByComparator); 6269 } 6270 6271 /** 6272 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6273 * 6274 * @param groupId the group ID 6275 * @param classNameId the class name ID 6276 * @param layoutUuid the layout uuid 6277 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6278 * @return the first matching journal article 6279 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6280 * @throws SystemException if a system exception occurred 6281 */ 6282 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First( 6283 long groupId, long classNameId, java.lang.String layoutUuid, 6284 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6285 throws com.liferay.portal.kernel.exception.SystemException, 6286 com.liferay.portlet.journal.NoSuchArticleException { 6287 return getPersistence() 6288 .findByG_C_L_First(groupId, classNameId, layoutUuid, 6289 orderByComparator); 6290 } 6291 6292 /** 6293 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6294 * 6295 * @param groupId the group ID 6296 * @param classNameId the class name ID 6297 * @param layoutUuid the layout uuid 6298 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6299 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6300 * @throws SystemException if a system exception occurred 6301 */ 6302 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First( 6303 long groupId, long classNameId, java.lang.String layoutUuid, 6304 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6305 throws com.liferay.portal.kernel.exception.SystemException { 6306 return getPersistence() 6307 .fetchByG_C_L_First(groupId, classNameId, layoutUuid, 6308 orderByComparator); 6309 } 6310 6311 /** 6312 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6313 * 6314 * @param groupId the group ID 6315 * @param classNameId the class name ID 6316 * @param layoutUuid the layout uuid 6317 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6318 * @return the last matching journal article 6319 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6320 * @throws SystemException if a system exception occurred 6321 */ 6322 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last( 6323 long groupId, long classNameId, java.lang.String layoutUuid, 6324 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6325 throws com.liferay.portal.kernel.exception.SystemException, 6326 com.liferay.portlet.journal.NoSuchArticleException { 6327 return getPersistence() 6328 .findByG_C_L_Last(groupId, classNameId, layoutUuid, 6329 orderByComparator); 6330 } 6331 6332 /** 6333 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6334 * 6335 * @param groupId the group ID 6336 * @param classNameId the class name ID 6337 * @param layoutUuid the layout uuid 6338 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6339 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6340 * @throws SystemException if a system exception occurred 6341 */ 6342 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last( 6343 long groupId, long classNameId, java.lang.String layoutUuid, 6344 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6345 throws com.liferay.portal.kernel.exception.SystemException { 6346 return getPersistence() 6347 .fetchByG_C_L_Last(groupId, classNameId, layoutUuid, 6348 orderByComparator); 6349 } 6350 6351 /** 6352 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6353 * 6354 * @param id the primary key of the current journal article 6355 * @param groupId the group ID 6356 * @param classNameId the class name ID 6357 * @param layoutUuid the layout uuid 6358 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6359 * @return the previous, current, and next journal article 6360 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6361 * @throws SystemException if a system exception occurred 6362 */ 6363 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext( 6364 long id, long groupId, long classNameId, java.lang.String layoutUuid, 6365 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6366 throws com.liferay.portal.kernel.exception.SystemException, 6367 com.liferay.portlet.journal.NoSuchArticleException { 6368 return getPersistence() 6369 .findByG_C_L_PrevAndNext(id, groupId, classNameId, 6370 layoutUuid, orderByComparator); 6371 } 6372 6373 /** 6374 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6375 * 6376 * @param groupId the group ID 6377 * @param classNameId the class name ID 6378 * @param layoutUuid the layout uuid 6379 * @return the matching journal articles that the user has permission to view 6380 * @throws SystemException if a system exception occurred 6381 */ 6382 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6383 long groupId, long classNameId, java.lang.String layoutUuid) 6384 throws com.liferay.portal.kernel.exception.SystemException { 6385 return getPersistence() 6386 .filterFindByG_C_L(groupId, classNameId, layoutUuid); 6387 } 6388 6389 /** 6390 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6391 * 6392 * <p> 6393 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6394 * </p> 6395 * 6396 * @param groupId the group ID 6397 * @param classNameId the class name ID 6398 * @param layoutUuid the layout uuid 6399 * @param start the lower bound of the range of journal articles 6400 * @param end the upper bound of the range of journal articles (not inclusive) 6401 * @return the range of matching journal articles that the user has permission to view 6402 * @throws SystemException if a system exception occurred 6403 */ 6404 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6405 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6406 int end) throws com.liferay.portal.kernel.exception.SystemException { 6407 return getPersistence() 6408 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 6409 end); 6410 } 6411 6412 /** 6413 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6414 * 6415 * <p> 6416 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6417 * </p> 6418 * 6419 * @param groupId the group ID 6420 * @param classNameId the class name ID 6421 * @param layoutUuid the layout uuid 6422 * @param start the lower bound of the range of journal articles 6423 * @param end the upper bound of the range of journal articles (not inclusive) 6424 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6425 * @return the ordered range of matching journal articles that the user has permission to view 6426 * @throws SystemException if a system exception occurred 6427 */ 6428 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6429 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6430 int end, 6431 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6432 throws com.liferay.portal.kernel.exception.SystemException { 6433 return getPersistence() 6434 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 6435 end, orderByComparator); 6436 } 6437 6438 /** 6439 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6440 * 6441 * @param id the primary key of the current journal article 6442 * @param groupId the group ID 6443 * @param classNameId the class name ID 6444 * @param layoutUuid the layout uuid 6445 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6446 * @return the previous, current, and next journal article 6447 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6448 * @throws SystemException if a system exception occurred 6449 */ 6450 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext( 6451 long id, long groupId, long classNameId, java.lang.String layoutUuid, 6452 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6453 throws com.liferay.portal.kernel.exception.SystemException, 6454 com.liferay.portlet.journal.NoSuchArticleException { 6455 return getPersistence() 6456 .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId, 6457 layoutUuid, orderByComparator); 6458 } 6459 6460 /** 6461 * Removes all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ? from the database. 6462 * 6463 * @param groupId the group ID 6464 * @param classNameId the class name ID 6465 * @param layoutUuid the layout uuid 6466 * @throws SystemException if a system exception occurred 6467 */ 6468 public static void removeByG_C_L(long groupId, long classNameId, 6469 java.lang.String layoutUuid) 6470 throws com.liferay.portal.kernel.exception.SystemException { 6471 getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid); 6472 } 6473 6474 /** 6475 * Returns the number of journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6476 * 6477 * @param groupId the group ID 6478 * @param classNameId the class name ID 6479 * @param layoutUuid the layout uuid 6480 * @return the number of matching journal articles 6481 * @throws SystemException if a system exception occurred 6482 */ 6483 public static int countByG_C_L(long groupId, long classNameId, 6484 java.lang.String layoutUuid) 6485 throws com.liferay.portal.kernel.exception.SystemException { 6486 return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid); 6487 } 6488 6489 /** 6490 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6491 * 6492 * @param groupId the group ID 6493 * @param classNameId the class name ID 6494 * @param layoutUuid the layout uuid 6495 * @return the number of matching journal articles that the user has permission to view 6496 * @throws SystemException if a system exception occurred 6497 */ 6498 public static int filterCountByG_C_L(long groupId, long classNameId, 6499 java.lang.String layoutUuid) 6500 throws com.liferay.portal.kernel.exception.SystemException { 6501 return getPersistence() 6502 .filterCountByG_C_L(groupId, classNameId, layoutUuid); 6503 } 6504 6505 /** 6506 * Returns all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6507 * 6508 * @param groupId the group ID 6509 * @param userId the user ID 6510 * @param classNameId the class name ID 6511 * @return the matching journal articles 6512 * @throws SystemException if a system exception occurred 6513 */ 6514 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6515 long groupId, long userId, long classNameId) 6516 throws com.liferay.portal.kernel.exception.SystemException { 6517 return getPersistence().findByG_U_C(groupId, userId, classNameId); 6518 } 6519 6520 /** 6521 * Returns a range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6522 * 6523 * <p> 6524 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6525 * </p> 6526 * 6527 * @param groupId the group ID 6528 * @param userId the user ID 6529 * @param classNameId the class name ID 6530 * @param start the lower bound of the range of journal articles 6531 * @param end the upper bound of the range of journal articles (not inclusive) 6532 * @return the range of matching journal articles 6533 * @throws SystemException if a system exception occurred 6534 */ 6535 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6536 long groupId, long userId, long classNameId, int start, int end) 6537 throws com.liferay.portal.kernel.exception.SystemException { 6538 return getPersistence() 6539 .findByG_U_C(groupId, userId, classNameId, start, end); 6540 } 6541 6542 /** 6543 * Returns an ordered range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6544 * 6545 * <p> 6546 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6547 * </p> 6548 * 6549 * @param groupId the group ID 6550 * @param userId the user ID 6551 * @param classNameId the class name ID 6552 * @param start the lower bound of the range of journal articles 6553 * @param end the upper bound of the range of journal articles (not inclusive) 6554 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6555 * @return the ordered range of matching journal articles 6556 * @throws SystemException if a system exception occurred 6557 */ 6558 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6559 long groupId, long userId, long classNameId, int start, int end, 6560 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6561 throws com.liferay.portal.kernel.exception.SystemException { 6562 return getPersistence() 6563 .findByG_U_C(groupId, userId, classNameId, start, end, 6564 orderByComparator); 6565 } 6566 6567 /** 6568 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6569 * 6570 * @param groupId the group ID 6571 * @param userId the user ID 6572 * @param classNameId the class name ID 6573 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6574 * @return the first matching journal article 6575 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6576 * @throws SystemException if a system exception occurred 6577 */ 6578 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First( 6579 long groupId, long userId, long classNameId, 6580 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6581 throws com.liferay.portal.kernel.exception.SystemException, 6582 com.liferay.portlet.journal.NoSuchArticleException { 6583 return getPersistence() 6584 .findByG_U_C_First(groupId, userId, classNameId, 6585 orderByComparator); 6586 } 6587 6588 /** 6589 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6590 * 6591 * @param groupId the group ID 6592 * @param userId the user ID 6593 * @param classNameId the class name ID 6594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6595 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6596 * @throws SystemException if a system exception occurred 6597 */ 6598 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First( 6599 long groupId, long userId, long classNameId, 6600 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6601 throws com.liferay.portal.kernel.exception.SystemException { 6602 return getPersistence() 6603 .fetchByG_U_C_First(groupId, userId, classNameId, 6604 orderByComparator); 6605 } 6606 6607 /** 6608 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6609 * 6610 * @param groupId the group ID 6611 * @param userId the user ID 6612 * @param classNameId the class name ID 6613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6614 * @return the last matching journal article 6615 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6616 * @throws SystemException if a system exception occurred 6617 */ 6618 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last( 6619 long groupId, long userId, long classNameId, 6620 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6621 throws com.liferay.portal.kernel.exception.SystemException, 6622 com.liferay.portlet.journal.NoSuchArticleException { 6623 return getPersistence() 6624 .findByG_U_C_Last(groupId, userId, classNameId, 6625 orderByComparator); 6626 } 6627 6628 /** 6629 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6630 * 6631 * @param groupId the group ID 6632 * @param userId the user ID 6633 * @param classNameId the class name ID 6634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6635 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6636 * @throws SystemException if a system exception occurred 6637 */ 6638 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last( 6639 long groupId, long userId, long classNameId, 6640 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6641 throws com.liferay.portal.kernel.exception.SystemException { 6642 return getPersistence() 6643 .fetchByG_U_C_Last(groupId, userId, classNameId, 6644 orderByComparator); 6645 } 6646 6647 /** 6648 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6649 * 6650 * @param id the primary key of the current journal article 6651 * @param groupId the group ID 6652 * @param userId the user ID 6653 * @param classNameId the class name ID 6654 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6655 * @return the previous, current, and next journal article 6656 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6657 * @throws SystemException if a system exception occurred 6658 */ 6659 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext( 6660 long id, long groupId, long userId, long classNameId, 6661 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6662 throws com.liferay.portal.kernel.exception.SystemException, 6663 com.liferay.portlet.journal.NoSuchArticleException { 6664 return getPersistence() 6665 .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId, 6666 orderByComparator); 6667 } 6668 6669 /** 6670 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6671 * 6672 * @param groupId the group ID 6673 * @param userId the user ID 6674 * @param classNameId the class name ID 6675 * @return the matching journal articles that the user has permission to view 6676 * @throws SystemException if a system exception occurred 6677 */ 6678 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6679 long groupId, long userId, long classNameId) 6680 throws com.liferay.portal.kernel.exception.SystemException { 6681 return getPersistence().filterFindByG_U_C(groupId, userId, classNameId); 6682 } 6683 6684 /** 6685 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6686 * 6687 * <p> 6688 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6689 * </p> 6690 * 6691 * @param groupId the group ID 6692 * @param userId the user ID 6693 * @param classNameId the class name ID 6694 * @param start the lower bound of the range of journal articles 6695 * @param end the upper bound of the range of journal articles (not inclusive) 6696 * @return the range of matching journal articles that the user has permission to view 6697 * @throws SystemException if a system exception occurred 6698 */ 6699 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6700 long groupId, long userId, long classNameId, int start, int end) 6701 throws com.liferay.portal.kernel.exception.SystemException { 6702 return getPersistence() 6703 .filterFindByG_U_C(groupId, userId, classNameId, start, end); 6704 } 6705 6706 /** 6707 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ? and classNameId = ?. 6708 * 6709 * <p> 6710 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6711 * </p> 6712 * 6713 * @param groupId the group ID 6714 * @param userId the user ID 6715 * @param classNameId the class name ID 6716 * @param start the lower bound of the range of journal articles 6717 * @param end the upper bound of the range of journal articles (not inclusive) 6718 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6719 * @return the ordered range of matching journal articles that the user has permission to view 6720 * @throws SystemException if a system exception occurred 6721 */ 6722 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6723 long groupId, long userId, long classNameId, int start, int end, 6724 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6725 throws com.liferay.portal.kernel.exception.SystemException { 6726 return getPersistence() 6727 .filterFindByG_U_C(groupId, userId, classNameId, start, end, 6728 orderByComparator); 6729 } 6730 6731 /** 6732 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6733 * 6734 * @param id the primary key of the current journal article 6735 * @param groupId the group ID 6736 * @param userId the user ID 6737 * @param classNameId the class name ID 6738 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6739 * @return the previous, current, and next journal article 6740 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6741 * @throws SystemException if a system exception occurred 6742 */ 6743 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext( 6744 long id, long groupId, long userId, long classNameId, 6745 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6746 throws com.liferay.portal.kernel.exception.SystemException, 6747 com.liferay.portlet.journal.NoSuchArticleException { 6748 return getPersistence() 6749 .filterFindByG_U_C_PrevAndNext(id, groupId, userId, 6750 classNameId, orderByComparator); 6751 } 6752 6753 /** 6754 * Removes all the journal articles where groupId = ? and userId = ? and classNameId = ? from the database. 6755 * 6756 * @param groupId the group ID 6757 * @param userId the user ID 6758 * @param classNameId the class name ID 6759 * @throws SystemException if a system exception occurred 6760 */ 6761 public static void removeByG_U_C(long groupId, long userId, long classNameId) 6762 throws com.liferay.portal.kernel.exception.SystemException { 6763 getPersistence().removeByG_U_C(groupId, userId, classNameId); 6764 } 6765 6766 /** 6767 * Returns the number of journal articles where groupId = ? and userId = ? and classNameId = ?. 6768 * 6769 * @param groupId the group ID 6770 * @param userId the user ID 6771 * @param classNameId the class name ID 6772 * @return the number of matching journal articles 6773 * @throws SystemException if a system exception occurred 6774 */ 6775 public static int countByG_U_C(long groupId, long userId, long classNameId) 6776 throws com.liferay.portal.kernel.exception.SystemException { 6777 return getPersistence().countByG_U_C(groupId, userId, classNameId); 6778 } 6779 6780 /** 6781 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6782 * 6783 * @param groupId the group ID 6784 * @param userId the user ID 6785 * @param classNameId the class name ID 6786 * @return the number of matching journal articles that the user has permission to view 6787 * @throws SystemException if a system exception occurred 6788 */ 6789 public static int filterCountByG_U_C(long groupId, long userId, 6790 long classNameId) 6791 throws com.liferay.portal.kernel.exception.SystemException { 6792 return getPersistence().filterCountByG_U_C(groupId, userId, classNameId); 6793 } 6794 6795 /** 6796 * Returns the journal article where groupId = ? and articleId = ? and version = ? or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 6797 * 6798 * @param groupId the group ID 6799 * @param articleId the article ID 6800 * @param version the version 6801 * @return the matching journal article 6802 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6803 * @throws SystemException if a system exception occurred 6804 */ 6805 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V( 6806 long groupId, java.lang.String articleId, double version) 6807 throws com.liferay.portal.kernel.exception.SystemException, 6808 com.liferay.portlet.journal.NoSuchArticleException { 6809 return getPersistence().findByG_A_V(groupId, articleId, version); 6810 } 6811 6812 /** 6813 * Returns the journal article where groupId = ? and articleId = ? and version = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 6814 * 6815 * @param groupId the group ID 6816 * @param articleId the article ID 6817 * @param version the version 6818 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6819 * @throws SystemException if a system exception occurred 6820 */ 6821 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 6822 long groupId, java.lang.String articleId, double version) 6823 throws com.liferay.portal.kernel.exception.SystemException { 6824 return getPersistence().fetchByG_A_V(groupId, articleId, version); 6825 } 6826 6827 /** 6828 * Returns 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. 6829 * 6830 * @param groupId the group ID 6831 * @param articleId the article ID 6832 * @param version the version 6833 * @param retrieveFromCache whether to use the finder cache 6834 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6835 * @throws SystemException if a system exception occurred 6836 */ 6837 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 6838 long groupId, java.lang.String articleId, double version, 6839 boolean retrieveFromCache) 6840 throws com.liferay.portal.kernel.exception.SystemException { 6841 return getPersistence() 6842 .fetchByG_A_V(groupId, articleId, version, retrieveFromCache); 6843 } 6844 6845 /** 6846 * Removes the journal article where groupId = ? and articleId = ? and version = ? from the database. 6847 * 6848 * @param groupId the group ID 6849 * @param articleId the article ID 6850 * @param version the version 6851 * @return the journal article that was removed 6852 * @throws SystemException if a system exception occurred 6853 */ 6854 public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V( 6855 long groupId, java.lang.String articleId, double version) 6856 throws com.liferay.portal.kernel.exception.SystemException, 6857 com.liferay.portlet.journal.NoSuchArticleException { 6858 return getPersistence().removeByG_A_V(groupId, articleId, version); 6859 } 6860 6861 /** 6862 * Returns the number of journal articles where groupId = ? and articleId = ? and version = ?. 6863 * 6864 * @param groupId the group ID 6865 * @param articleId the article ID 6866 * @param version the version 6867 * @return the number of matching journal articles 6868 * @throws SystemException if a system exception occurred 6869 */ 6870 public static int countByG_A_V(long groupId, java.lang.String articleId, 6871 double version) 6872 throws com.liferay.portal.kernel.exception.SystemException { 6873 return getPersistence().countByG_A_V(groupId, articleId, version); 6874 } 6875 6876 /** 6877 * Returns all the journal articles where groupId = ? and articleId = ? and status = ?. 6878 * 6879 * @param groupId the group ID 6880 * @param articleId the article ID 6881 * @param status the status 6882 * @return the matching journal articles 6883 * @throws SystemException if a system exception occurred 6884 */ 6885 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6886 long groupId, java.lang.String articleId, int status) 6887 throws com.liferay.portal.kernel.exception.SystemException { 6888 return getPersistence().findByG_A_ST(groupId, articleId, status); 6889 } 6890 6891 /** 6892 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = ?. 6893 * 6894 * <p> 6895 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6896 * </p> 6897 * 6898 * @param groupId the group ID 6899 * @param articleId the article ID 6900 * @param status the status 6901 * @param start the lower bound of the range of journal articles 6902 * @param end the upper bound of the range of journal articles (not inclusive) 6903 * @return the range of matching journal articles 6904 * @throws SystemException if a system exception occurred 6905 */ 6906 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6907 long groupId, java.lang.String articleId, int status, int start, int end) 6908 throws com.liferay.portal.kernel.exception.SystemException { 6909 return getPersistence() 6910 .findByG_A_ST(groupId, articleId, status, start, end); 6911 } 6912 6913 /** 6914 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = ?. 6915 * 6916 * <p> 6917 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6918 * </p> 6919 * 6920 * @param groupId the group ID 6921 * @param articleId the article ID 6922 * @param status the status 6923 * @param start the lower bound of the range of journal articles 6924 * @param end the upper bound of the range of journal articles (not inclusive) 6925 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6926 * @return the ordered range of matching journal articles 6927 * @throws SystemException if a system exception occurred 6928 */ 6929 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6930 long groupId, java.lang.String articleId, int status, int start, 6931 int end, 6932 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6933 throws com.liferay.portal.kernel.exception.SystemException { 6934 return getPersistence() 6935 .findByG_A_ST(groupId, articleId, status, start, end, 6936 orderByComparator); 6937 } 6938 6939 /** 6940 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6941 * 6942 * @param groupId the group ID 6943 * @param articleId the article ID 6944 * @param status the status 6945 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6946 * @return the first matching journal article 6947 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6948 * @throws SystemException if a system exception occurred 6949 */ 6950 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First( 6951 long groupId, java.lang.String articleId, int status, 6952 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6953 throws com.liferay.portal.kernel.exception.SystemException, 6954 com.liferay.portlet.journal.NoSuchArticleException { 6955 return getPersistence() 6956 .findByG_A_ST_First(groupId, articleId, status, 6957 orderByComparator); 6958 } 6959 6960 /** 6961 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6962 * 6963 * @param groupId the group ID 6964 * @param articleId the article ID 6965 * @param status the status 6966 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6967 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6968 * @throws SystemException if a system exception occurred 6969 */ 6970 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First( 6971 long groupId, java.lang.String articleId, int status, 6972 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6973 throws com.liferay.portal.kernel.exception.SystemException { 6974 return getPersistence() 6975 .fetchByG_A_ST_First(groupId, articleId, status, 6976 orderByComparator); 6977 } 6978 6979 /** 6980 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6981 * 6982 * @param groupId the group ID 6983 * @param articleId the article ID 6984 * @param status the status 6985 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6986 * @return the last matching journal article 6987 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6988 * @throws SystemException if a system exception occurred 6989 */ 6990 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last( 6991 long groupId, java.lang.String articleId, int status, 6992 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6993 throws com.liferay.portal.kernel.exception.SystemException, 6994 com.liferay.portlet.journal.NoSuchArticleException { 6995 return getPersistence() 6996 .findByG_A_ST_Last(groupId, articleId, status, 6997 orderByComparator); 6998 } 6999 7000 /** 7001 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7002 * 7003 * @param groupId the group ID 7004 * @param articleId the article ID 7005 * @param status the status 7006 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7007 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7008 * @throws SystemException if a system exception occurred 7009 */ 7010 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last( 7011 long groupId, java.lang.String articleId, int status, 7012 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7013 throws com.liferay.portal.kernel.exception.SystemException { 7014 return getPersistence() 7015 .fetchByG_A_ST_Last(groupId, articleId, status, 7016 orderByComparator); 7017 } 7018 7019 /** 7020 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7021 * 7022 * @param id the primary key of the current journal article 7023 * @param groupId the group ID 7024 * @param articleId the article ID 7025 * @param status the status 7026 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7027 * @return the previous, current, and next journal article 7028 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7029 * @throws SystemException if a system exception occurred 7030 */ 7031 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext( 7032 long id, long groupId, java.lang.String articleId, int status, 7033 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7034 throws com.liferay.portal.kernel.exception.SystemException, 7035 com.liferay.portlet.journal.NoSuchArticleException { 7036 return getPersistence() 7037 .findByG_A_ST_PrevAndNext(id, groupId, articleId, status, 7038 orderByComparator); 7039 } 7040 7041 /** 7042 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7043 * 7044 * @param groupId the group ID 7045 * @param articleId the article ID 7046 * @param status the status 7047 * @return the matching journal articles that the user has permission to view 7048 * @throws SystemException if a system exception occurred 7049 */ 7050 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7051 long groupId, java.lang.String articleId, int status) 7052 throws com.liferay.portal.kernel.exception.SystemException { 7053 return getPersistence().filterFindByG_A_ST(groupId, articleId, status); 7054 } 7055 7056 /** 7057 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7058 * 7059 * <p> 7060 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7061 * </p> 7062 * 7063 * @param groupId the group ID 7064 * @param articleId the article ID 7065 * @param status the status 7066 * @param start the lower bound of the range of journal articles 7067 * @param end the upper bound of the range of journal articles (not inclusive) 7068 * @return the range of matching journal articles that the user has permission to view 7069 * @throws SystemException if a system exception occurred 7070 */ 7071 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7072 long groupId, java.lang.String articleId, int status, int start, int end) 7073 throws com.liferay.portal.kernel.exception.SystemException { 7074 return getPersistence() 7075 .filterFindByG_A_ST(groupId, articleId, status, start, end); 7076 } 7077 7078 /** 7079 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status = ?. 7080 * 7081 * <p> 7082 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7083 * </p> 7084 * 7085 * @param groupId the group ID 7086 * @param articleId the article ID 7087 * @param status the status 7088 * @param start the lower bound of the range of journal articles 7089 * @param end the upper bound of the range of journal articles (not inclusive) 7090 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7091 * @return the ordered range of matching journal articles that the user has permission to view 7092 * @throws SystemException if a system exception occurred 7093 */ 7094 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7095 long groupId, java.lang.String articleId, int status, int start, 7096 int end, 7097 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7098 throws com.liferay.portal.kernel.exception.SystemException { 7099 return getPersistence() 7100 .filterFindByG_A_ST(groupId, articleId, status, start, end, 7101 orderByComparator); 7102 } 7103 7104 /** 7105 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7106 * 7107 * @param id the primary key of the current journal article 7108 * @param groupId the group ID 7109 * @param articleId the article ID 7110 * @param status the status 7111 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7112 * @return the previous, current, and next journal article 7113 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7114 * @throws SystemException if a system exception occurred 7115 */ 7116 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext( 7117 long id, long groupId, java.lang.String articleId, int status, 7118 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7119 throws com.liferay.portal.kernel.exception.SystemException, 7120 com.liferay.portlet.journal.NoSuchArticleException { 7121 return getPersistence() 7122 .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId, 7123 status, orderByComparator); 7124 } 7125 7126 /** 7127 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7128 * 7129 * @param groupId the group ID 7130 * @param articleId the article ID 7131 * @param statuses the statuses 7132 * @return the matching journal articles that the user has permission to view 7133 * @throws SystemException if a system exception occurred 7134 */ 7135 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7136 long groupId, java.lang.String articleId, int[] statuses) 7137 throws com.liferay.portal.kernel.exception.SystemException { 7138 return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses); 7139 } 7140 7141 /** 7142 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7143 * 7144 * <p> 7145 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7146 * </p> 7147 * 7148 * @param groupId the group ID 7149 * @param articleId the article ID 7150 * @param statuses the statuses 7151 * @param start the lower bound of the range of journal articles 7152 * @param end the upper bound of the range of journal articles (not inclusive) 7153 * @return the range of matching journal articles that the user has permission to view 7154 * @throws SystemException if a system exception occurred 7155 */ 7156 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7157 long groupId, java.lang.String articleId, int[] statuses, int start, 7158 int end) throws com.liferay.portal.kernel.exception.SystemException { 7159 return getPersistence() 7160 .filterFindByG_A_ST(groupId, articleId, statuses, start, end); 7161 } 7162 7163 /** 7164 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7165 * 7166 * <p> 7167 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7168 * </p> 7169 * 7170 * @param groupId the group ID 7171 * @param articleId the article ID 7172 * @param statuses the statuses 7173 * @param start the lower bound of the range of journal articles 7174 * @param end the upper bound of the range of journal articles (not inclusive) 7175 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7176 * @return the ordered range of matching journal articles that the user has permission to view 7177 * @throws SystemException if a system exception occurred 7178 */ 7179 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7180 long groupId, java.lang.String articleId, int[] statuses, int start, 7181 int end, 7182 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7183 throws com.liferay.portal.kernel.exception.SystemException { 7184 return getPersistence() 7185 .filterFindByG_A_ST(groupId, articleId, statuses, start, 7186 end, orderByComparator); 7187 } 7188 7189 /** 7190 * Returns all the journal articles where groupId = ? and articleId = ? and status = any ?. 7191 * 7192 * <p> 7193 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7194 * </p> 7195 * 7196 * @param groupId the group ID 7197 * @param articleId the article ID 7198 * @param statuses the statuses 7199 * @return the matching journal articles 7200 * @throws SystemException if a system exception occurred 7201 */ 7202 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7203 long groupId, java.lang.String articleId, int[] statuses) 7204 throws com.liferay.portal.kernel.exception.SystemException { 7205 return getPersistence().findByG_A_ST(groupId, articleId, statuses); 7206 } 7207 7208 /** 7209 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 7210 * 7211 * <p> 7212 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7213 * </p> 7214 * 7215 * @param groupId the group ID 7216 * @param articleId the article ID 7217 * @param statuses the statuses 7218 * @param start the lower bound of the range of journal articles 7219 * @param end the upper bound of the range of journal articles (not inclusive) 7220 * @return the range of matching journal articles 7221 * @throws SystemException if a system exception occurred 7222 */ 7223 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7224 long groupId, java.lang.String articleId, int[] statuses, int start, 7225 int end) throws com.liferay.portal.kernel.exception.SystemException { 7226 return getPersistence() 7227 .findByG_A_ST(groupId, articleId, statuses, start, end); 7228 } 7229 7230 /** 7231 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 7232 * 7233 * <p> 7234 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7235 * </p> 7236 * 7237 * @param groupId the group ID 7238 * @param articleId the article ID 7239 * @param statuses the statuses 7240 * @param start the lower bound of the range of journal articles 7241 * @param end the upper bound of the range of journal articles (not inclusive) 7242 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7243 * @return the ordered range of matching journal articles 7244 * @throws SystemException if a system exception occurred 7245 */ 7246 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7247 long groupId, java.lang.String articleId, int[] statuses, int start, 7248 int end, 7249 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7250 throws com.liferay.portal.kernel.exception.SystemException { 7251 return getPersistence() 7252 .findByG_A_ST(groupId, articleId, statuses, start, end, 7253 orderByComparator); 7254 } 7255 7256 /** 7257 * Removes all the journal articles where groupId = ? and articleId = ? and status = ? from the database. 7258 * 7259 * @param groupId the group ID 7260 * @param articleId the article ID 7261 * @param status the status 7262 * @throws SystemException if a system exception occurred 7263 */ 7264 public static void removeByG_A_ST(long groupId, java.lang.String articleId, 7265 int status) throws com.liferay.portal.kernel.exception.SystemException { 7266 getPersistence().removeByG_A_ST(groupId, articleId, status); 7267 } 7268 7269 /** 7270 * Returns the number of journal articles where groupId = ? and articleId = ? and status = ?. 7271 * 7272 * @param groupId the group ID 7273 * @param articleId the article ID 7274 * @param status the status 7275 * @return the number of matching journal articles 7276 * @throws SystemException if a system exception occurred 7277 */ 7278 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7279 int status) throws com.liferay.portal.kernel.exception.SystemException { 7280 return getPersistence().countByG_A_ST(groupId, articleId, status); 7281 } 7282 7283 /** 7284 * Returns the number of journal articles where groupId = ? and articleId = ? and status = any ?. 7285 * 7286 * @param groupId the group ID 7287 * @param articleId the article ID 7288 * @param statuses the statuses 7289 * @return the number of matching journal articles 7290 * @throws SystemException if a system exception occurred 7291 */ 7292 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7293 int[] statuses) 7294 throws com.liferay.portal.kernel.exception.SystemException { 7295 return getPersistence().countByG_A_ST(groupId, articleId, statuses); 7296 } 7297 7298 /** 7299 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7300 * 7301 * @param groupId the group ID 7302 * @param articleId the article ID 7303 * @param status the status 7304 * @return the number of matching journal articles that the user has permission to view 7305 * @throws SystemException if a system exception occurred 7306 */ 7307 public static int filterCountByG_A_ST(long groupId, 7308 java.lang.String articleId, int status) 7309 throws com.liferay.portal.kernel.exception.SystemException { 7310 return getPersistence().filterCountByG_A_ST(groupId, articleId, status); 7311 } 7312 7313 /** 7314 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7315 * 7316 * @param groupId the group ID 7317 * @param articleId the article ID 7318 * @param statuses the statuses 7319 * @return the number of matching journal articles that the user has permission to view 7320 * @throws SystemException if a system exception occurred 7321 */ 7322 public static int filterCountByG_A_ST(long groupId, 7323 java.lang.String articleId, int[] statuses) 7324 throws com.liferay.portal.kernel.exception.SystemException { 7325 return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses); 7326 } 7327 7328 /** 7329 * Returns all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7330 * 7331 * @param groupId the group ID 7332 * @param urlTitle the url title 7333 * @param status the status 7334 * @return the matching journal articles 7335 * @throws SystemException if a system exception occurred 7336 */ 7337 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7338 long groupId, java.lang.String urlTitle, int status) 7339 throws com.liferay.portal.kernel.exception.SystemException { 7340 return getPersistence().findByG_UT_ST(groupId, urlTitle, status); 7341 } 7342 7343 /** 7344 * Returns a range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7345 * 7346 * <p> 7347 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7348 * </p> 7349 * 7350 * @param groupId the group ID 7351 * @param urlTitle the url title 7352 * @param status the status 7353 * @param start the lower bound of the range of journal articles 7354 * @param end the upper bound of the range of journal articles (not inclusive) 7355 * @return the range of matching journal articles 7356 * @throws SystemException if a system exception occurred 7357 */ 7358 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7359 long groupId, java.lang.String urlTitle, int status, int start, int end) 7360 throws com.liferay.portal.kernel.exception.SystemException { 7361 return getPersistence() 7362 .findByG_UT_ST(groupId, urlTitle, status, start, end); 7363 } 7364 7365 /** 7366 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7367 * 7368 * <p> 7369 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7370 * </p> 7371 * 7372 * @param groupId the group ID 7373 * @param urlTitle the url title 7374 * @param status the status 7375 * @param start the lower bound of the range of journal articles 7376 * @param end the upper bound of the range of journal articles (not inclusive) 7377 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7378 * @return the ordered range of matching journal articles 7379 * @throws SystemException if a system exception occurred 7380 */ 7381 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7382 long groupId, java.lang.String urlTitle, int status, int start, 7383 int end, 7384 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7385 throws com.liferay.portal.kernel.exception.SystemException { 7386 return getPersistence() 7387 .findByG_UT_ST(groupId, urlTitle, status, start, end, 7388 orderByComparator); 7389 } 7390 7391 /** 7392 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7393 * 7394 * @param groupId the group ID 7395 * @param urlTitle the url title 7396 * @param status the status 7397 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7398 * @return the first matching journal article 7399 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7400 * @throws SystemException if a system exception occurred 7401 */ 7402 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First( 7403 long groupId, java.lang.String urlTitle, int status, 7404 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7405 throws com.liferay.portal.kernel.exception.SystemException, 7406 com.liferay.portlet.journal.NoSuchArticleException { 7407 return getPersistence() 7408 .findByG_UT_ST_First(groupId, urlTitle, status, 7409 orderByComparator); 7410 } 7411 7412 /** 7413 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7414 * 7415 * @param groupId the group ID 7416 * @param urlTitle the url title 7417 * @param status the status 7418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7419 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7420 * @throws SystemException if a system exception occurred 7421 */ 7422 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First( 7423 long groupId, java.lang.String urlTitle, int status, 7424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7425 throws com.liferay.portal.kernel.exception.SystemException { 7426 return getPersistence() 7427 .fetchByG_UT_ST_First(groupId, urlTitle, status, 7428 orderByComparator); 7429 } 7430 7431 /** 7432 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7433 * 7434 * @param groupId the group ID 7435 * @param urlTitle the url title 7436 * @param status the status 7437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7438 * @return the last matching journal article 7439 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7440 * @throws SystemException if a system exception occurred 7441 */ 7442 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last( 7443 long groupId, java.lang.String urlTitle, int status, 7444 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7445 throws com.liferay.portal.kernel.exception.SystemException, 7446 com.liferay.portlet.journal.NoSuchArticleException { 7447 return getPersistence() 7448 .findByG_UT_ST_Last(groupId, urlTitle, status, 7449 orderByComparator); 7450 } 7451 7452 /** 7453 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7454 * 7455 * @param groupId the group ID 7456 * @param urlTitle the url title 7457 * @param status the status 7458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7459 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7460 * @throws SystemException if a system exception occurred 7461 */ 7462 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last( 7463 long groupId, java.lang.String urlTitle, int status, 7464 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7465 throws com.liferay.portal.kernel.exception.SystemException { 7466 return getPersistence() 7467 .fetchByG_UT_ST_Last(groupId, urlTitle, status, 7468 orderByComparator); 7469 } 7470 7471 /** 7472 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7473 * 7474 * @param id the primary key of the current journal article 7475 * @param groupId the group ID 7476 * @param urlTitle the url title 7477 * @param status the status 7478 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7479 * @return the previous, current, and next journal article 7480 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7481 * @throws SystemException if a system exception occurred 7482 */ 7483 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext( 7484 long id, long groupId, java.lang.String urlTitle, int status, 7485 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7486 throws com.liferay.portal.kernel.exception.SystemException, 7487 com.liferay.portlet.journal.NoSuchArticleException { 7488 return getPersistence() 7489 .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status, 7490 orderByComparator); 7491 } 7492 7493 /** 7494 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7495 * 7496 * @param groupId the group ID 7497 * @param urlTitle the url title 7498 * @param status the status 7499 * @return the matching journal articles that the user has permission to view 7500 * @throws SystemException if a system exception occurred 7501 */ 7502 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7503 long groupId, java.lang.String urlTitle, int status) 7504 throws com.liferay.portal.kernel.exception.SystemException { 7505 return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status); 7506 } 7507 7508 /** 7509 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7510 * 7511 * <p> 7512 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7513 * </p> 7514 * 7515 * @param groupId the group ID 7516 * @param urlTitle the url title 7517 * @param status the status 7518 * @param start the lower bound of the range of journal articles 7519 * @param end the upper bound of the range of journal articles (not inclusive) 7520 * @return the range of matching journal articles that the user has permission to view 7521 * @throws SystemException if a system exception occurred 7522 */ 7523 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7524 long groupId, java.lang.String urlTitle, int status, int start, int end) 7525 throws com.liferay.portal.kernel.exception.SystemException { 7526 return getPersistence() 7527 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end); 7528 } 7529 7530 /** 7531 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ? and status = ?. 7532 * 7533 * <p> 7534 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7535 * </p> 7536 * 7537 * @param groupId the group ID 7538 * @param urlTitle the url title 7539 * @param status the status 7540 * @param start the lower bound of the range of journal articles 7541 * @param end the upper bound of the range of journal articles (not inclusive) 7542 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7543 * @return the ordered range of matching journal articles that the user has permission to view 7544 * @throws SystemException if a system exception occurred 7545 */ 7546 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7547 long groupId, java.lang.String urlTitle, int status, int start, 7548 int end, 7549 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7550 throws com.liferay.portal.kernel.exception.SystemException { 7551 return getPersistence() 7552 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end, 7553 orderByComparator); 7554 } 7555 7556 /** 7557 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7558 * 7559 * @param id the primary key of the current journal article 7560 * @param groupId the group ID 7561 * @param urlTitle the url title 7562 * @param status the status 7563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7564 * @return the previous, current, and next journal article 7565 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7566 * @throws SystemException if a system exception occurred 7567 */ 7568 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext( 7569 long id, long groupId, java.lang.String urlTitle, int status, 7570 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7571 throws com.liferay.portal.kernel.exception.SystemException, 7572 com.liferay.portlet.journal.NoSuchArticleException { 7573 return getPersistence() 7574 .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle, 7575 status, orderByComparator); 7576 } 7577 7578 /** 7579 * Removes all the journal articles where groupId = ? and urlTitle = ? and status = ? from the database. 7580 * 7581 * @param groupId the group ID 7582 * @param urlTitle the url title 7583 * @param status the status 7584 * @throws SystemException if a system exception occurred 7585 */ 7586 public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle, 7587 int status) throws com.liferay.portal.kernel.exception.SystemException { 7588 getPersistence().removeByG_UT_ST(groupId, urlTitle, status); 7589 } 7590 7591 /** 7592 * Returns the number of journal articles where groupId = ? and urlTitle = ? and status = ?. 7593 * 7594 * @param groupId the group ID 7595 * @param urlTitle the url title 7596 * @param status the status 7597 * @return the number of matching journal articles 7598 * @throws SystemException if a system exception occurred 7599 */ 7600 public static int countByG_UT_ST(long groupId, java.lang.String urlTitle, 7601 int status) throws com.liferay.portal.kernel.exception.SystemException { 7602 return getPersistence().countByG_UT_ST(groupId, urlTitle, status); 7603 } 7604 7605 /** 7606 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7607 * 7608 * @param groupId the group ID 7609 * @param urlTitle the url title 7610 * @param status the status 7611 * @return the number of matching journal articles that the user has permission to view 7612 * @throws SystemException if a system exception occurred 7613 */ 7614 public static int filterCountByG_UT_ST(long groupId, 7615 java.lang.String urlTitle, int status) 7616 throws com.liferay.portal.kernel.exception.SystemException { 7617 return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status); 7618 } 7619 7620 /** 7621 * Returns all the journal articles where companyId = ? and version = ? and status = ?. 7622 * 7623 * @param companyId the company ID 7624 * @param version the version 7625 * @param status the status 7626 * @return the matching journal articles 7627 * @throws SystemException if a system exception occurred 7628 */ 7629 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7630 long companyId, double version, int status) 7631 throws com.liferay.portal.kernel.exception.SystemException { 7632 return getPersistence().findByC_V_ST(companyId, version, status); 7633 } 7634 7635 /** 7636 * Returns a range of all the journal articles where companyId = ? and version = ? and status = ?. 7637 * 7638 * <p> 7639 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7640 * </p> 7641 * 7642 * @param companyId the company ID 7643 * @param version the version 7644 * @param status the status 7645 * @param start the lower bound of the range of journal articles 7646 * @param end the upper bound of the range of journal articles (not inclusive) 7647 * @return the range of matching journal articles 7648 * @throws SystemException if a system exception occurred 7649 */ 7650 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7651 long companyId, double version, int status, int start, int end) 7652 throws com.liferay.portal.kernel.exception.SystemException { 7653 return getPersistence() 7654 .findByC_V_ST(companyId, version, status, start, end); 7655 } 7656 7657 /** 7658 * Returns an ordered range of all the journal articles where companyId = ? and version = ? and status = ?. 7659 * 7660 * <p> 7661 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7662 * </p> 7663 * 7664 * @param companyId the company ID 7665 * @param version the version 7666 * @param status the status 7667 * @param start the lower bound of the range of journal articles 7668 * @param end the upper bound of the range of journal articles (not inclusive) 7669 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7670 * @return the ordered range of matching journal articles 7671 * @throws SystemException if a system exception occurred 7672 */ 7673 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7674 long companyId, double version, int status, int start, int end, 7675 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7676 throws com.liferay.portal.kernel.exception.SystemException { 7677 return getPersistence() 7678 .findByC_V_ST(companyId, version, status, start, end, 7679 orderByComparator); 7680 } 7681 7682 /** 7683 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 7684 * 7685 * @param companyId the company ID 7686 * @param version the version 7687 * @param status the status 7688 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7689 * @return the first matching journal article 7690 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7691 * @throws SystemException if a system exception occurred 7692 */ 7693 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First( 7694 long companyId, double version, int status, 7695 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7696 throws com.liferay.portal.kernel.exception.SystemException, 7697 com.liferay.portlet.journal.NoSuchArticleException { 7698 return getPersistence() 7699 .findByC_V_ST_First(companyId, version, status, 7700 orderByComparator); 7701 } 7702 7703 /** 7704 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 7705 * 7706 * @param companyId the company ID 7707 * @param version the version 7708 * @param status the status 7709 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7710 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7711 * @throws SystemException if a system exception occurred 7712 */ 7713 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First( 7714 long companyId, double version, int status, 7715 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7716 throws com.liferay.portal.kernel.exception.SystemException { 7717 return getPersistence() 7718 .fetchByC_V_ST_First(companyId, version, status, 7719 orderByComparator); 7720 } 7721 7722 /** 7723 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 7724 * 7725 * @param companyId the company ID 7726 * @param version the version 7727 * @param status the status 7728 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7729 * @return the last matching journal article 7730 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7731 * @throws SystemException if a system exception occurred 7732 */ 7733 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last( 7734 long companyId, double version, int status, 7735 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7736 throws com.liferay.portal.kernel.exception.SystemException, 7737 com.liferay.portlet.journal.NoSuchArticleException { 7738 return getPersistence() 7739 .findByC_V_ST_Last(companyId, version, status, 7740 orderByComparator); 7741 } 7742 7743 /** 7744 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 7745 * 7746 * @param companyId the company ID 7747 * @param version the version 7748 * @param status the status 7749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7750 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7751 * @throws SystemException if a system exception occurred 7752 */ 7753 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last( 7754 long companyId, double version, int status, 7755 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7756 throws com.liferay.portal.kernel.exception.SystemException { 7757 return getPersistence() 7758 .fetchByC_V_ST_Last(companyId, version, status, 7759 orderByComparator); 7760 } 7761 7762 /** 7763 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ? and status = ?. 7764 * 7765 * @param id the primary key of the current journal article 7766 * @param companyId the company ID 7767 * @param version the version 7768 * @param status the status 7769 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7770 * @return the previous, current, and next journal article 7771 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7772 * @throws SystemException if a system exception occurred 7773 */ 7774 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext( 7775 long id, long companyId, double version, int status, 7776 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7777 throws com.liferay.portal.kernel.exception.SystemException, 7778 com.liferay.portlet.journal.NoSuchArticleException { 7779 return getPersistence() 7780 .findByC_V_ST_PrevAndNext(id, companyId, version, status, 7781 orderByComparator); 7782 } 7783 7784 /** 7785 * Removes all the journal articles where companyId = ? and version = ? and status = ? from the database. 7786 * 7787 * @param companyId the company ID 7788 * @param version the version 7789 * @param status the status 7790 * @throws SystemException if a system exception occurred 7791 */ 7792 public static void removeByC_V_ST(long companyId, double version, int status) 7793 throws com.liferay.portal.kernel.exception.SystemException { 7794 getPersistence().removeByC_V_ST(companyId, version, status); 7795 } 7796 7797 /** 7798 * Returns the number of journal articles where companyId = ? and version = ? and status = ?. 7799 * 7800 * @param companyId the company ID 7801 * @param version the version 7802 * @param status the status 7803 * @return the number of matching journal articles 7804 * @throws SystemException if a system exception occurred 7805 */ 7806 public static int countByC_V_ST(long companyId, double version, int status) 7807 throws com.liferay.portal.kernel.exception.SystemException { 7808 return getPersistence().countByC_V_ST(companyId, version, status); 7809 } 7810 7811 /** 7812 * Caches the journal article in the entity cache if it is enabled. 7813 * 7814 * @param journalArticle the journal article 7815 */ 7816 public static void cacheResult( 7817 com.liferay.portlet.journal.model.JournalArticle journalArticle) { 7818 getPersistence().cacheResult(journalArticle); 7819 } 7820 7821 /** 7822 * Caches the journal articles in the entity cache if it is enabled. 7823 * 7824 * @param journalArticles the journal articles 7825 */ 7826 public static void cacheResult( 7827 java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) { 7828 getPersistence().cacheResult(journalArticles); 7829 } 7830 7831 /** 7832 * Creates a new journal article with the primary key. Does not add the journal article to the database. 7833 * 7834 * @param id the primary key for the new journal article 7835 * @return the new journal article 7836 */ 7837 public static com.liferay.portlet.journal.model.JournalArticle create( 7838 long id) { 7839 return getPersistence().create(id); 7840 } 7841 7842 /** 7843 * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners. 7844 * 7845 * @param id the primary key of the journal article 7846 * @return the journal article that was removed 7847 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7848 * @throws SystemException if a system exception occurred 7849 */ 7850 public static com.liferay.portlet.journal.model.JournalArticle remove( 7851 long id) 7852 throws com.liferay.portal.kernel.exception.SystemException, 7853 com.liferay.portlet.journal.NoSuchArticleException { 7854 return getPersistence().remove(id); 7855 } 7856 7857 public static com.liferay.portlet.journal.model.JournalArticle updateImpl( 7858 com.liferay.portlet.journal.model.JournalArticle journalArticle) 7859 throws com.liferay.portal.kernel.exception.SystemException { 7860 return getPersistence().updateImpl(journalArticle); 7861 } 7862 7863 /** 7864 * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 7865 * 7866 * @param id the primary key of the journal article 7867 * @return the journal article 7868 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7869 * @throws SystemException if a system exception occurred 7870 */ 7871 public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey( 7872 long id) 7873 throws com.liferay.portal.kernel.exception.SystemException, 7874 com.liferay.portlet.journal.NoSuchArticleException { 7875 return getPersistence().findByPrimaryKey(id); 7876 } 7877 7878 /** 7879 * Returns the journal article with the primary key or returns <code>null</code> if it could not be found. 7880 * 7881 * @param id the primary key of the journal article 7882 * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found 7883 * @throws SystemException if a system exception occurred 7884 */ 7885 public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey( 7886 long id) throws com.liferay.portal.kernel.exception.SystemException { 7887 return getPersistence().fetchByPrimaryKey(id); 7888 } 7889 7890 /** 7891 * Returns all the journal articles. 7892 * 7893 * @return the journal articles 7894 * @throws SystemException if a system exception occurred 7895 */ 7896 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll() 7897 throws com.liferay.portal.kernel.exception.SystemException { 7898 return getPersistence().findAll(); 7899 } 7900 7901 /** 7902 * Returns a range of all the journal articles. 7903 * 7904 * <p> 7905 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7906 * </p> 7907 * 7908 * @param start the lower bound of the range of journal articles 7909 * @param end the upper bound of the range of journal articles (not inclusive) 7910 * @return the range of journal articles 7911 * @throws SystemException if a system exception occurred 7912 */ 7913 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 7914 int start, int end) 7915 throws com.liferay.portal.kernel.exception.SystemException { 7916 return getPersistence().findAll(start, end); 7917 } 7918 7919 /** 7920 * Returns an ordered range of all the journal articles. 7921 * 7922 * <p> 7923 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7924 * </p> 7925 * 7926 * @param start the lower bound of the range of journal articles 7927 * @param end the upper bound of the range of journal articles (not inclusive) 7928 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7929 * @return the ordered range of journal articles 7930 * @throws SystemException if a system exception occurred 7931 */ 7932 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 7933 int start, int end, 7934 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7935 throws com.liferay.portal.kernel.exception.SystemException { 7936 return getPersistence().findAll(start, end, orderByComparator); 7937 } 7938 7939 /** 7940 * Removes all the journal articles from the database. 7941 * 7942 * @throws SystemException if a system exception occurred 7943 */ 7944 public static void removeAll() 7945 throws com.liferay.portal.kernel.exception.SystemException { 7946 getPersistence().removeAll(); 7947 } 7948 7949 /** 7950 * Returns the number of journal articles. 7951 * 7952 * @return the number of journal articles 7953 * @throws SystemException if a system exception occurred 7954 */ 7955 public static int countAll() 7956 throws com.liferay.portal.kernel.exception.SystemException { 7957 return getPersistence().countAll(); 7958 } 7959 7960 public static JournalArticlePersistence getPersistence() { 7961 if (_persistence == null) { 7962 _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName()); 7963 7964 ReferenceRegistry.registerReference(JournalArticleUtil.class, 7965 "_persistence"); 7966 } 7967 7968 return _persistence; 7969 } 7970 7971 /** 7972 * @deprecated As of 6.2.0 7973 */ 7974 public void setPersistence(JournalArticlePersistence persistence) { 7975 } 7976 7977 private static JournalArticlePersistence _persistence; 7978 }