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 aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.exception.SystemException; 022 import com.liferay.portal.kernel.util.OrderByComparator; 023 import com.liferay.portal.kernel.util.ReferenceRegistry; 024 import com.liferay.portal.service.ServiceContext; 025 026 import com.liferay.portlet.journal.model.JournalArticle; 027 028 import java.util.List; 029 030 /** 031 * 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. 032 * 033 * <p> 034 * Caching information and settings can be found in <code>portal.properties</code> 035 * </p> 036 * 037 * @author Brian Wing Shun Chan 038 * @see JournalArticlePersistence 039 * @see JournalArticlePersistenceImpl 040 * @generated 041 */ 042 @ProviderType 043 public class JournalArticleUtil { 044 /* 045 * NOTE FOR DEVELOPERS: 046 * 047 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 048 */ 049 050 /** 051 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 052 */ 053 public static void clearCache() { 054 getPersistence().clearCache(); 055 } 056 057 /** 058 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 059 */ 060 public static void clearCache(JournalArticle journalArticle) { 061 getPersistence().clearCache(journalArticle); 062 } 063 064 /** 065 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 066 */ 067 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) 068 throws SystemException { 069 return getPersistence().countWithDynamicQuery(dynamicQuery); 070 } 071 072 /** 073 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 074 */ 075 public static List<JournalArticle> findWithDynamicQuery( 076 DynamicQuery dynamicQuery) throws SystemException { 077 return getPersistence().findWithDynamicQuery(dynamicQuery); 078 } 079 080 /** 081 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 082 */ 083 public static List<JournalArticle> findWithDynamicQuery( 084 DynamicQuery dynamicQuery, int start, int end) 085 throws SystemException { 086 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 087 } 088 089 /** 090 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 091 */ 092 public static List<JournalArticle> findWithDynamicQuery( 093 DynamicQuery dynamicQuery, int start, int end, 094 OrderByComparator orderByComparator) throws SystemException { 095 return getPersistence() 096 .findWithDynamicQuery(dynamicQuery, start, end, 097 orderByComparator); 098 } 099 100 /** 101 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 102 */ 103 public static JournalArticle update(JournalArticle journalArticle) 104 throws SystemException { 105 return getPersistence().update(journalArticle); 106 } 107 108 /** 109 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 110 */ 111 public static JournalArticle update(JournalArticle journalArticle, 112 ServiceContext serviceContext) throws SystemException { 113 return getPersistence().update(journalArticle, serviceContext); 114 } 115 116 /** 117 * Returns all the journal articles where uuid = ?. 118 * 119 * @param uuid the uuid 120 * @return the matching journal articles 121 * @throws SystemException if a system exception occurred 122 */ 123 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 124 java.lang.String uuid) 125 throws com.liferay.portal.kernel.exception.SystemException { 126 return getPersistence().findByUuid(uuid); 127 } 128 129 /** 130 * Returns a range of all the journal articles where uuid = ?. 131 * 132 * <p> 133 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 134 * </p> 135 * 136 * @param uuid the uuid 137 * @param start the lower bound of the range of journal articles 138 * @param end the upper bound of the range of journal articles (not inclusive) 139 * @return the range of matching journal articles 140 * @throws SystemException if a system exception occurred 141 */ 142 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 143 java.lang.String uuid, int start, int end) 144 throws com.liferay.portal.kernel.exception.SystemException { 145 return getPersistence().findByUuid(uuid, start, end); 146 } 147 148 /** 149 * Returns an ordered range of all the journal articles where uuid = ?. 150 * 151 * <p> 152 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 153 * </p> 154 * 155 * @param uuid the uuid 156 * @param start the lower bound of the range of journal articles 157 * @param end the upper bound of the range of journal articles (not inclusive) 158 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 159 * @return the ordered range of matching journal articles 160 * @throws SystemException if a system exception occurred 161 */ 162 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 163 java.lang.String uuid, int start, int end, 164 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 165 throws com.liferay.portal.kernel.exception.SystemException { 166 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 167 } 168 169 /** 170 * Returns the first journal article in the ordered set where uuid = ?. 171 * 172 * @param uuid the uuid 173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 174 * @return the first matching journal article 175 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 176 * @throws SystemException if a system exception occurred 177 */ 178 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First( 179 java.lang.String uuid, 180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.journal.NoSuchArticleException { 183 return getPersistence().findByUuid_First(uuid, orderByComparator); 184 } 185 186 /** 187 * Returns the first journal article in the ordered set where uuid = ?. 188 * 189 * @param uuid the uuid 190 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 191 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 192 * @throws SystemException if a system exception occurred 193 */ 194 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First( 195 java.lang.String uuid, 196 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 197 throws com.liferay.portal.kernel.exception.SystemException { 198 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 199 } 200 201 /** 202 * Returns the last journal article in the ordered set where uuid = ?. 203 * 204 * @param uuid the uuid 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the last matching journal article 207 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 208 * @throws SystemException if a system exception occurred 209 */ 210 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last( 211 java.lang.String uuid, 212 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 213 throws com.liferay.portal.kernel.exception.SystemException, 214 com.liferay.portlet.journal.NoSuchArticleException { 215 return getPersistence().findByUuid_Last(uuid, orderByComparator); 216 } 217 218 /** 219 * Returns the last journal article in the ordered set where uuid = ?. 220 * 221 * @param uuid the uuid 222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 223 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 224 * @throws SystemException if a system exception occurred 225 */ 226 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last( 227 java.lang.String uuid, 228 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 229 throws com.liferay.portal.kernel.exception.SystemException { 230 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 231 } 232 233 /** 234 * Returns the journal articles before and after the current journal article in the ordered set where uuid = ?. 235 * 236 * @param id the primary key of the current journal article 237 * @param uuid the uuid 238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 239 * @return the previous, current, and next journal article 240 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 241 * @throws SystemException if a system exception occurred 242 */ 243 public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext( 244 long id, java.lang.String uuid, 245 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 246 throws com.liferay.portal.kernel.exception.SystemException, 247 com.liferay.portlet.journal.NoSuchArticleException { 248 return getPersistence() 249 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 250 } 251 252 /** 253 * Removes all the journal articles where uuid = ? from the database. 254 * 255 * @param uuid the uuid 256 * @throws SystemException if a system exception occurred 257 */ 258 public static void removeByUuid(java.lang.String uuid) 259 throws com.liferay.portal.kernel.exception.SystemException { 260 getPersistence().removeByUuid(uuid); 261 } 262 263 /** 264 * Returns the number of journal articles where uuid = ?. 265 * 266 * @param uuid the uuid 267 * @return the number of matching journal articles 268 * @throws SystemException if a system exception occurred 269 */ 270 public static int countByUuid(java.lang.String uuid) 271 throws com.liferay.portal.kernel.exception.SystemException { 272 return getPersistence().countByUuid(uuid); 273 } 274 275 /** 276 * Returns the journal article where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 277 * 278 * @param uuid the uuid 279 * @param groupId the group ID 280 * @return the matching journal article 281 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 282 * @throws SystemException if a system exception occurred 283 */ 284 public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G( 285 java.lang.String uuid, long groupId) 286 throws com.liferay.portal.kernel.exception.SystemException, 287 com.liferay.portlet.journal.NoSuchArticleException { 288 return getPersistence().findByUUID_G(uuid, groupId); 289 } 290 291 /** 292 * Returns the journal article where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 293 * 294 * @param uuid the uuid 295 * @param groupId the group ID 296 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 297 * @throws SystemException if a system exception occurred 298 */ 299 public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G( 300 java.lang.String uuid, long groupId) 301 throws com.liferay.portal.kernel.exception.SystemException { 302 return getPersistence().fetchByUUID_G(uuid, groupId); 303 } 304 305 /** 306 * Returns the journal article where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 307 * 308 * @param uuid the uuid 309 * @param groupId the group ID 310 * @param retrieveFromCache whether to use the finder cache 311 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 312 * @throws SystemException if a system exception occurred 313 */ 314 public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G( 315 java.lang.String uuid, long groupId, boolean retrieveFromCache) 316 throws com.liferay.portal.kernel.exception.SystemException { 317 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 318 } 319 320 /** 321 * Removes the journal article where uuid = ? and groupId = ? from the database. 322 * 323 * @param uuid the uuid 324 * @param groupId the group ID 325 * @return the journal article that was removed 326 * @throws SystemException if a system exception occurred 327 */ 328 public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G( 329 java.lang.String uuid, long groupId) 330 throws com.liferay.portal.kernel.exception.SystemException, 331 com.liferay.portlet.journal.NoSuchArticleException { 332 return getPersistence().removeByUUID_G(uuid, groupId); 333 } 334 335 /** 336 * Returns the number of journal articles where uuid = ? and groupId = ?. 337 * 338 * @param uuid the uuid 339 * @param groupId the group ID 340 * @return the number of matching journal articles 341 * @throws SystemException if a system exception occurred 342 */ 343 public static int countByUUID_G(java.lang.String uuid, long groupId) 344 throws com.liferay.portal.kernel.exception.SystemException { 345 return getPersistence().countByUUID_G(uuid, groupId); 346 } 347 348 /** 349 * Returns all the journal articles where uuid = ? and companyId = ?. 350 * 351 * @param uuid the uuid 352 * @param companyId the company ID 353 * @return the matching journal articles 354 * @throws SystemException if a system exception occurred 355 */ 356 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 357 java.lang.String uuid, long companyId) 358 throws com.liferay.portal.kernel.exception.SystemException { 359 return getPersistence().findByUuid_C(uuid, companyId); 360 } 361 362 /** 363 * Returns a range of all the journal articles where uuid = ? and companyId = ?. 364 * 365 * <p> 366 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 367 * </p> 368 * 369 * @param uuid the uuid 370 * @param companyId the company ID 371 * @param start the lower bound of the range of journal articles 372 * @param end the upper bound of the range of journal articles (not inclusive) 373 * @return the range of matching journal articles 374 * @throws SystemException if a system exception occurred 375 */ 376 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 377 java.lang.String uuid, long companyId, int start, int end) 378 throws com.liferay.portal.kernel.exception.SystemException { 379 return getPersistence().findByUuid_C(uuid, companyId, start, end); 380 } 381 382 /** 383 * Returns an ordered range of all the journal articles where uuid = ? and companyId = ?. 384 * 385 * <p> 386 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 387 * </p> 388 * 389 * @param uuid the uuid 390 * @param companyId the company ID 391 * @param start the lower bound of the range of journal articles 392 * @param end the upper bound of the range of journal articles (not inclusive) 393 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 394 * @return the ordered range of matching journal articles 395 * @throws SystemException if a system exception occurred 396 */ 397 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 398 java.lang.String uuid, long companyId, int start, int end, 399 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 400 throws com.liferay.portal.kernel.exception.SystemException { 401 return getPersistence() 402 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 403 } 404 405 /** 406 * Returns the first journal article in the ordered set where uuid = ? and companyId = ?. 407 * 408 * @param uuid the uuid 409 * @param companyId the company ID 410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 411 * @return the first matching journal article 412 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 413 * @throws SystemException if a system exception occurred 414 */ 415 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First( 416 java.lang.String uuid, long companyId, 417 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 418 throws com.liferay.portal.kernel.exception.SystemException, 419 com.liferay.portlet.journal.NoSuchArticleException { 420 return getPersistence() 421 .findByUuid_C_First(uuid, companyId, orderByComparator); 422 } 423 424 /** 425 * Returns the first journal article in the ordered set where uuid = ? and companyId = ?. 426 * 427 * @param uuid the uuid 428 * @param companyId the company ID 429 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 430 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 431 * @throws SystemException if a system exception occurred 432 */ 433 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First( 434 java.lang.String uuid, long companyId, 435 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 436 throws com.liferay.portal.kernel.exception.SystemException { 437 return getPersistence() 438 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 439 } 440 441 /** 442 * Returns the last journal article in the ordered set where uuid = ? and companyId = ?. 443 * 444 * @param uuid the uuid 445 * @param companyId the company ID 446 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 447 * @return the last matching journal article 448 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 449 * @throws SystemException if a system exception occurred 450 */ 451 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last( 452 java.lang.String uuid, long companyId, 453 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 454 throws com.liferay.portal.kernel.exception.SystemException, 455 com.liferay.portlet.journal.NoSuchArticleException { 456 return getPersistence() 457 .findByUuid_C_Last(uuid, companyId, orderByComparator); 458 } 459 460 /** 461 * Returns the last journal article in the ordered set where uuid = ? and companyId = ?. 462 * 463 * @param uuid the uuid 464 * @param companyId the company ID 465 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 466 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 467 * @throws SystemException if a system exception occurred 468 */ 469 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last( 470 java.lang.String uuid, long companyId, 471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 472 throws com.liferay.portal.kernel.exception.SystemException { 473 return getPersistence() 474 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 475 } 476 477 /** 478 * Returns the journal articles before and after the current journal article in the ordered set where uuid = ? and companyId = ?. 479 * 480 * @param id the primary key of the current journal article 481 * @param uuid the uuid 482 * @param companyId the company ID 483 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 484 * @return the previous, current, and next journal article 485 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 486 * @throws SystemException if a system exception occurred 487 */ 488 public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext( 489 long id, java.lang.String uuid, long companyId, 490 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 491 throws com.liferay.portal.kernel.exception.SystemException, 492 com.liferay.portlet.journal.NoSuchArticleException { 493 return getPersistence() 494 .findByUuid_C_PrevAndNext(id, uuid, companyId, 495 orderByComparator); 496 } 497 498 /** 499 * Removes all the journal articles where uuid = ? and companyId = ? from the database. 500 * 501 * @param uuid the uuid 502 * @param companyId the company ID 503 * @throws SystemException if a system exception occurred 504 */ 505 public static void removeByUuid_C(java.lang.String uuid, long companyId) 506 throws com.liferay.portal.kernel.exception.SystemException { 507 getPersistence().removeByUuid_C(uuid, companyId); 508 } 509 510 /** 511 * Returns the number of journal articles where uuid = ? and companyId = ?. 512 * 513 * @param uuid the uuid 514 * @param companyId the company ID 515 * @return the number of matching journal articles 516 * @throws SystemException if a system exception occurred 517 */ 518 public static int countByUuid_C(java.lang.String uuid, long companyId) 519 throws com.liferay.portal.kernel.exception.SystemException { 520 return getPersistence().countByUuid_C(uuid, companyId); 521 } 522 523 /** 524 * Returns all the journal articles where resourcePrimKey = ?. 525 * 526 * @param resourcePrimKey the resource prim key 527 * @return the matching journal articles 528 * @throws SystemException if a system exception occurred 529 */ 530 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 531 long resourcePrimKey) 532 throws com.liferay.portal.kernel.exception.SystemException { 533 return getPersistence().findByResourcePrimKey(resourcePrimKey); 534 } 535 536 /** 537 * Returns a range of all the journal articles where resourcePrimKey = ?. 538 * 539 * <p> 540 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 541 * </p> 542 * 543 * @param resourcePrimKey the resource prim key 544 * @param start the lower bound of the range of journal articles 545 * @param end the upper bound of the range of journal articles (not inclusive) 546 * @return the range of matching journal articles 547 * @throws SystemException if a system exception occurred 548 */ 549 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 550 long resourcePrimKey, int start, int end) 551 throws com.liferay.portal.kernel.exception.SystemException { 552 return getPersistence() 553 .findByResourcePrimKey(resourcePrimKey, start, end); 554 } 555 556 /** 557 * Returns an ordered range of all the journal articles where resourcePrimKey = ?. 558 * 559 * <p> 560 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 561 * </p> 562 * 563 * @param resourcePrimKey the resource prim key 564 * @param start the lower bound of the range of journal articles 565 * @param end the upper bound of the range of journal articles (not inclusive) 566 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 567 * @return the ordered range of matching journal articles 568 * @throws SystemException if a system exception occurred 569 */ 570 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 571 long resourcePrimKey, int start, int end, 572 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 573 throws com.liferay.portal.kernel.exception.SystemException { 574 return getPersistence() 575 .findByResourcePrimKey(resourcePrimKey, start, end, 576 orderByComparator); 577 } 578 579 /** 580 * Returns the first journal article in the ordered set where resourcePrimKey = ?. 581 * 582 * @param resourcePrimKey the resource prim key 583 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 584 * @return the first matching journal article 585 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 586 * @throws SystemException if a system exception occurred 587 */ 588 public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First( 589 long resourcePrimKey, 590 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 591 throws com.liferay.portal.kernel.exception.SystemException, 592 com.liferay.portlet.journal.NoSuchArticleException { 593 return getPersistence() 594 .findByResourcePrimKey_First(resourcePrimKey, 595 orderByComparator); 596 } 597 598 /** 599 * Returns the first journal article in the ordered set where resourcePrimKey = ?. 600 * 601 * @param resourcePrimKey the resource prim key 602 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 603 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 604 * @throws SystemException if a system exception occurred 605 */ 606 public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First( 607 long resourcePrimKey, 608 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 609 throws com.liferay.portal.kernel.exception.SystemException { 610 return getPersistence() 611 .fetchByResourcePrimKey_First(resourcePrimKey, 612 orderByComparator); 613 } 614 615 /** 616 * Returns the last journal article in the ordered set where resourcePrimKey = ?. 617 * 618 * @param resourcePrimKey the resource prim key 619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 620 * @return the last matching journal article 621 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 622 * @throws SystemException if a system exception occurred 623 */ 624 public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last( 625 long resourcePrimKey, 626 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 627 throws com.liferay.portal.kernel.exception.SystemException, 628 com.liferay.portlet.journal.NoSuchArticleException { 629 return getPersistence() 630 .findByResourcePrimKey_Last(resourcePrimKey, 631 orderByComparator); 632 } 633 634 /** 635 * Returns the last journal article in the ordered set where resourcePrimKey = ?. 636 * 637 * @param resourcePrimKey the resource prim key 638 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 639 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 640 * @throws SystemException if a system exception occurred 641 */ 642 public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last( 643 long resourcePrimKey, 644 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 645 throws com.liferay.portal.kernel.exception.SystemException { 646 return getPersistence() 647 .fetchByResourcePrimKey_Last(resourcePrimKey, 648 orderByComparator); 649 } 650 651 /** 652 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ?. 653 * 654 * @param id the primary key of the current journal article 655 * @param resourcePrimKey the resource prim key 656 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 657 * @return the previous, current, and next journal article 658 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 659 * @throws SystemException if a system exception occurred 660 */ 661 public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext( 662 long id, long resourcePrimKey, 663 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 664 throws com.liferay.portal.kernel.exception.SystemException, 665 com.liferay.portlet.journal.NoSuchArticleException { 666 return getPersistence() 667 .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey, 668 orderByComparator); 669 } 670 671 /** 672 * Removes all the journal articles where resourcePrimKey = ? from the database. 673 * 674 * @param resourcePrimKey the resource prim key 675 * @throws SystemException if a system exception occurred 676 */ 677 public static void removeByResourcePrimKey(long resourcePrimKey) 678 throws com.liferay.portal.kernel.exception.SystemException { 679 getPersistence().removeByResourcePrimKey(resourcePrimKey); 680 } 681 682 /** 683 * Returns the number of journal articles where resourcePrimKey = ?. 684 * 685 * @param resourcePrimKey the resource prim key 686 * @return the number of matching journal articles 687 * @throws SystemException if a system exception occurred 688 */ 689 public static int countByResourcePrimKey(long resourcePrimKey) 690 throws com.liferay.portal.kernel.exception.SystemException { 691 return getPersistence().countByResourcePrimKey(resourcePrimKey); 692 } 693 694 /** 695 * Returns all the journal articles where groupId = ?. 696 * 697 * @param groupId the group ID 698 * @return the matching journal articles 699 * @throws SystemException if a system exception occurred 700 */ 701 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 702 long groupId) 703 throws com.liferay.portal.kernel.exception.SystemException { 704 return getPersistence().findByGroupId(groupId); 705 } 706 707 /** 708 * Returns a range of all the journal articles where groupId = ?. 709 * 710 * <p> 711 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 712 * </p> 713 * 714 * @param groupId the group ID 715 * @param start the lower bound of the range of journal articles 716 * @param end the upper bound of the range of journal articles (not inclusive) 717 * @return the range of matching journal articles 718 * @throws SystemException if a system exception occurred 719 */ 720 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 721 long groupId, int start, int end) 722 throws com.liferay.portal.kernel.exception.SystemException { 723 return getPersistence().findByGroupId(groupId, start, end); 724 } 725 726 /** 727 * Returns an ordered range of all the journal articles where groupId = ?. 728 * 729 * <p> 730 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 731 * </p> 732 * 733 * @param groupId the group ID 734 * @param start the lower bound of the range of journal articles 735 * @param end the upper bound of the range of journal articles (not inclusive) 736 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 737 * @return the ordered range of matching journal articles 738 * @throws SystemException if a system exception occurred 739 */ 740 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 741 long groupId, int start, int end, 742 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 743 throws com.liferay.portal.kernel.exception.SystemException { 744 return getPersistence() 745 .findByGroupId(groupId, start, end, orderByComparator); 746 } 747 748 /** 749 * Returns the first journal article in the ordered set where groupId = ?. 750 * 751 * @param groupId the group ID 752 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 753 * @return the first matching journal article 754 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 755 * @throws SystemException if a system exception occurred 756 */ 757 public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First( 758 long groupId, 759 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 760 throws com.liferay.portal.kernel.exception.SystemException, 761 com.liferay.portlet.journal.NoSuchArticleException { 762 return getPersistence().findByGroupId_First(groupId, orderByComparator); 763 } 764 765 /** 766 * Returns the first journal article in the ordered set where groupId = ?. 767 * 768 * @param groupId the group ID 769 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 770 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 771 * @throws SystemException if a system exception occurred 772 */ 773 public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First( 774 long groupId, 775 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 776 throws com.liferay.portal.kernel.exception.SystemException { 777 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 778 } 779 780 /** 781 * Returns the last journal article in the ordered set where groupId = ?. 782 * 783 * @param groupId the group ID 784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 785 * @return the last matching journal article 786 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 787 * @throws SystemException if a system exception occurred 788 */ 789 public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last( 790 long groupId, 791 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 792 throws com.liferay.portal.kernel.exception.SystemException, 793 com.liferay.portlet.journal.NoSuchArticleException { 794 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 795 } 796 797 /** 798 * Returns the last journal article in the ordered set where groupId = ?. 799 * 800 * @param groupId the group ID 801 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 802 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 803 * @throws SystemException if a system exception occurred 804 */ 805 public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last( 806 long groupId, 807 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 808 throws com.liferay.portal.kernel.exception.SystemException { 809 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 810 } 811 812 /** 813 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ?. 814 * 815 * @param id the primary key of the current journal article 816 * @param groupId the group ID 817 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 818 * @return the previous, current, and next journal article 819 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 820 * @throws SystemException if a system exception occurred 821 */ 822 public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext( 823 long id, long groupId, 824 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 825 throws com.liferay.portal.kernel.exception.SystemException, 826 com.liferay.portlet.journal.NoSuchArticleException { 827 return getPersistence() 828 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 829 } 830 831 /** 832 * Returns all the journal articles that the user has permission to view where groupId = ?. 833 * 834 * @param groupId the group ID 835 * @return the matching journal articles that the user has permission to view 836 * @throws SystemException if a system exception occurred 837 */ 838 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 839 long groupId) 840 throws com.liferay.portal.kernel.exception.SystemException { 841 return getPersistence().filterFindByGroupId(groupId); 842 } 843 844 /** 845 * Returns a range of all the journal articles that the user has permission to view where groupId = ?. 846 * 847 * <p> 848 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 849 * </p> 850 * 851 * @param groupId the group ID 852 * @param start the lower bound of the range of journal articles 853 * @param end the upper bound of the range of journal articles (not inclusive) 854 * @return the range of matching journal articles that the user has permission to view 855 * @throws SystemException if a system exception occurred 856 */ 857 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 858 long groupId, int start, int end) 859 throws com.liferay.portal.kernel.exception.SystemException { 860 return getPersistence().filterFindByGroupId(groupId, start, end); 861 } 862 863 /** 864 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ?. 865 * 866 * <p> 867 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 868 * </p> 869 * 870 * @param groupId the group ID 871 * @param start the lower bound of the range of journal articles 872 * @param end the upper bound of the range of journal articles (not inclusive) 873 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 874 * @return the ordered range of matching journal articles that the user has permission to view 875 * @throws SystemException if a system exception occurred 876 */ 877 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 878 long groupId, int start, int end, 879 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 880 throws com.liferay.portal.kernel.exception.SystemException { 881 return getPersistence() 882 .filterFindByGroupId(groupId, start, end, orderByComparator); 883 } 884 885 /** 886 * 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 = ?. 887 * 888 * @param id the primary key of the current journal article 889 * @param groupId the group ID 890 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 891 * @return the previous, current, and next journal article 892 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 893 * @throws SystemException if a system exception occurred 894 */ 895 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext( 896 long id, long groupId, 897 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 898 throws com.liferay.portal.kernel.exception.SystemException, 899 com.liferay.portlet.journal.NoSuchArticleException { 900 return getPersistence() 901 .filterFindByGroupId_PrevAndNext(id, groupId, 902 orderByComparator); 903 } 904 905 /** 906 * Removes all the journal articles where groupId = ? from the database. 907 * 908 * @param groupId the group ID 909 * @throws SystemException if a system exception occurred 910 */ 911 public static void removeByGroupId(long groupId) 912 throws com.liferay.portal.kernel.exception.SystemException { 913 getPersistence().removeByGroupId(groupId); 914 } 915 916 /** 917 * Returns the number of journal articles where groupId = ?. 918 * 919 * @param groupId the group ID 920 * @return the number of matching journal articles 921 * @throws SystemException if a system exception occurred 922 */ 923 public static int countByGroupId(long groupId) 924 throws com.liferay.portal.kernel.exception.SystemException { 925 return getPersistence().countByGroupId(groupId); 926 } 927 928 /** 929 * Returns the number of journal articles that the user has permission to view where groupId = ?. 930 * 931 * @param groupId the group ID 932 * @return the number of matching journal articles that the user has permission to view 933 * @throws SystemException if a system exception occurred 934 */ 935 public static int filterCountByGroupId(long groupId) 936 throws com.liferay.portal.kernel.exception.SystemException { 937 return getPersistence().filterCountByGroupId(groupId); 938 } 939 940 /** 941 * Returns all the journal articles where companyId = ?. 942 * 943 * @param companyId the company ID 944 * @return the matching journal articles 945 * @throws SystemException if a system exception occurred 946 */ 947 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 948 long companyId) 949 throws com.liferay.portal.kernel.exception.SystemException { 950 return getPersistence().findByCompanyId(companyId); 951 } 952 953 /** 954 * Returns a range of all the journal articles where companyId = ?. 955 * 956 * <p> 957 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 958 * </p> 959 * 960 * @param companyId the company ID 961 * @param start the lower bound of the range of journal articles 962 * @param end the upper bound of the range of journal articles (not inclusive) 963 * @return the range of matching journal articles 964 * @throws SystemException if a system exception occurred 965 */ 966 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 967 long companyId, int start, int end) 968 throws com.liferay.portal.kernel.exception.SystemException { 969 return getPersistence().findByCompanyId(companyId, start, end); 970 } 971 972 /** 973 * Returns an ordered range of all the journal articles where companyId = ?. 974 * 975 * <p> 976 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 977 * </p> 978 * 979 * @param companyId the company ID 980 * @param start the lower bound of the range of journal articles 981 * @param end the upper bound of the range of journal articles (not inclusive) 982 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 983 * @return the ordered range of matching journal articles 984 * @throws SystemException if a system exception occurred 985 */ 986 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 987 long companyId, int start, int end, 988 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 989 throws com.liferay.portal.kernel.exception.SystemException { 990 return getPersistence() 991 .findByCompanyId(companyId, start, end, orderByComparator); 992 } 993 994 /** 995 * Returns the first journal article in the ordered set where companyId = ?. 996 * 997 * @param companyId the company ID 998 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 999 * @return the first matching journal article 1000 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1001 * @throws SystemException if a system exception occurred 1002 */ 1003 public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First( 1004 long companyId, 1005 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1006 throws com.liferay.portal.kernel.exception.SystemException, 1007 com.liferay.portlet.journal.NoSuchArticleException { 1008 return getPersistence() 1009 .findByCompanyId_First(companyId, orderByComparator); 1010 } 1011 1012 /** 1013 * Returns the first journal article in the ordered set where companyId = ?. 1014 * 1015 * @param companyId the company ID 1016 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1017 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1018 * @throws SystemException if a system exception occurred 1019 */ 1020 public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First( 1021 long companyId, 1022 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1023 throws com.liferay.portal.kernel.exception.SystemException { 1024 return getPersistence() 1025 .fetchByCompanyId_First(companyId, orderByComparator); 1026 } 1027 1028 /** 1029 * Returns the last journal article in the ordered set where companyId = ?. 1030 * 1031 * @param companyId the company ID 1032 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1033 * @return the last matching journal article 1034 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1035 * @throws SystemException if a system exception occurred 1036 */ 1037 public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last( 1038 long companyId, 1039 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1040 throws com.liferay.portal.kernel.exception.SystemException, 1041 com.liferay.portlet.journal.NoSuchArticleException { 1042 return getPersistence() 1043 .findByCompanyId_Last(companyId, orderByComparator); 1044 } 1045 1046 /** 1047 * Returns the last journal article in the ordered set where companyId = ?. 1048 * 1049 * @param companyId the company ID 1050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1051 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1052 * @throws SystemException if a system exception occurred 1053 */ 1054 public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last( 1055 long companyId, 1056 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1057 throws com.liferay.portal.kernel.exception.SystemException { 1058 return getPersistence() 1059 .fetchByCompanyId_Last(companyId, orderByComparator); 1060 } 1061 1062 /** 1063 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ?. 1064 * 1065 * @param id the primary key of the current journal article 1066 * @param companyId the company ID 1067 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1068 * @return the previous, current, and next journal article 1069 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1070 * @throws SystemException if a system exception occurred 1071 */ 1072 public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext( 1073 long id, long companyId, 1074 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1075 throws com.liferay.portal.kernel.exception.SystemException, 1076 com.liferay.portlet.journal.NoSuchArticleException { 1077 return getPersistence() 1078 .findByCompanyId_PrevAndNext(id, companyId, orderByComparator); 1079 } 1080 1081 /** 1082 * Removes all the journal articles where companyId = ? from the database. 1083 * 1084 * @param companyId the company ID 1085 * @throws SystemException if a system exception occurred 1086 */ 1087 public static void removeByCompanyId(long companyId) 1088 throws com.liferay.portal.kernel.exception.SystemException { 1089 getPersistence().removeByCompanyId(companyId); 1090 } 1091 1092 /** 1093 * Returns the number of journal articles where companyId = ?. 1094 * 1095 * @param companyId the company ID 1096 * @return the number of matching journal articles 1097 * @throws SystemException if a system exception occurred 1098 */ 1099 public static int countByCompanyId(long companyId) 1100 throws com.liferay.portal.kernel.exception.SystemException { 1101 return getPersistence().countByCompanyId(companyId); 1102 } 1103 1104 /** 1105 * Returns all the journal articles where structureId = ?. 1106 * 1107 * @param structureId the structure ID 1108 * @return the matching journal articles 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1112 java.lang.String structureId) 1113 throws com.liferay.portal.kernel.exception.SystemException { 1114 return getPersistence().findByStructureId(structureId); 1115 } 1116 1117 /** 1118 * Returns a range of all the journal articles where structureId = ?. 1119 * 1120 * <p> 1121 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 1122 * </p> 1123 * 1124 * @param structureId the structure ID 1125 * @param start the lower bound of the range of journal articles 1126 * @param end the upper bound of the range of journal articles (not inclusive) 1127 * @return the range of matching journal articles 1128 * @throws SystemException if a system exception occurred 1129 */ 1130 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1131 java.lang.String structureId, int start, int end) 1132 throws com.liferay.portal.kernel.exception.SystemException { 1133 return getPersistence().findByStructureId(structureId, start, end); 1134 } 1135 1136 /** 1137 * Returns an ordered range of all the journal articles where structureId = ?. 1138 * 1139 * <p> 1140 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1141 * </p> 1142 * 1143 * @param structureId the structure ID 1144 * @param start the lower bound of the range of journal articles 1145 * @param end the upper bound of the range of journal articles (not inclusive) 1146 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1147 * @return the ordered range of matching journal articles 1148 * @throws SystemException if a system exception occurred 1149 */ 1150 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1151 java.lang.String structureId, int start, int end, 1152 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1153 throws com.liferay.portal.kernel.exception.SystemException { 1154 return getPersistence() 1155 .findByStructureId(structureId, start, end, orderByComparator); 1156 } 1157 1158 /** 1159 * Returns the first journal article in the ordered set where structureId = ?. 1160 * 1161 * @param structureId the structure ID 1162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1163 * @return the first matching journal article 1164 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1165 * @throws SystemException if a system exception occurred 1166 */ 1167 public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First( 1168 java.lang.String structureId, 1169 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1170 throws com.liferay.portal.kernel.exception.SystemException, 1171 com.liferay.portlet.journal.NoSuchArticleException { 1172 return getPersistence() 1173 .findByStructureId_First(structureId, orderByComparator); 1174 } 1175 1176 /** 1177 * Returns the first journal article in the ordered set where structureId = ?. 1178 * 1179 * @param structureId the structure ID 1180 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1181 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1182 * @throws SystemException if a system exception occurred 1183 */ 1184 public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First( 1185 java.lang.String structureId, 1186 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1187 throws com.liferay.portal.kernel.exception.SystemException { 1188 return getPersistence() 1189 .fetchByStructureId_First(structureId, orderByComparator); 1190 } 1191 1192 /** 1193 * Returns the last journal article in the ordered set where structureId = ?. 1194 * 1195 * @param structureId the structure ID 1196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1197 * @return the last matching journal article 1198 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1199 * @throws SystemException if a system exception occurred 1200 */ 1201 public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last( 1202 java.lang.String structureId, 1203 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1204 throws com.liferay.portal.kernel.exception.SystemException, 1205 com.liferay.portlet.journal.NoSuchArticleException { 1206 return getPersistence() 1207 .findByStructureId_Last(structureId, orderByComparator); 1208 } 1209 1210 /** 1211 * Returns the last journal article in the ordered set where structureId = ?. 1212 * 1213 * @param structureId the structure ID 1214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1215 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1216 * @throws SystemException if a system exception occurred 1217 */ 1218 public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last( 1219 java.lang.String structureId, 1220 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1221 throws com.liferay.portal.kernel.exception.SystemException { 1222 return getPersistence() 1223 .fetchByStructureId_Last(structureId, orderByComparator); 1224 } 1225 1226 /** 1227 * Returns the journal articles before and after the current journal article in the ordered set where structureId = ?. 1228 * 1229 * @param id the primary key of the current journal article 1230 * @param structureId the structure ID 1231 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1232 * @return the previous, current, and next journal article 1233 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1234 * @throws SystemException if a system exception occurred 1235 */ 1236 public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext( 1237 long id, java.lang.String structureId, 1238 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1239 throws com.liferay.portal.kernel.exception.SystemException, 1240 com.liferay.portlet.journal.NoSuchArticleException { 1241 return getPersistence() 1242 .findByStructureId_PrevAndNext(id, structureId, 1243 orderByComparator); 1244 } 1245 1246 /** 1247 * Returns all the journal articles where structureId = any ?. 1248 * 1249 * <p> 1250 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1251 * </p> 1252 * 1253 * @param structureIds the structure IDs 1254 * @return the matching journal articles 1255 * @throws SystemException if a system exception occurred 1256 */ 1257 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1258 java.lang.String[] structureIds) 1259 throws com.liferay.portal.kernel.exception.SystemException { 1260 return getPersistence().findByStructureId(structureIds); 1261 } 1262 1263 /** 1264 * Returns a range of all the journal articles where structureId = any ?. 1265 * 1266 * <p> 1267 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1268 * </p> 1269 * 1270 * @param structureIds the structure IDs 1271 * @param start the lower bound of the range of journal articles 1272 * @param end the upper bound of the range of journal articles (not inclusive) 1273 * @return the range of matching journal articles 1274 * @throws SystemException if a system exception occurred 1275 */ 1276 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1277 java.lang.String[] structureIds, int start, int end) 1278 throws com.liferay.portal.kernel.exception.SystemException { 1279 return getPersistence().findByStructureId(structureIds, start, end); 1280 } 1281 1282 /** 1283 * Returns an ordered range of all the journal articles where structureId = any ?. 1284 * 1285 * <p> 1286 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1287 * </p> 1288 * 1289 * @param structureIds the structure IDs 1290 * @param start the lower bound of the range of journal articles 1291 * @param end the upper bound of the range of journal articles (not inclusive) 1292 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1293 * @return the ordered range of matching journal articles 1294 * @throws SystemException if a system exception occurred 1295 */ 1296 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1297 java.lang.String[] structureIds, int start, int end, 1298 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1299 throws com.liferay.portal.kernel.exception.SystemException { 1300 return getPersistence() 1301 .findByStructureId(structureIds, start, end, 1302 orderByComparator); 1303 } 1304 1305 /** 1306 * Removes all the journal articles where structureId = ? from the database. 1307 * 1308 * @param structureId the structure ID 1309 * @throws SystemException if a system exception occurred 1310 */ 1311 public static void removeByStructureId(java.lang.String structureId) 1312 throws com.liferay.portal.kernel.exception.SystemException { 1313 getPersistence().removeByStructureId(structureId); 1314 } 1315 1316 /** 1317 * Returns the number of journal articles where structureId = ?. 1318 * 1319 * @param structureId the structure ID 1320 * @return the number of matching journal articles 1321 * @throws SystemException if a system exception occurred 1322 */ 1323 public static int countByStructureId(java.lang.String structureId) 1324 throws com.liferay.portal.kernel.exception.SystemException { 1325 return getPersistence().countByStructureId(structureId); 1326 } 1327 1328 /** 1329 * Returns the number of journal articles where structureId = any ?. 1330 * 1331 * @param structureIds the structure IDs 1332 * @return the number of matching journal articles 1333 * @throws SystemException if a system exception occurred 1334 */ 1335 public static int countByStructureId(java.lang.String[] structureIds) 1336 throws com.liferay.portal.kernel.exception.SystemException { 1337 return getPersistence().countByStructureId(structureIds); 1338 } 1339 1340 /** 1341 * Returns all the journal articles where templateId = ?. 1342 * 1343 * @param templateId the template ID 1344 * @return the matching journal articles 1345 * @throws SystemException if a system exception occurred 1346 */ 1347 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1348 java.lang.String templateId) 1349 throws com.liferay.portal.kernel.exception.SystemException { 1350 return getPersistence().findByTemplateId(templateId); 1351 } 1352 1353 /** 1354 * Returns a range of all the journal articles where templateId = ?. 1355 * 1356 * <p> 1357 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1358 * </p> 1359 * 1360 * @param templateId the template ID 1361 * @param start the lower bound of the range of journal articles 1362 * @param end the upper bound of the range of journal articles (not inclusive) 1363 * @return the range of matching journal articles 1364 * @throws SystemException if a system exception occurred 1365 */ 1366 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1367 java.lang.String templateId, int start, int end) 1368 throws com.liferay.portal.kernel.exception.SystemException { 1369 return getPersistence().findByTemplateId(templateId, start, end); 1370 } 1371 1372 /** 1373 * Returns an ordered range of all the journal articles where templateId = ?. 1374 * 1375 * <p> 1376 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1377 * </p> 1378 * 1379 * @param templateId the template ID 1380 * @param start the lower bound of the range of journal articles 1381 * @param end the upper bound of the range of journal articles (not inclusive) 1382 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1383 * @return the ordered range of matching journal articles 1384 * @throws SystemException if a system exception occurred 1385 */ 1386 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1387 java.lang.String templateId, int start, int end, 1388 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1389 throws com.liferay.portal.kernel.exception.SystemException { 1390 return getPersistence() 1391 .findByTemplateId(templateId, start, end, orderByComparator); 1392 } 1393 1394 /** 1395 * Returns the first journal article in the ordered set where templateId = ?. 1396 * 1397 * @param templateId the template ID 1398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1399 * @return the first matching journal article 1400 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1401 * @throws SystemException if a system exception occurred 1402 */ 1403 public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First( 1404 java.lang.String templateId, 1405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1406 throws com.liferay.portal.kernel.exception.SystemException, 1407 com.liferay.portlet.journal.NoSuchArticleException { 1408 return getPersistence() 1409 .findByTemplateId_First(templateId, orderByComparator); 1410 } 1411 1412 /** 1413 * Returns the first journal article in the ordered set where templateId = ?. 1414 * 1415 * @param templateId the template ID 1416 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1417 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1418 * @throws SystemException if a system exception occurred 1419 */ 1420 public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First( 1421 java.lang.String templateId, 1422 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1423 throws com.liferay.portal.kernel.exception.SystemException { 1424 return getPersistence() 1425 .fetchByTemplateId_First(templateId, orderByComparator); 1426 } 1427 1428 /** 1429 * Returns the last journal article in the ordered set where templateId = ?. 1430 * 1431 * @param templateId the template ID 1432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1433 * @return the last matching journal article 1434 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1435 * @throws SystemException if a system exception occurred 1436 */ 1437 public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last( 1438 java.lang.String templateId, 1439 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1440 throws com.liferay.portal.kernel.exception.SystemException, 1441 com.liferay.portlet.journal.NoSuchArticleException { 1442 return getPersistence() 1443 .findByTemplateId_Last(templateId, orderByComparator); 1444 } 1445 1446 /** 1447 * Returns the last journal article in the ordered set where templateId = ?. 1448 * 1449 * @param templateId the template ID 1450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1451 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1452 * @throws SystemException if a system exception occurred 1453 */ 1454 public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last( 1455 java.lang.String templateId, 1456 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1457 throws com.liferay.portal.kernel.exception.SystemException { 1458 return getPersistence() 1459 .fetchByTemplateId_Last(templateId, orderByComparator); 1460 } 1461 1462 /** 1463 * Returns the journal articles before and after the current journal article in the ordered set where templateId = ?. 1464 * 1465 * @param id the primary key of the current journal article 1466 * @param templateId the template ID 1467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1468 * @return the previous, current, and next journal article 1469 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1470 * @throws SystemException if a system exception occurred 1471 */ 1472 public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext( 1473 long id, java.lang.String templateId, 1474 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1475 throws com.liferay.portal.kernel.exception.SystemException, 1476 com.liferay.portlet.journal.NoSuchArticleException { 1477 return getPersistence() 1478 .findByTemplateId_PrevAndNext(id, templateId, 1479 orderByComparator); 1480 } 1481 1482 /** 1483 * Removes all the journal articles where templateId = ? from the database. 1484 * 1485 * @param templateId the template ID 1486 * @throws SystemException if a system exception occurred 1487 */ 1488 public static void removeByTemplateId(java.lang.String templateId) 1489 throws com.liferay.portal.kernel.exception.SystemException { 1490 getPersistence().removeByTemplateId(templateId); 1491 } 1492 1493 /** 1494 * Returns the number of journal articles where templateId = ?. 1495 * 1496 * @param templateId the template ID 1497 * @return the number of matching journal articles 1498 * @throws SystemException if a system exception occurred 1499 */ 1500 public static int countByTemplateId(java.lang.String templateId) 1501 throws com.liferay.portal.kernel.exception.SystemException { 1502 return getPersistence().countByTemplateId(templateId); 1503 } 1504 1505 /** 1506 * Returns all the journal articles where layoutUuid = ?. 1507 * 1508 * @param layoutUuid the layout uuid 1509 * @return the matching journal articles 1510 * @throws SystemException if a system exception occurred 1511 */ 1512 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1513 java.lang.String layoutUuid) 1514 throws com.liferay.portal.kernel.exception.SystemException { 1515 return getPersistence().findByLayoutUuid(layoutUuid); 1516 } 1517 1518 /** 1519 * Returns a range of all the journal articles where layoutUuid = ?. 1520 * 1521 * <p> 1522 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1523 * </p> 1524 * 1525 * @param layoutUuid the layout uuid 1526 * @param start the lower bound of the range of journal articles 1527 * @param end the upper bound of the range of journal articles (not inclusive) 1528 * @return the range of matching journal articles 1529 * @throws SystemException if a system exception occurred 1530 */ 1531 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1532 java.lang.String layoutUuid, int start, int end) 1533 throws com.liferay.portal.kernel.exception.SystemException { 1534 return getPersistence().findByLayoutUuid(layoutUuid, start, end); 1535 } 1536 1537 /** 1538 * Returns an ordered range of all the journal articles where layoutUuid = ?. 1539 * 1540 * <p> 1541 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1542 * </p> 1543 * 1544 * @param layoutUuid the layout uuid 1545 * @param start the lower bound of the range of journal articles 1546 * @param end the upper bound of the range of journal articles (not inclusive) 1547 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1548 * @return the ordered range of matching journal articles 1549 * @throws SystemException if a system exception occurred 1550 */ 1551 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1552 java.lang.String layoutUuid, int start, int end, 1553 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1554 throws com.liferay.portal.kernel.exception.SystemException { 1555 return getPersistence() 1556 .findByLayoutUuid(layoutUuid, start, end, orderByComparator); 1557 } 1558 1559 /** 1560 * Returns the first journal article in the ordered set where layoutUuid = ?. 1561 * 1562 * @param layoutUuid the layout uuid 1563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1564 * @return the first matching journal article 1565 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1566 * @throws SystemException if a system exception occurred 1567 */ 1568 public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First( 1569 java.lang.String layoutUuid, 1570 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1571 throws com.liferay.portal.kernel.exception.SystemException, 1572 com.liferay.portlet.journal.NoSuchArticleException { 1573 return getPersistence() 1574 .findByLayoutUuid_First(layoutUuid, orderByComparator); 1575 } 1576 1577 /** 1578 * Returns the first journal article in the ordered set where layoutUuid = ?. 1579 * 1580 * @param layoutUuid the layout uuid 1581 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1582 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1583 * @throws SystemException if a system exception occurred 1584 */ 1585 public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First( 1586 java.lang.String layoutUuid, 1587 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1588 throws com.liferay.portal.kernel.exception.SystemException { 1589 return getPersistence() 1590 .fetchByLayoutUuid_First(layoutUuid, orderByComparator); 1591 } 1592 1593 /** 1594 * Returns the last journal article in the ordered set where layoutUuid = ?. 1595 * 1596 * @param layoutUuid the layout uuid 1597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1598 * @return the last matching journal article 1599 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1600 * @throws SystemException if a system exception occurred 1601 */ 1602 public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last( 1603 java.lang.String layoutUuid, 1604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1605 throws com.liferay.portal.kernel.exception.SystemException, 1606 com.liferay.portlet.journal.NoSuchArticleException { 1607 return getPersistence() 1608 .findByLayoutUuid_Last(layoutUuid, orderByComparator); 1609 } 1610 1611 /** 1612 * Returns the last journal article in the ordered set where layoutUuid = ?. 1613 * 1614 * @param layoutUuid the layout uuid 1615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1616 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1617 * @throws SystemException if a system exception occurred 1618 */ 1619 public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last( 1620 java.lang.String layoutUuid, 1621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1622 throws com.liferay.portal.kernel.exception.SystemException { 1623 return getPersistence() 1624 .fetchByLayoutUuid_Last(layoutUuid, orderByComparator); 1625 } 1626 1627 /** 1628 * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = ?. 1629 * 1630 * @param id the primary key of the current journal article 1631 * @param layoutUuid the layout uuid 1632 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1633 * @return the previous, current, and next journal article 1634 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1635 * @throws SystemException if a system exception occurred 1636 */ 1637 public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext( 1638 long id, java.lang.String layoutUuid, 1639 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1640 throws com.liferay.portal.kernel.exception.SystemException, 1641 com.liferay.portlet.journal.NoSuchArticleException { 1642 return getPersistence() 1643 .findByLayoutUuid_PrevAndNext(id, layoutUuid, 1644 orderByComparator); 1645 } 1646 1647 /** 1648 * Removes all the journal articles where layoutUuid = ? from the database. 1649 * 1650 * @param layoutUuid the layout uuid 1651 * @throws SystemException if a system exception occurred 1652 */ 1653 public static void removeByLayoutUuid(java.lang.String layoutUuid) 1654 throws com.liferay.portal.kernel.exception.SystemException { 1655 getPersistence().removeByLayoutUuid(layoutUuid); 1656 } 1657 1658 /** 1659 * Returns the number of journal articles where layoutUuid = ?. 1660 * 1661 * @param layoutUuid the layout uuid 1662 * @return the number of matching journal articles 1663 * @throws SystemException if a system exception occurred 1664 */ 1665 public static int countByLayoutUuid(java.lang.String layoutUuid) 1666 throws com.liferay.portal.kernel.exception.SystemException { 1667 return getPersistence().countByLayoutUuid(layoutUuid); 1668 } 1669 1670 /** 1671 * Returns all the journal articles where smallImageId = ?. 1672 * 1673 * @param smallImageId the small image ID 1674 * @return the matching journal articles 1675 * @throws SystemException if a system exception occurred 1676 */ 1677 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1678 long smallImageId) 1679 throws com.liferay.portal.kernel.exception.SystemException { 1680 return getPersistence().findBySmallImageId(smallImageId); 1681 } 1682 1683 /** 1684 * Returns a range of all the journal articles where smallImageId = ?. 1685 * 1686 * <p> 1687 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1688 * </p> 1689 * 1690 * @param smallImageId the small image ID 1691 * @param start the lower bound of the range of journal articles 1692 * @param end the upper bound of the range of journal articles (not inclusive) 1693 * @return the range of matching journal articles 1694 * @throws SystemException if a system exception occurred 1695 */ 1696 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1697 long smallImageId, int start, int end) 1698 throws com.liferay.portal.kernel.exception.SystemException { 1699 return getPersistence().findBySmallImageId(smallImageId, start, end); 1700 } 1701 1702 /** 1703 * Returns an ordered range of all the journal articles where smallImageId = ?. 1704 * 1705 * <p> 1706 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1707 * </p> 1708 * 1709 * @param smallImageId the small image ID 1710 * @param start the lower bound of the range of journal articles 1711 * @param end the upper bound of the range of journal articles (not inclusive) 1712 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1713 * @return the ordered range of matching journal articles 1714 * @throws SystemException if a system exception occurred 1715 */ 1716 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1717 long smallImageId, int start, int end, 1718 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1719 throws com.liferay.portal.kernel.exception.SystemException { 1720 return getPersistence() 1721 .findBySmallImageId(smallImageId, start, end, 1722 orderByComparator); 1723 } 1724 1725 /** 1726 * Returns the first journal article in the ordered set where smallImageId = ?. 1727 * 1728 * @param smallImageId the small image ID 1729 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1730 * @return the first matching journal article 1731 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1732 * @throws SystemException if a system exception occurred 1733 */ 1734 public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First( 1735 long smallImageId, 1736 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1737 throws com.liferay.portal.kernel.exception.SystemException, 1738 com.liferay.portlet.journal.NoSuchArticleException { 1739 return getPersistence() 1740 .findBySmallImageId_First(smallImageId, orderByComparator); 1741 } 1742 1743 /** 1744 * Returns the first journal article in the ordered set where smallImageId = ?. 1745 * 1746 * @param smallImageId the small image ID 1747 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1748 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1749 * @throws SystemException if a system exception occurred 1750 */ 1751 public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First( 1752 long smallImageId, 1753 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1754 throws com.liferay.portal.kernel.exception.SystemException { 1755 return getPersistence() 1756 .fetchBySmallImageId_First(smallImageId, orderByComparator); 1757 } 1758 1759 /** 1760 * Returns the last journal article in the ordered set where smallImageId = ?. 1761 * 1762 * @param smallImageId the small image ID 1763 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1764 * @return the last matching journal article 1765 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1766 * @throws SystemException if a system exception occurred 1767 */ 1768 public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last( 1769 long smallImageId, 1770 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1771 throws com.liferay.portal.kernel.exception.SystemException, 1772 com.liferay.portlet.journal.NoSuchArticleException { 1773 return getPersistence() 1774 .findBySmallImageId_Last(smallImageId, orderByComparator); 1775 } 1776 1777 /** 1778 * Returns the last journal article in the ordered set where smallImageId = ?. 1779 * 1780 * @param smallImageId the small image ID 1781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1782 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1783 * @throws SystemException if a system exception occurred 1784 */ 1785 public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last( 1786 long smallImageId, 1787 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1788 throws com.liferay.portal.kernel.exception.SystemException { 1789 return getPersistence() 1790 .fetchBySmallImageId_Last(smallImageId, orderByComparator); 1791 } 1792 1793 /** 1794 * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = ?. 1795 * 1796 * @param id the primary key of the current journal article 1797 * @param smallImageId the small image ID 1798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1799 * @return the previous, current, and next journal article 1800 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1801 * @throws SystemException if a system exception occurred 1802 */ 1803 public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext( 1804 long id, long smallImageId, 1805 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1806 throws com.liferay.portal.kernel.exception.SystemException, 1807 com.liferay.portlet.journal.NoSuchArticleException { 1808 return getPersistence() 1809 .findBySmallImageId_PrevAndNext(id, smallImageId, 1810 orderByComparator); 1811 } 1812 1813 /** 1814 * Removes all the journal articles where smallImageId = ? from the database. 1815 * 1816 * @param smallImageId the small image ID 1817 * @throws SystemException if a system exception occurred 1818 */ 1819 public static void removeBySmallImageId(long smallImageId) 1820 throws com.liferay.portal.kernel.exception.SystemException { 1821 getPersistence().removeBySmallImageId(smallImageId); 1822 } 1823 1824 /** 1825 * Returns the number of journal articles where smallImageId = ?. 1826 * 1827 * @param smallImageId the small image ID 1828 * @return the number of matching journal articles 1829 * @throws SystemException if a system exception occurred 1830 */ 1831 public static int countBySmallImageId(long smallImageId) 1832 throws com.liferay.portal.kernel.exception.SystemException { 1833 return getPersistence().countBySmallImageId(smallImageId); 1834 } 1835 1836 /** 1837 * Returns all the journal articles where resourcePrimKey = ? and indexable = ?. 1838 * 1839 * @param resourcePrimKey the resource prim key 1840 * @param indexable the indexable 1841 * @return the matching journal articles 1842 * @throws SystemException if a system exception occurred 1843 */ 1844 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I( 1845 long resourcePrimKey, boolean indexable) 1846 throws com.liferay.portal.kernel.exception.SystemException { 1847 return getPersistence().findByR_I(resourcePrimKey, indexable); 1848 } 1849 1850 /** 1851 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ?. 1852 * 1853 * <p> 1854 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1855 * </p> 1856 * 1857 * @param resourcePrimKey the resource prim key 1858 * @param indexable the indexable 1859 * @param start the lower bound of the range of journal articles 1860 * @param end the upper bound of the range of journal articles (not inclusive) 1861 * @return the range of matching journal articles 1862 * @throws SystemException if a system exception occurred 1863 */ 1864 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I( 1865 long resourcePrimKey, boolean indexable, int start, int end) 1866 throws com.liferay.portal.kernel.exception.SystemException { 1867 return getPersistence().findByR_I(resourcePrimKey, indexable, start, end); 1868 } 1869 1870 /** 1871 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ?. 1872 * 1873 * <p> 1874 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 1875 * </p> 1876 * 1877 * @param resourcePrimKey the resource prim key 1878 * @param indexable the indexable 1879 * @param start the lower bound of the range of journal articles 1880 * @param end the upper bound of the range of journal articles (not inclusive) 1881 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1882 * @return the ordered range of matching journal articles 1883 * @throws SystemException if a system exception occurred 1884 */ 1885 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I( 1886 long resourcePrimKey, boolean indexable, int start, int end, 1887 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1888 throws com.liferay.portal.kernel.exception.SystemException { 1889 return getPersistence() 1890 .findByR_I(resourcePrimKey, indexable, start, end, 1891 orderByComparator); 1892 } 1893 1894 /** 1895 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1896 * 1897 * @param resourcePrimKey the resource prim key 1898 * @param indexable the indexable 1899 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1900 * @return the first matching journal article 1901 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1902 * @throws SystemException if a system exception occurred 1903 */ 1904 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_First( 1905 long resourcePrimKey, boolean indexable, 1906 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1907 throws com.liferay.portal.kernel.exception.SystemException, 1908 com.liferay.portlet.journal.NoSuchArticleException { 1909 return getPersistence() 1910 .findByR_I_First(resourcePrimKey, indexable, 1911 orderByComparator); 1912 } 1913 1914 /** 1915 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1916 * 1917 * @param resourcePrimKey the resource prim key 1918 * @param indexable the indexable 1919 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1920 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1921 * @throws SystemException if a system exception occurred 1922 */ 1923 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_First( 1924 long resourcePrimKey, boolean indexable, 1925 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1926 throws com.liferay.portal.kernel.exception.SystemException { 1927 return getPersistence() 1928 .fetchByR_I_First(resourcePrimKey, indexable, 1929 orderByComparator); 1930 } 1931 1932 /** 1933 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1934 * 1935 * @param resourcePrimKey the resource prim key 1936 * @param indexable the indexable 1937 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1938 * @return the last matching journal article 1939 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1940 * @throws SystemException if a system exception occurred 1941 */ 1942 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_Last( 1943 long resourcePrimKey, boolean indexable, 1944 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1945 throws com.liferay.portal.kernel.exception.SystemException, 1946 com.liferay.portlet.journal.NoSuchArticleException { 1947 return getPersistence() 1948 .findByR_I_Last(resourcePrimKey, indexable, orderByComparator); 1949 } 1950 1951 /** 1952 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1953 * 1954 * @param resourcePrimKey the resource prim key 1955 * @param indexable the indexable 1956 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1957 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1958 * @throws SystemException if a system exception occurred 1959 */ 1960 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_Last( 1961 long resourcePrimKey, boolean indexable, 1962 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1963 throws com.liferay.portal.kernel.exception.SystemException { 1964 return getPersistence() 1965 .fetchByR_I_Last(resourcePrimKey, indexable, 1966 orderByComparator); 1967 } 1968 1969 /** 1970 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1971 * 1972 * @param id the primary key of the current journal article 1973 * @param resourcePrimKey the resource prim key 1974 * @param indexable the indexable 1975 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1976 * @return the previous, current, and next journal article 1977 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1978 * @throws SystemException if a system exception occurred 1979 */ 1980 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_PrevAndNext( 1981 long id, long resourcePrimKey, boolean indexable, 1982 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1983 throws com.liferay.portal.kernel.exception.SystemException, 1984 com.liferay.portlet.journal.NoSuchArticleException { 1985 return getPersistence() 1986 .findByR_I_PrevAndNext(id, resourcePrimKey, indexable, 1987 orderByComparator); 1988 } 1989 1990 /** 1991 * Removes all the journal articles where resourcePrimKey = ? and indexable = ? from the database. 1992 * 1993 * @param resourcePrimKey the resource prim key 1994 * @param indexable the indexable 1995 * @throws SystemException if a system exception occurred 1996 */ 1997 public static void removeByR_I(long resourcePrimKey, boolean indexable) 1998 throws com.liferay.portal.kernel.exception.SystemException { 1999 getPersistence().removeByR_I(resourcePrimKey, indexable); 2000 } 2001 2002 /** 2003 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ?. 2004 * 2005 * @param resourcePrimKey the resource prim key 2006 * @param indexable the indexable 2007 * @return the number of matching journal articles 2008 * @throws SystemException if a system exception occurred 2009 */ 2010 public static int countByR_I(long resourcePrimKey, boolean indexable) 2011 throws com.liferay.portal.kernel.exception.SystemException { 2012 return getPersistence().countByR_I(resourcePrimKey, indexable); 2013 } 2014 2015 /** 2016 * Returns all the journal articles where resourcePrimKey = ? and status = ?. 2017 * 2018 * @param resourcePrimKey the resource prim key 2019 * @param status the status 2020 * @return the matching journal articles 2021 * @throws SystemException if a system exception occurred 2022 */ 2023 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2024 long resourcePrimKey, int status) 2025 throws com.liferay.portal.kernel.exception.SystemException { 2026 return getPersistence().findByR_ST(resourcePrimKey, status); 2027 } 2028 2029 /** 2030 * Returns a range of all the journal articles where resourcePrimKey = ? and status = ?. 2031 * 2032 * <p> 2033 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2034 * </p> 2035 * 2036 * @param resourcePrimKey the resource prim key 2037 * @param status the status 2038 * @param start the lower bound of the range of journal articles 2039 * @param end the upper bound of the range of journal articles (not inclusive) 2040 * @return the range of matching journal articles 2041 * @throws SystemException if a system exception occurred 2042 */ 2043 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2044 long resourcePrimKey, int status, int start, int end) 2045 throws com.liferay.portal.kernel.exception.SystemException { 2046 return getPersistence().findByR_ST(resourcePrimKey, status, start, end); 2047 } 2048 2049 /** 2050 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and status = ?. 2051 * 2052 * <p> 2053 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2054 * </p> 2055 * 2056 * @param resourcePrimKey the resource prim key 2057 * @param status the status 2058 * @param start the lower bound of the range of journal articles 2059 * @param end the upper bound of the range of journal articles (not inclusive) 2060 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2061 * @return the ordered range of matching journal articles 2062 * @throws SystemException if a system exception occurred 2063 */ 2064 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2065 long resourcePrimKey, int status, int start, int end, 2066 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2067 throws com.liferay.portal.kernel.exception.SystemException { 2068 return getPersistence() 2069 .findByR_ST(resourcePrimKey, status, start, end, 2070 orderByComparator); 2071 } 2072 2073 /** 2074 * Returns the first journal article in the ordered set where resourcePrimKey = ? and status = ?. 2075 * 2076 * @param resourcePrimKey the resource prim key 2077 * @param status the status 2078 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2079 * @return the first matching journal article 2080 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2081 * @throws SystemException if a system exception occurred 2082 */ 2083 public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First( 2084 long resourcePrimKey, int status, 2085 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2086 throws com.liferay.portal.kernel.exception.SystemException, 2087 com.liferay.portlet.journal.NoSuchArticleException { 2088 return getPersistence() 2089 .findByR_ST_First(resourcePrimKey, status, orderByComparator); 2090 } 2091 2092 /** 2093 * Returns the first journal article in the ordered set where resourcePrimKey = ? and status = ?. 2094 * 2095 * @param resourcePrimKey the resource prim key 2096 * @param status the status 2097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2098 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2099 * @throws SystemException if a system exception occurred 2100 */ 2101 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First( 2102 long resourcePrimKey, int status, 2103 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2104 throws com.liferay.portal.kernel.exception.SystemException { 2105 return getPersistence() 2106 .fetchByR_ST_First(resourcePrimKey, status, orderByComparator); 2107 } 2108 2109 /** 2110 * Returns the last journal article in the ordered set where resourcePrimKey = ? and status = ?. 2111 * 2112 * @param resourcePrimKey the resource prim key 2113 * @param status the status 2114 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2115 * @return the last matching journal article 2116 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2117 * @throws SystemException if a system exception occurred 2118 */ 2119 public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last( 2120 long resourcePrimKey, int status, 2121 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2122 throws com.liferay.portal.kernel.exception.SystemException, 2123 com.liferay.portlet.journal.NoSuchArticleException { 2124 return getPersistence() 2125 .findByR_ST_Last(resourcePrimKey, status, orderByComparator); 2126 } 2127 2128 /** 2129 * Returns the last journal article in the ordered set where resourcePrimKey = ? and status = ?. 2130 * 2131 * @param resourcePrimKey the resource prim key 2132 * @param status the status 2133 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2134 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2135 * @throws SystemException if a system exception occurred 2136 */ 2137 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last( 2138 long resourcePrimKey, int status, 2139 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2140 throws com.liferay.portal.kernel.exception.SystemException { 2141 return getPersistence() 2142 .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator); 2143 } 2144 2145 /** 2146 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and status = ?. 2147 * 2148 * @param id the primary key of the current journal article 2149 * @param resourcePrimKey the resource prim key 2150 * @param status the status 2151 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2152 * @return the previous, current, and next journal article 2153 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2154 * @throws SystemException if a system exception occurred 2155 */ 2156 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext( 2157 long id, long resourcePrimKey, int status, 2158 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2159 throws com.liferay.portal.kernel.exception.SystemException, 2160 com.liferay.portlet.journal.NoSuchArticleException { 2161 return getPersistence() 2162 .findByR_ST_PrevAndNext(id, resourcePrimKey, status, 2163 orderByComparator); 2164 } 2165 2166 /** 2167 * Returns all the journal articles where resourcePrimKey = ? and status = any ?. 2168 * 2169 * <p> 2170 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 2171 * </p> 2172 * 2173 * @param resourcePrimKey the resource prim key 2174 * @param statuses the statuses 2175 * @return the matching journal articles 2176 * @throws SystemException if a system exception occurred 2177 */ 2178 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2179 long resourcePrimKey, int[] statuses) 2180 throws com.liferay.portal.kernel.exception.SystemException { 2181 return getPersistence().findByR_ST(resourcePrimKey, statuses); 2182 } 2183 2184 /** 2185 * Returns a range of all the journal articles where resourcePrimKey = ? and status = any ?. 2186 * 2187 * <p> 2188 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2189 * </p> 2190 * 2191 * @param resourcePrimKey the resource prim key 2192 * @param statuses the statuses 2193 * @param start the lower bound of the range of journal articles 2194 * @param end the upper bound of the range of journal articles (not inclusive) 2195 * @return the range of matching journal articles 2196 * @throws SystemException if a system exception occurred 2197 */ 2198 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2199 long resourcePrimKey, int[] statuses, int start, int end) 2200 throws com.liferay.portal.kernel.exception.SystemException { 2201 return getPersistence().findByR_ST(resourcePrimKey, statuses, start, end); 2202 } 2203 2204 /** 2205 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and status = any ?. 2206 * 2207 * <p> 2208 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2209 * </p> 2210 * 2211 * @param resourcePrimKey the resource prim key 2212 * @param statuses the statuses 2213 * @param start the lower bound of the range of journal articles 2214 * @param end the upper bound of the range of journal articles (not inclusive) 2215 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2216 * @return the ordered range of matching journal articles 2217 * @throws SystemException if a system exception occurred 2218 */ 2219 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2220 long resourcePrimKey, int[] statuses, int start, int end, 2221 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2222 throws com.liferay.portal.kernel.exception.SystemException { 2223 return getPersistence() 2224 .findByR_ST(resourcePrimKey, statuses, start, end, 2225 orderByComparator); 2226 } 2227 2228 /** 2229 * Removes all the journal articles where resourcePrimKey = ? and status = ? from the database. 2230 * 2231 * @param resourcePrimKey the resource prim key 2232 * @param status the status 2233 * @throws SystemException if a system exception occurred 2234 */ 2235 public static void removeByR_ST(long resourcePrimKey, int status) 2236 throws com.liferay.portal.kernel.exception.SystemException { 2237 getPersistence().removeByR_ST(resourcePrimKey, status); 2238 } 2239 2240 /** 2241 * Returns the number of journal articles where resourcePrimKey = ? and status = ?. 2242 * 2243 * @param resourcePrimKey the resource prim key 2244 * @param status the status 2245 * @return the number of matching journal articles 2246 * @throws SystemException if a system exception occurred 2247 */ 2248 public static int countByR_ST(long resourcePrimKey, int status) 2249 throws com.liferay.portal.kernel.exception.SystemException { 2250 return getPersistence().countByR_ST(resourcePrimKey, status); 2251 } 2252 2253 /** 2254 * Returns the number of journal articles where resourcePrimKey = ? and status = any ?. 2255 * 2256 * @param resourcePrimKey the resource prim key 2257 * @param statuses the statuses 2258 * @return the number of matching journal articles 2259 * @throws SystemException if a system exception occurred 2260 */ 2261 public static int countByR_ST(long resourcePrimKey, int[] statuses) 2262 throws com.liferay.portal.kernel.exception.SystemException { 2263 return getPersistence().countByR_ST(resourcePrimKey, statuses); 2264 } 2265 2266 /** 2267 * Returns all the journal articles where groupId = ? and userId = ?. 2268 * 2269 * @param groupId the group ID 2270 * @param userId the user ID 2271 * @return the matching journal articles 2272 * @throws SystemException if a system exception occurred 2273 */ 2274 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2275 long groupId, long userId) 2276 throws com.liferay.portal.kernel.exception.SystemException { 2277 return getPersistence().findByG_U(groupId, userId); 2278 } 2279 2280 /** 2281 * Returns a range of all the journal articles where groupId = ? and userId = ?. 2282 * 2283 * <p> 2284 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2285 * </p> 2286 * 2287 * @param groupId the group ID 2288 * @param userId the user ID 2289 * @param start the lower bound of the range of journal articles 2290 * @param end the upper bound of the range of journal articles (not inclusive) 2291 * @return the range of matching journal articles 2292 * @throws SystemException if a system exception occurred 2293 */ 2294 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2295 long groupId, long userId, int start, int end) 2296 throws com.liferay.portal.kernel.exception.SystemException { 2297 return getPersistence().findByG_U(groupId, userId, start, end); 2298 } 2299 2300 /** 2301 * Returns an ordered range of all the journal articles where groupId = ? and userId = ?. 2302 * 2303 * <p> 2304 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 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. 2305 * </p> 2306 * 2307 * @param groupId the group ID 2308 * @param userId the user ID 2309 * @param start the lower bound of the range of journal articles 2310 * @param end the upper bound of the range of journal articles (not inclusive) 2311 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2312 * @return the ordered range of matching journal articles 2313 * @throws SystemException if a system exception occurred 2314 */ 2315 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2316 long groupId, long userId, int start, int end, 2317 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2318 throws com.liferay.portal.kernel.exception.SystemException { 2319 return getPersistence() 2320 .findByG_U(groupId, userId, start, end, orderByComparator); 2321 } 2322 2323 /** 2324 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2325 * 2326 * @param groupId the group ID 2327 * @param userId the user ID 2328 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2329 * @return the first matching journal article 2330 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2331 * @throws SystemException if a system exception occurred 2332 */ 2333 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First( 2334 long groupId, long userId, 2335 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2336 throws com.liferay.portal.kernel.exception.SystemException, 2337 com.liferay.portlet.journal.NoSuchArticleException { 2338 return getPersistence() 2339 .findByG_U_First(groupId, userId, orderByComparator); 2340 } 2341 2342 /** 2343 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2344 * 2345 * @param groupId the group ID 2346 * @param userId the user ID 2347 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2348 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2349 * @throws SystemException if a system exception occurred 2350 */ 2351 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First( 2352 long groupId, long userId, 2353 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2354 throws com.liferay.portal.kernel.exception.SystemException { 2355 return getPersistence() 2356 .fetchByG_U_First(groupId, userId, orderByComparator); 2357 } 2358 2359 /** 2360 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2361 * 2362 * @param groupId the group ID 2363 * @param userId the user ID 2364 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2365 * @return the last matching journal article 2366 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2367 * @throws SystemException if a system exception occurred 2368 */ 2369 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last( 2370 long groupId, long userId, 2371 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2372 throws com.liferay.portal.kernel.exception.SystemException, 2373 com.liferay.portlet.journal.NoSuchArticleException { 2374 return getPersistence() 2375 .findByG_U_Last(groupId, userId, orderByComparator); 2376 } 2377 2378 /** 2379 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2380 * 2381 * @param groupId the group ID 2382 * @param userId the user ID 2383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2384 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2385 * @throws SystemException if a system exception occurred 2386 */ 2387 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last( 2388 long groupId, long userId, 2389 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2390 throws com.liferay.portal.kernel.exception.SystemException { 2391 return getPersistence() 2392 .fetchByG_U_Last(groupId, userId, orderByComparator); 2393 } 2394 2395 /** 2396 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ?. 2397 * 2398 * @param id the primary key of the current journal article 2399 * @param groupId the group ID 2400 * @param userId the user ID 2401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2402 * @return the previous, current, and next journal article 2403 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2404 * @throws SystemException if a system exception occurred 2405 */ 2406 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext( 2407 long id, long groupId, long userId, 2408 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2409 throws com.liferay.portal.kernel.exception.SystemException, 2410 com.liferay.portlet.journal.NoSuchArticleException { 2411 return getPersistence() 2412 .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator); 2413 } 2414 2415 /** 2416 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2417 * 2418 * @param groupId the group ID 2419 * @param userId the user ID 2420 * @return the matching journal articles that the user has permission to view 2421 * @throws SystemException if a system exception occurred 2422 */ 2423 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2424 long groupId, long userId) 2425 throws com.liferay.portal.kernel.exception.SystemException { 2426 return getPersistence().filterFindByG_U(groupId, userId); 2427 } 2428 2429 /** 2430 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2431 * 2432 * <p> 2433 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2434 * </p> 2435 * 2436 * @param groupId the group ID 2437 * @param userId the user ID 2438 * @param start the lower bound of the range of journal articles 2439 * @param end the upper bound of the range of journal articles (not inclusive) 2440 * @return the range of matching journal articles that the user has permission to view 2441 * @throws SystemException if a system exception occurred 2442 */ 2443 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2444 long groupId, long userId, int start, int end) 2445 throws com.liferay.portal.kernel.exception.SystemException { 2446 return getPersistence().filterFindByG_U(groupId, userId, start, end); 2447 } 2448 2449 /** 2450 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ?. 2451 * 2452 * <p> 2453 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2454 * </p> 2455 * 2456 * @param groupId the group ID 2457 * @param userId the user ID 2458 * @param start the lower bound of the range of journal articles 2459 * @param end the upper bound of the range of journal articles (not inclusive) 2460 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2461 * @return the ordered range of matching journal articles that the user has permission to view 2462 * @throws SystemException if a system exception occurred 2463 */ 2464 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2465 long groupId, long userId, int start, int end, 2466 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2467 throws com.liferay.portal.kernel.exception.SystemException { 2468 return getPersistence() 2469 .filterFindByG_U(groupId, userId, start, end, 2470 orderByComparator); 2471 } 2472 2473 /** 2474 * 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 = ?. 2475 * 2476 * @param id the primary key of the current journal article 2477 * @param groupId the group ID 2478 * @param userId the user ID 2479 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2480 * @return the previous, current, and next journal article 2481 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2482 * @throws SystemException if a system exception occurred 2483 */ 2484 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext( 2485 long id, long groupId, long userId, 2486 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2487 throws com.liferay.portal.kernel.exception.SystemException, 2488 com.liferay.portlet.journal.NoSuchArticleException { 2489 return getPersistence() 2490 .filterFindByG_U_PrevAndNext(id, groupId, userId, 2491 orderByComparator); 2492 } 2493 2494 /** 2495 * Removes all the journal articles where groupId = ? and userId = ? from the database. 2496 * 2497 * @param groupId the group ID 2498 * @param userId the user ID 2499 * @throws SystemException if a system exception occurred 2500 */ 2501 public static void removeByG_U(long groupId, long userId) 2502 throws com.liferay.portal.kernel.exception.SystemException { 2503 getPersistence().removeByG_U(groupId, userId); 2504 } 2505 2506 /** 2507 * Returns the number of journal articles where groupId = ? and userId = ?. 2508 * 2509 * @param groupId the group ID 2510 * @param userId the user ID 2511 * @return the number of matching journal articles 2512 * @throws SystemException if a system exception occurred 2513 */ 2514 public static int countByG_U(long groupId, long userId) 2515 throws com.liferay.portal.kernel.exception.SystemException { 2516 return getPersistence().countByG_U(groupId, userId); 2517 } 2518 2519 /** 2520 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ?. 2521 * 2522 * @param groupId the group ID 2523 * @param userId the user ID 2524 * @return the number of matching journal articles that the user has permission to view 2525 * @throws SystemException if a system exception occurred 2526 */ 2527 public static int filterCountByG_U(long groupId, long userId) 2528 throws com.liferay.portal.kernel.exception.SystemException { 2529 return getPersistence().filterCountByG_U(groupId, userId); 2530 } 2531 2532 /** 2533 * Returns all the journal articles where groupId = ? and folderId = ?. 2534 * 2535 * @param groupId the group ID 2536 * @param folderId the folder ID 2537 * @return the matching journal articles 2538 * @throws SystemException if a system exception occurred 2539 */ 2540 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2541 long groupId, long folderId) 2542 throws com.liferay.portal.kernel.exception.SystemException { 2543 return getPersistence().findByG_F(groupId, folderId); 2544 } 2545 2546 /** 2547 * Returns a range of all the journal articles where groupId = ? and folderId = ?. 2548 * 2549 * <p> 2550 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2551 * </p> 2552 * 2553 * @param groupId the group ID 2554 * @param folderId the folder ID 2555 * @param start the lower bound of the range of journal articles 2556 * @param end the upper bound of the range of journal articles (not inclusive) 2557 * @return the range of matching journal articles 2558 * @throws SystemException if a system exception occurred 2559 */ 2560 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2561 long groupId, long folderId, int start, int end) 2562 throws com.liferay.portal.kernel.exception.SystemException { 2563 return getPersistence().findByG_F(groupId, folderId, start, end); 2564 } 2565 2566 /** 2567 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ?. 2568 * 2569 * <p> 2570 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2571 * </p> 2572 * 2573 * @param groupId the group ID 2574 * @param folderId the folder ID 2575 * @param start the lower bound of the range of journal articles 2576 * @param end the upper bound of the range of journal articles (not inclusive) 2577 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2578 * @return the ordered range of matching journal articles 2579 * @throws SystemException if a system exception occurred 2580 */ 2581 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2582 long groupId, long folderId, int start, int end, 2583 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2584 throws com.liferay.portal.kernel.exception.SystemException { 2585 return getPersistence() 2586 .findByG_F(groupId, folderId, start, end, orderByComparator); 2587 } 2588 2589 /** 2590 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2591 * 2592 * @param groupId the group ID 2593 * @param folderId the folder ID 2594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2595 * @return the first matching journal article 2596 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2597 * @throws SystemException if a system exception occurred 2598 */ 2599 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First( 2600 long groupId, long folderId, 2601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2602 throws com.liferay.portal.kernel.exception.SystemException, 2603 com.liferay.portlet.journal.NoSuchArticleException { 2604 return getPersistence() 2605 .findByG_F_First(groupId, folderId, orderByComparator); 2606 } 2607 2608 /** 2609 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2610 * 2611 * @param groupId the group ID 2612 * @param folderId the folder ID 2613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2614 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2615 * @throws SystemException if a system exception occurred 2616 */ 2617 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First( 2618 long groupId, long folderId, 2619 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2620 throws com.liferay.portal.kernel.exception.SystemException { 2621 return getPersistence() 2622 .fetchByG_F_First(groupId, folderId, orderByComparator); 2623 } 2624 2625 /** 2626 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2627 * 2628 * @param groupId the group ID 2629 * @param folderId the folder ID 2630 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2631 * @return the last matching journal article 2632 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2633 * @throws SystemException if a system exception occurred 2634 */ 2635 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last( 2636 long groupId, long folderId, 2637 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2638 throws com.liferay.portal.kernel.exception.SystemException, 2639 com.liferay.portlet.journal.NoSuchArticleException { 2640 return getPersistence() 2641 .findByG_F_Last(groupId, folderId, orderByComparator); 2642 } 2643 2644 /** 2645 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2646 * 2647 * @param groupId the group ID 2648 * @param folderId the folder ID 2649 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2650 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2651 * @throws SystemException if a system exception occurred 2652 */ 2653 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last( 2654 long groupId, long folderId, 2655 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2656 throws com.liferay.portal.kernel.exception.SystemException { 2657 return getPersistence() 2658 .fetchByG_F_Last(groupId, folderId, orderByComparator); 2659 } 2660 2661 /** 2662 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ?. 2663 * 2664 * @param id the primary key of the current journal article 2665 * @param groupId the group ID 2666 * @param folderId the folder ID 2667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2668 * @return the previous, current, and next journal article 2669 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2670 * @throws SystemException if a system exception occurred 2671 */ 2672 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext( 2673 long id, long groupId, long folderId, 2674 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2675 throws com.liferay.portal.kernel.exception.SystemException, 2676 com.liferay.portlet.journal.NoSuchArticleException { 2677 return getPersistence() 2678 .findByG_F_PrevAndNext(id, groupId, folderId, 2679 orderByComparator); 2680 } 2681 2682 /** 2683 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2684 * 2685 * @param groupId the group ID 2686 * @param folderId the folder ID 2687 * @return the matching journal articles that the user has permission to view 2688 * @throws SystemException if a system exception occurred 2689 */ 2690 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2691 long groupId, long folderId) 2692 throws com.liferay.portal.kernel.exception.SystemException { 2693 return getPersistence().filterFindByG_F(groupId, folderId); 2694 } 2695 2696 /** 2697 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2698 * 2699 * <p> 2700 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2701 * </p> 2702 * 2703 * @param groupId the group ID 2704 * @param folderId the folder ID 2705 * @param start the lower bound of the range of journal articles 2706 * @param end the upper bound of the range of journal articles (not inclusive) 2707 * @return the range of matching journal articles that the user has permission to view 2708 * @throws SystemException if a system exception occurred 2709 */ 2710 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2711 long groupId, long folderId, int start, int end) 2712 throws com.liferay.portal.kernel.exception.SystemException { 2713 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 2714 } 2715 2716 /** 2717 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ?. 2718 * 2719 * <p> 2720 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2721 * </p> 2722 * 2723 * @param groupId the group ID 2724 * @param folderId the folder ID 2725 * @param start the lower bound of the range of journal articles 2726 * @param end the upper bound of the range of journal articles (not inclusive) 2727 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2728 * @return the ordered range of matching journal articles that the user has permission to view 2729 * @throws SystemException if a system exception occurred 2730 */ 2731 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2732 long groupId, long folderId, int start, int end, 2733 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2734 throws com.liferay.portal.kernel.exception.SystemException { 2735 return getPersistence() 2736 .filterFindByG_F(groupId, folderId, start, end, 2737 orderByComparator); 2738 } 2739 2740 /** 2741 * 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 = ?. 2742 * 2743 * @param id the primary key of the current journal article 2744 * @param groupId the group ID 2745 * @param folderId the folder ID 2746 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2747 * @return the previous, current, and next journal article 2748 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2749 * @throws SystemException if a system exception occurred 2750 */ 2751 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext( 2752 long id, long groupId, long folderId, 2753 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2754 throws com.liferay.portal.kernel.exception.SystemException, 2755 com.liferay.portlet.journal.NoSuchArticleException { 2756 return getPersistence() 2757 .filterFindByG_F_PrevAndNext(id, groupId, folderId, 2758 orderByComparator); 2759 } 2760 2761 /** 2762 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2763 * 2764 * @param groupId the group ID 2765 * @param folderIds the folder IDs 2766 * @return the matching journal articles that the user has permission to view 2767 * @throws SystemException if a system exception occurred 2768 */ 2769 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2770 long groupId, long[] folderIds) 2771 throws com.liferay.portal.kernel.exception.SystemException { 2772 return getPersistence().filterFindByG_F(groupId, folderIds); 2773 } 2774 2775 /** 2776 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2777 * 2778 * <p> 2779 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2780 * </p> 2781 * 2782 * @param groupId the group ID 2783 * @param folderIds the folder IDs 2784 * @param start the lower bound of the range of journal articles 2785 * @param end the upper bound of the range of journal articles (not inclusive) 2786 * @return the range of matching journal articles that the user has permission to view 2787 * @throws SystemException if a system exception occurred 2788 */ 2789 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2790 long groupId, long[] folderIds, int start, int end) 2791 throws com.liferay.portal.kernel.exception.SystemException { 2792 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 2793 } 2794 2795 /** 2796 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2797 * 2798 * <p> 2799 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2800 * </p> 2801 * 2802 * @param groupId the group ID 2803 * @param folderIds the folder IDs 2804 * @param start the lower bound of the range of journal articles 2805 * @param end the upper bound of the range of journal articles (not inclusive) 2806 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2807 * @return the ordered range of matching journal articles that the user has permission to view 2808 * @throws SystemException if a system exception occurred 2809 */ 2810 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2811 long groupId, long[] folderIds, int start, int end, 2812 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2813 throws com.liferay.portal.kernel.exception.SystemException { 2814 return getPersistence() 2815 .filterFindByG_F(groupId, folderIds, start, end, 2816 orderByComparator); 2817 } 2818 2819 /** 2820 * Returns all the journal articles where groupId = ? and folderId = any ?. 2821 * 2822 * <p> 2823 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2824 * </p> 2825 * 2826 * @param groupId the group ID 2827 * @param folderIds the folder IDs 2828 * @return the matching journal articles 2829 * @throws SystemException if a system exception occurred 2830 */ 2831 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2832 long groupId, long[] folderIds) 2833 throws com.liferay.portal.kernel.exception.SystemException { 2834 return getPersistence().findByG_F(groupId, folderIds); 2835 } 2836 2837 /** 2838 * Returns a range of all the journal articles where groupId = ? and folderId = any ?. 2839 * 2840 * <p> 2841 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2842 * </p> 2843 * 2844 * @param groupId the group ID 2845 * @param folderIds the folder IDs 2846 * @param start the lower bound of the range of journal articles 2847 * @param end the upper bound of the range of journal articles (not inclusive) 2848 * @return the range of matching journal articles 2849 * @throws SystemException if a system exception occurred 2850 */ 2851 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2852 long groupId, long[] folderIds, int start, int end) 2853 throws com.liferay.portal.kernel.exception.SystemException { 2854 return getPersistence().findByG_F(groupId, folderIds, start, end); 2855 } 2856 2857 /** 2858 * Returns an ordered range of all the journal articles where groupId = ? and folderId = any ?. 2859 * 2860 * <p> 2861 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2862 * </p> 2863 * 2864 * @param groupId the group ID 2865 * @param folderIds the folder IDs 2866 * @param start the lower bound of the range of journal articles 2867 * @param end the upper bound of the range of journal articles (not inclusive) 2868 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2869 * @return the ordered range of matching journal articles 2870 * @throws SystemException if a system exception occurred 2871 */ 2872 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2873 long groupId, long[] folderIds, int start, int end, 2874 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2875 throws com.liferay.portal.kernel.exception.SystemException { 2876 return getPersistence() 2877 .findByG_F(groupId, folderIds, start, end, orderByComparator); 2878 } 2879 2880 /** 2881 * Removes all the journal articles where groupId = ? and folderId = ? from the database. 2882 * 2883 * @param groupId the group ID 2884 * @param folderId the folder ID 2885 * @throws SystemException if a system exception occurred 2886 */ 2887 public static void removeByG_F(long groupId, long folderId) 2888 throws com.liferay.portal.kernel.exception.SystemException { 2889 getPersistence().removeByG_F(groupId, folderId); 2890 } 2891 2892 /** 2893 * Returns the number of journal articles where groupId = ? and folderId = ?. 2894 * 2895 * @param groupId the group ID 2896 * @param folderId the folder ID 2897 * @return the number of matching journal articles 2898 * @throws SystemException if a system exception occurred 2899 */ 2900 public static int countByG_F(long groupId, long folderId) 2901 throws com.liferay.portal.kernel.exception.SystemException { 2902 return getPersistence().countByG_F(groupId, folderId); 2903 } 2904 2905 /** 2906 * Returns the number of journal articles where groupId = ? and folderId = any ?. 2907 * 2908 * @param groupId the group ID 2909 * @param folderIds the folder IDs 2910 * @return the number of matching journal articles 2911 * @throws SystemException if a system exception occurred 2912 */ 2913 public static int countByG_F(long groupId, long[] folderIds) 2914 throws com.liferay.portal.kernel.exception.SystemException { 2915 return getPersistence().countByG_F(groupId, folderIds); 2916 } 2917 2918 /** 2919 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ?. 2920 * 2921 * @param groupId the group ID 2922 * @param folderId the folder ID 2923 * @return the number of matching journal articles that the user has permission to view 2924 * @throws SystemException if a system exception occurred 2925 */ 2926 public static int filterCountByG_F(long groupId, long folderId) 2927 throws com.liferay.portal.kernel.exception.SystemException { 2928 return getPersistence().filterCountByG_F(groupId, folderId); 2929 } 2930 2931 /** 2932 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2933 * 2934 * @param groupId the group ID 2935 * @param folderIds the folder IDs 2936 * @return the number of matching journal articles that the user has permission to view 2937 * @throws SystemException if a system exception occurred 2938 */ 2939 public static int filterCountByG_F(long groupId, long[] folderIds) 2940 throws com.liferay.portal.kernel.exception.SystemException { 2941 return getPersistence().filterCountByG_F(groupId, folderIds); 2942 } 2943 2944 /** 2945 * Returns all the journal articles where groupId = ? and articleId = ?. 2946 * 2947 * @param groupId the group ID 2948 * @param articleId the article ID 2949 * @return the matching journal articles 2950 * @throws SystemException if a system exception occurred 2951 */ 2952 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2953 long groupId, java.lang.String articleId) 2954 throws com.liferay.portal.kernel.exception.SystemException { 2955 return getPersistence().findByG_A(groupId, articleId); 2956 } 2957 2958 /** 2959 * Returns a range of all the journal articles where groupId = ? and articleId = ?. 2960 * 2961 * <p> 2962 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2963 * </p> 2964 * 2965 * @param groupId the group ID 2966 * @param articleId the article ID 2967 * @param start the lower bound of the range of journal articles 2968 * @param end the upper bound of the range of journal articles (not inclusive) 2969 * @return the range of matching journal articles 2970 * @throws SystemException if a system exception occurred 2971 */ 2972 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2973 long groupId, java.lang.String articleId, int start, int end) 2974 throws com.liferay.portal.kernel.exception.SystemException { 2975 return getPersistence().findByG_A(groupId, articleId, start, end); 2976 } 2977 2978 /** 2979 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ?. 2980 * 2981 * <p> 2982 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2983 * </p> 2984 * 2985 * @param groupId the group ID 2986 * @param articleId the article ID 2987 * @param start the lower bound of the range of journal articles 2988 * @param end the upper bound of the range of journal articles (not inclusive) 2989 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2990 * @return the ordered range of matching journal articles 2991 * @throws SystemException if a system exception occurred 2992 */ 2993 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2994 long groupId, java.lang.String articleId, int start, int end, 2995 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2996 throws com.liferay.portal.kernel.exception.SystemException { 2997 return getPersistence() 2998 .findByG_A(groupId, articleId, start, end, orderByComparator); 2999 } 3000 3001 /** 3002 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 3003 * 3004 * @param groupId the group ID 3005 * @param articleId the article ID 3006 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3007 * @return the first matching journal article 3008 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3009 * @throws SystemException if a system exception occurred 3010 */ 3011 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First( 3012 long groupId, java.lang.String articleId, 3013 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3014 throws com.liferay.portal.kernel.exception.SystemException, 3015 com.liferay.portlet.journal.NoSuchArticleException { 3016 return getPersistence() 3017 .findByG_A_First(groupId, articleId, orderByComparator); 3018 } 3019 3020 /** 3021 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 3022 * 3023 * @param groupId the group ID 3024 * @param articleId the article ID 3025 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3026 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3027 * @throws SystemException if a system exception occurred 3028 */ 3029 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First( 3030 long groupId, java.lang.String articleId, 3031 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3032 throws com.liferay.portal.kernel.exception.SystemException { 3033 return getPersistence() 3034 .fetchByG_A_First(groupId, articleId, orderByComparator); 3035 } 3036 3037 /** 3038 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 3039 * 3040 * @param groupId the group ID 3041 * @param articleId the article ID 3042 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3043 * @return the last matching journal article 3044 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3045 * @throws SystemException if a system exception occurred 3046 */ 3047 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last( 3048 long groupId, java.lang.String articleId, 3049 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3050 throws com.liferay.portal.kernel.exception.SystemException, 3051 com.liferay.portlet.journal.NoSuchArticleException { 3052 return getPersistence() 3053 .findByG_A_Last(groupId, articleId, orderByComparator); 3054 } 3055 3056 /** 3057 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 3058 * 3059 * @param groupId the group ID 3060 * @param articleId the article ID 3061 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3062 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3063 * @throws SystemException if a system exception occurred 3064 */ 3065 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last( 3066 long groupId, java.lang.String articleId, 3067 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3068 throws com.liferay.portal.kernel.exception.SystemException { 3069 return getPersistence() 3070 .fetchByG_A_Last(groupId, articleId, orderByComparator); 3071 } 3072 3073 /** 3074 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ?. 3075 * 3076 * @param id the primary key of the current journal article 3077 * @param groupId the group ID 3078 * @param articleId the article ID 3079 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3080 * @return the previous, current, and next journal article 3081 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3082 * @throws SystemException if a system exception occurred 3083 */ 3084 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext( 3085 long id, long groupId, java.lang.String articleId, 3086 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3087 throws com.liferay.portal.kernel.exception.SystemException, 3088 com.liferay.portlet.journal.NoSuchArticleException { 3089 return getPersistence() 3090 .findByG_A_PrevAndNext(id, groupId, articleId, 3091 orderByComparator); 3092 } 3093 3094 /** 3095 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 3096 * 3097 * @param groupId the group ID 3098 * @param articleId the article ID 3099 * @return the matching journal articles that the user has permission to view 3100 * @throws SystemException if a system exception occurred 3101 */ 3102 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3103 long groupId, java.lang.String articleId) 3104 throws com.liferay.portal.kernel.exception.SystemException { 3105 return getPersistence().filterFindByG_A(groupId, articleId); 3106 } 3107 3108 /** 3109 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 3110 * 3111 * <p> 3112 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3113 * </p> 3114 * 3115 * @param groupId the group ID 3116 * @param articleId the article ID 3117 * @param start the lower bound of the range of journal articles 3118 * @param end the upper bound of the range of journal articles (not inclusive) 3119 * @return the range of matching journal articles that the user has permission to view 3120 * @throws SystemException if a system exception occurred 3121 */ 3122 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3123 long groupId, java.lang.String articleId, int start, int end) 3124 throws com.liferay.portal.kernel.exception.SystemException { 3125 return getPersistence().filterFindByG_A(groupId, articleId, start, end); 3126 } 3127 3128 /** 3129 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ?. 3130 * 3131 * <p> 3132 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3133 * </p> 3134 * 3135 * @param groupId the group ID 3136 * @param articleId the article ID 3137 * @param start the lower bound of the range of journal articles 3138 * @param end the upper bound of the range of journal articles (not inclusive) 3139 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3140 * @return the ordered range of matching journal articles that the user has permission to view 3141 * @throws SystemException if a system exception occurred 3142 */ 3143 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3144 long groupId, java.lang.String articleId, int start, int end, 3145 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3146 throws com.liferay.portal.kernel.exception.SystemException { 3147 return getPersistence() 3148 .filterFindByG_A(groupId, articleId, start, end, 3149 orderByComparator); 3150 } 3151 3152 /** 3153 * 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 = ?. 3154 * 3155 * @param id the primary key of the current journal article 3156 * @param groupId the group ID 3157 * @param articleId the article ID 3158 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3159 * @return the previous, current, and next journal article 3160 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3161 * @throws SystemException if a system exception occurred 3162 */ 3163 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext( 3164 long id, long groupId, java.lang.String articleId, 3165 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3166 throws com.liferay.portal.kernel.exception.SystemException, 3167 com.liferay.portlet.journal.NoSuchArticleException { 3168 return getPersistence() 3169 .filterFindByG_A_PrevAndNext(id, groupId, articleId, 3170 orderByComparator); 3171 } 3172 3173 /** 3174 * Removes all the journal articles where groupId = ? and articleId = ? from the database. 3175 * 3176 * @param groupId the group ID 3177 * @param articleId the article ID 3178 * @throws SystemException if a system exception occurred 3179 */ 3180 public static void removeByG_A(long groupId, java.lang.String articleId) 3181 throws com.liferay.portal.kernel.exception.SystemException { 3182 getPersistence().removeByG_A(groupId, articleId); 3183 } 3184 3185 /** 3186 * Returns the number of journal articles where groupId = ? and articleId = ?. 3187 * 3188 * @param groupId the group ID 3189 * @param articleId the article ID 3190 * @return the number of matching journal articles 3191 * @throws SystemException if a system exception occurred 3192 */ 3193 public static int countByG_A(long groupId, java.lang.String articleId) 3194 throws com.liferay.portal.kernel.exception.SystemException { 3195 return getPersistence().countByG_A(groupId, articleId); 3196 } 3197 3198 /** 3199 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ?. 3200 * 3201 * @param groupId the group ID 3202 * @param articleId the article ID 3203 * @return the number of matching journal articles that the user has permission to view 3204 * @throws SystemException if a system exception occurred 3205 */ 3206 public static int filterCountByG_A(long groupId, java.lang.String articleId) 3207 throws com.liferay.portal.kernel.exception.SystemException { 3208 return getPersistence().filterCountByG_A(groupId, articleId); 3209 } 3210 3211 /** 3212 * Returns all the journal articles where groupId = ? and urlTitle = ?. 3213 * 3214 * @param groupId the group ID 3215 * @param urlTitle the url title 3216 * @return the matching journal articles 3217 * @throws SystemException if a system exception occurred 3218 */ 3219 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3220 long groupId, java.lang.String urlTitle) 3221 throws com.liferay.portal.kernel.exception.SystemException { 3222 return getPersistence().findByG_UT(groupId, urlTitle); 3223 } 3224 3225 /** 3226 * Returns a range of all the journal articles where groupId = ? and urlTitle = ?. 3227 * 3228 * <p> 3229 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3230 * </p> 3231 * 3232 * @param groupId the group ID 3233 * @param urlTitle the url title 3234 * @param start the lower bound of the range of journal articles 3235 * @param end the upper bound of the range of journal articles (not inclusive) 3236 * @return the range of matching journal articles 3237 * @throws SystemException if a system exception occurred 3238 */ 3239 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3240 long groupId, java.lang.String urlTitle, int start, int end) 3241 throws com.liferay.portal.kernel.exception.SystemException { 3242 return getPersistence().findByG_UT(groupId, urlTitle, start, end); 3243 } 3244 3245 /** 3246 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ?. 3247 * 3248 * <p> 3249 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3250 * </p> 3251 * 3252 * @param groupId the group ID 3253 * @param urlTitle the url title 3254 * @param start the lower bound of the range of journal articles 3255 * @param end the upper bound of the range of journal articles (not inclusive) 3256 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3257 * @return the ordered range of matching journal articles 3258 * @throws SystemException if a system exception occurred 3259 */ 3260 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3261 long groupId, java.lang.String urlTitle, int start, int end, 3262 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3263 throws com.liferay.portal.kernel.exception.SystemException { 3264 return getPersistence() 3265 .findByG_UT(groupId, urlTitle, start, end, orderByComparator); 3266 } 3267 3268 /** 3269 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3270 * 3271 * @param groupId the group ID 3272 * @param urlTitle the url title 3273 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3274 * @return the first matching journal article 3275 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3276 * @throws SystemException if a system exception occurred 3277 */ 3278 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First( 3279 long groupId, java.lang.String urlTitle, 3280 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3281 throws com.liferay.portal.kernel.exception.SystemException, 3282 com.liferay.portlet.journal.NoSuchArticleException { 3283 return getPersistence() 3284 .findByG_UT_First(groupId, urlTitle, orderByComparator); 3285 } 3286 3287 /** 3288 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3289 * 3290 * @param groupId the group ID 3291 * @param urlTitle the url title 3292 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3293 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3294 * @throws SystemException if a system exception occurred 3295 */ 3296 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First( 3297 long groupId, java.lang.String urlTitle, 3298 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3299 throws com.liferay.portal.kernel.exception.SystemException { 3300 return getPersistence() 3301 .fetchByG_UT_First(groupId, urlTitle, orderByComparator); 3302 } 3303 3304 /** 3305 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3306 * 3307 * @param groupId the group ID 3308 * @param urlTitle the url title 3309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3310 * @return the last matching journal article 3311 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3312 * @throws SystemException if a system exception occurred 3313 */ 3314 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last( 3315 long groupId, java.lang.String urlTitle, 3316 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3317 throws com.liferay.portal.kernel.exception.SystemException, 3318 com.liferay.portlet.journal.NoSuchArticleException { 3319 return getPersistence() 3320 .findByG_UT_Last(groupId, urlTitle, orderByComparator); 3321 } 3322 3323 /** 3324 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3325 * 3326 * @param groupId the group ID 3327 * @param urlTitle the url title 3328 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3329 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3330 * @throws SystemException if a system exception occurred 3331 */ 3332 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last( 3333 long groupId, java.lang.String urlTitle, 3334 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3335 throws com.liferay.portal.kernel.exception.SystemException { 3336 return getPersistence() 3337 .fetchByG_UT_Last(groupId, urlTitle, orderByComparator); 3338 } 3339 3340 /** 3341 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ?. 3342 * 3343 * @param id the primary key of the current journal article 3344 * @param groupId the group ID 3345 * @param urlTitle the url title 3346 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3347 * @return the previous, current, and next journal article 3348 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3349 * @throws SystemException if a system exception occurred 3350 */ 3351 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext( 3352 long id, long groupId, java.lang.String urlTitle, 3353 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3354 throws com.liferay.portal.kernel.exception.SystemException, 3355 com.liferay.portlet.journal.NoSuchArticleException { 3356 return getPersistence() 3357 .findByG_UT_PrevAndNext(id, groupId, urlTitle, 3358 orderByComparator); 3359 } 3360 3361 /** 3362 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3363 * 3364 * @param groupId the group ID 3365 * @param urlTitle the url title 3366 * @return the matching journal articles that the user has permission to view 3367 * @throws SystemException if a system exception occurred 3368 */ 3369 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3370 long groupId, java.lang.String urlTitle) 3371 throws com.liferay.portal.kernel.exception.SystemException { 3372 return getPersistence().filterFindByG_UT(groupId, urlTitle); 3373 } 3374 3375 /** 3376 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3377 * 3378 * <p> 3379 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3380 * </p> 3381 * 3382 * @param groupId the group ID 3383 * @param urlTitle the url title 3384 * @param start the lower bound of the range of journal articles 3385 * @param end the upper bound of the range of journal articles (not inclusive) 3386 * @return the range of matching journal articles that the user has permission to view 3387 * @throws SystemException if a system exception occurred 3388 */ 3389 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3390 long groupId, java.lang.String urlTitle, int start, int end) 3391 throws com.liferay.portal.kernel.exception.SystemException { 3392 return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end); 3393 } 3394 3395 /** 3396 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ?. 3397 * 3398 * <p> 3399 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3400 * </p> 3401 * 3402 * @param groupId the group ID 3403 * @param urlTitle the url title 3404 * @param start the lower bound of the range of journal articles 3405 * @param end the upper bound of the range of journal articles (not inclusive) 3406 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3407 * @return the ordered range of matching journal articles that the user has permission to view 3408 * @throws SystemException if a system exception occurred 3409 */ 3410 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3411 long groupId, java.lang.String urlTitle, int start, int end, 3412 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3413 throws com.liferay.portal.kernel.exception.SystemException { 3414 return getPersistence() 3415 .filterFindByG_UT(groupId, urlTitle, start, end, 3416 orderByComparator); 3417 } 3418 3419 /** 3420 * 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 = ?. 3421 * 3422 * @param id the primary key of the current journal article 3423 * @param groupId the group ID 3424 * @param urlTitle the url title 3425 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3426 * @return the previous, current, and next journal article 3427 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3428 * @throws SystemException if a system exception occurred 3429 */ 3430 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext( 3431 long id, long groupId, java.lang.String urlTitle, 3432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3433 throws com.liferay.portal.kernel.exception.SystemException, 3434 com.liferay.portlet.journal.NoSuchArticleException { 3435 return getPersistence() 3436 .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle, 3437 orderByComparator); 3438 } 3439 3440 /** 3441 * Removes all the journal articles where groupId = ? and urlTitle = ? from the database. 3442 * 3443 * @param groupId the group ID 3444 * @param urlTitle the url title 3445 * @throws SystemException if a system exception occurred 3446 */ 3447 public static void removeByG_UT(long groupId, java.lang.String urlTitle) 3448 throws com.liferay.portal.kernel.exception.SystemException { 3449 getPersistence().removeByG_UT(groupId, urlTitle); 3450 } 3451 3452 /** 3453 * Returns the number of journal articles where groupId = ? and urlTitle = ?. 3454 * 3455 * @param groupId the group ID 3456 * @param urlTitle the url title 3457 * @return the number of matching journal articles 3458 * @throws SystemException if a system exception occurred 3459 */ 3460 public static int countByG_UT(long groupId, java.lang.String urlTitle) 3461 throws com.liferay.portal.kernel.exception.SystemException { 3462 return getPersistence().countByG_UT(groupId, urlTitle); 3463 } 3464 3465 /** 3466 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3467 * 3468 * @param groupId the group ID 3469 * @param urlTitle the url title 3470 * @return the number of matching journal articles that the user has permission to view 3471 * @throws SystemException if a system exception occurred 3472 */ 3473 public static int filterCountByG_UT(long groupId, java.lang.String urlTitle) 3474 throws com.liferay.portal.kernel.exception.SystemException { 3475 return getPersistence().filterCountByG_UT(groupId, urlTitle); 3476 } 3477 3478 /** 3479 * Returns all the journal articles where groupId = ? and structureId = ?. 3480 * 3481 * @param groupId the group ID 3482 * @param structureId the structure ID 3483 * @return the matching journal articles 3484 * @throws SystemException if a system exception occurred 3485 */ 3486 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3487 long groupId, java.lang.String structureId) 3488 throws com.liferay.portal.kernel.exception.SystemException { 3489 return getPersistence().findByG_S(groupId, structureId); 3490 } 3491 3492 /** 3493 * Returns a range of all the journal articles where groupId = ? and structureId = ?. 3494 * 3495 * <p> 3496 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3497 * </p> 3498 * 3499 * @param groupId the group ID 3500 * @param structureId the structure ID 3501 * @param start the lower bound of the range of journal articles 3502 * @param end the upper bound of the range of journal articles (not inclusive) 3503 * @return the range of matching journal articles 3504 * @throws SystemException if a system exception occurred 3505 */ 3506 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3507 long groupId, java.lang.String structureId, int start, int end) 3508 throws com.liferay.portal.kernel.exception.SystemException { 3509 return getPersistence().findByG_S(groupId, structureId, start, end); 3510 } 3511 3512 /** 3513 * Returns an ordered range of all the journal articles where groupId = ? and structureId = ?. 3514 * 3515 * <p> 3516 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3517 * </p> 3518 * 3519 * @param groupId the group ID 3520 * @param structureId the structure ID 3521 * @param start the lower bound of the range of journal articles 3522 * @param end the upper bound of the range of journal articles (not inclusive) 3523 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3524 * @return the ordered range of matching journal articles 3525 * @throws SystemException if a system exception occurred 3526 */ 3527 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3528 long groupId, java.lang.String structureId, int start, int end, 3529 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3530 throws com.liferay.portal.kernel.exception.SystemException { 3531 return getPersistence() 3532 .findByG_S(groupId, structureId, start, end, 3533 orderByComparator); 3534 } 3535 3536 /** 3537 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3538 * 3539 * @param groupId the group ID 3540 * @param structureId the structure ID 3541 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3542 * @return the first matching journal article 3543 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3544 * @throws SystemException if a system exception occurred 3545 */ 3546 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First( 3547 long groupId, java.lang.String structureId, 3548 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3549 throws com.liferay.portal.kernel.exception.SystemException, 3550 com.liferay.portlet.journal.NoSuchArticleException { 3551 return getPersistence() 3552 .findByG_S_First(groupId, structureId, orderByComparator); 3553 } 3554 3555 /** 3556 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3557 * 3558 * @param groupId the group ID 3559 * @param structureId the structure ID 3560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3561 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3562 * @throws SystemException if a system exception occurred 3563 */ 3564 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First( 3565 long groupId, java.lang.String structureId, 3566 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3567 throws com.liferay.portal.kernel.exception.SystemException { 3568 return getPersistence() 3569 .fetchByG_S_First(groupId, structureId, orderByComparator); 3570 } 3571 3572 /** 3573 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3574 * 3575 * @param groupId the group ID 3576 * @param structureId the structure ID 3577 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3578 * @return the last matching journal article 3579 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3580 * @throws SystemException if a system exception occurred 3581 */ 3582 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last( 3583 long groupId, java.lang.String structureId, 3584 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3585 throws com.liferay.portal.kernel.exception.SystemException, 3586 com.liferay.portlet.journal.NoSuchArticleException { 3587 return getPersistence() 3588 .findByG_S_Last(groupId, structureId, orderByComparator); 3589 } 3590 3591 /** 3592 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3593 * 3594 * @param groupId the group ID 3595 * @param structureId the structure ID 3596 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3597 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3598 * @throws SystemException if a system exception occurred 3599 */ 3600 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last( 3601 long groupId, java.lang.String structureId, 3602 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3603 throws com.liferay.portal.kernel.exception.SystemException { 3604 return getPersistence() 3605 .fetchByG_S_Last(groupId, structureId, orderByComparator); 3606 } 3607 3608 /** 3609 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and structureId = ?. 3610 * 3611 * @param id the primary key of the current journal article 3612 * @param groupId the group ID 3613 * @param structureId the structure ID 3614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3615 * @return the previous, current, and next journal article 3616 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3617 * @throws SystemException if a system exception occurred 3618 */ 3619 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext( 3620 long id, long groupId, java.lang.String structureId, 3621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3622 throws com.liferay.portal.kernel.exception.SystemException, 3623 com.liferay.portlet.journal.NoSuchArticleException { 3624 return getPersistence() 3625 .findByG_S_PrevAndNext(id, groupId, structureId, 3626 orderByComparator); 3627 } 3628 3629 /** 3630 * Returns all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3631 * 3632 * @param groupId the group ID 3633 * @param structureId the structure ID 3634 * @return the matching journal articles that the user has permission to view 3635 * @throws SystemException if a system exception occurred 3636 */ 3637 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3638 long groupId, java.lang.String structureId) 3639 throws com.liferay.portal.kernel.exception.SystemException { 3640 return getPersistence().filterFindByG_S(groupId, structureId); 3641 } 3642 3643 /** 3644 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3645 * 3646 * <p> 3647 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3648 * </p> 3649 * 3650 * @param groupId the group ID 3651 * @param structureId the structure ID 3652 * @param start the lower bound of the range of journal articles 3653 * @param end the upper bound of the range of journal articles (not inclusive) 3654 * @return the range of matching journal articles that the user has permission to view 3655 * @throws SystemException if a system exception occurred 3656 */ 3657 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3658 long groupId, java.lang.String structureId, int start, int end) 3659 throws com.liferay.portal.kernel.exception.SystemException { 3660 return getPersistence().filterFindByG_S(groupId, structureId, start, end); 3661 } 3662 3663 /** 3664 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and structureId = ?. 3665 * 3666 * <p> 3667 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3668 * </p> 3669 * 3670 * @param groupId the group ID 3671 * @param structureId the structure ID 3672 * @param start the lower bound of the range of journal articles 3673 * @param end the upper bound of the range of journal articles (not inclusive) 3674 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3675 * @return the ordered range of matching journal articles that the user has permission to view 3676 * @throws SystemException if a system exception occurred 3677 */ 3678 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3679 long groupId, java.lang.String structureId, int start, int end, 3680 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3681 throws com.liferay.portal.kernel.exception.SystemException { 3682 return getPersistence() 3683 .filterFindByG_S(groupId, structureId, start, end, 3684 orderByComparator); 3685 } 3686 3687 /** 3688 * 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 = ?. 3689 * 3690 * @param id the primary key of the current journal article 3691 * @param groupId the group ID 3692 * @param structureId the structure ID 3693 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3694 * @return the previous, current, and next journal article 3695 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3696 * @throws SystemException if a system exception occurred 3697 */ 3698 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext( 3699 long id, long groupId, java.lang.String structureId, 3700 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3701 throws com.liferay.portal.kernel.exception.SystemException, 3702 com.liferay.portlet.journal.NoSuchArticleException { 3703 return getPersistence() 3704 .filterFindByG_S_PrevAndNext(id, groupId, structureId, 3705 orderByComparator); 3706 } 3707 3708 /** 3709 * Removes all the journal articles where groupId = ? and structureId = ? from the database. 3710 * 3711 * @param groupId the group ID 3712 * @param structureId the structure ID 3713 * @throws SystemException if a system exception occurred 3714 */ 3715 public static void removeByG_S(long groupId, java.lang.String structureId) 3716 throws com.liferay.portal.kernel.exception.SystemException { 3717 getPersistence().removeByG_S(groupId, structureId); 3718 } 3719 3720 /** 3721 * Returns the number of journal articles where groupId = ? and structureId = ?. 3722 * 3723 * @param groupId the group ID 3724 * @param structureId the structure ID 3725 * @return the number of matching journal articles 3726 * @throws SystemException if a system exception occurred 3727 */ 3728 public static int countByG_S(long groupId, java.lang.String structureId) 3729 throws com.liferay.portal.kernel.exception.SystemException { 3730 return getPersistence().countByG_S(groupId, structureId); 3731 } 3732 3733 /** 3734 * Returns the number of journal articles that the user has permission to view where groupId = ? and structureId = ?. 3735 * 3736 * @param groupId the group ID 3737 * @param structureId the structure ID 3738 * @return the number of matching journal articles that the user has permission to view 3739 * @throws SystemException if a system exception occurred 3740 */ 3741 public static int filterCountByG_S(long groupId, 3742 java.lang.String structureId) 3743 throws com.liferay.portal.kernel.exception.SystemException { 3744 return getPersistence().filterCountByG_S(groupId, structureId); 3745 } 3746 3747 /** 3748 * Returns all the journal articles where groupId = ? and templateId = ?. 3749 * 3750 * @param groupId the group ID 3751 * @param templateId the template ID 3752 * @return the matching journal articles 3753 * @throws SystemException if a system exception occurred 3754 */ 3755 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3756 long groupId, java.lang.String templateId) 3757 throws com.liferay.portal.kernel.exception.SystemException { 3758 return getPersistence().findByG_T(groupId, templateId); 3759 } 3760 3761 /** 3762 * Returns a range of all the journal articles where groupId = ? and templateId = ?. 3763 * 3764 * <p> 3765 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3766 * </p> 3767 * 3768 * @param groupId the group ID 3769 * @param templateId the template ID 3770 * @param start the lower bound of the range of journal articles 3771 * @param end the upper bound of the range of journal articles (not inclusive) 3772 * @return the range of matching journal articles 3773 * @throws SystemException if a system exception occurred 3774 */ 3775 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3776 long groupId, java.lang.String templateId, int start, int end) 3777 throws com.liferay.portal.kernel.exception.SystemException { 3778 return getPersistence().findByG_T(groupId, templateId, start, end); 3779 } 3780 3781 /** 3782 * Returns an ordered range of all the journal articles where groupId = ? and templateId = ?. 3783 * 3784 * <p> 3785 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3786 * </p> 3787 * 3788 * @param groupId the group ID 3789 * @param templateId the template ID 3790 * @param start the lower bound of the range of journal articles 3791 * @param end the upper bound of the range of journal articles (not inclusive) 3792 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3793 * @return the ordered range of matching journal articles 3794 * @throws SystemException if a system exception occurred 3795 */ 3796 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3797 long groupId, java.lang.String templateId, int start, int end, 3798 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3799 throws com.liferay.portal.kernel.exception.SystemException { 3800 return getPersistence() 3801 .findByG_T(groupId, templateId, start, end, orderByComparator); 3802 } 3803 3804 /** 3805 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3806 * 3807 * @param groupId the group ID 3808 * @param templateId the template ID 3809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3810 * @return the first matching journal article 3811 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3812 * @throws SystemException if a system exception occurred 3813 */ 3814 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First( 3815 long groupId, java.lang.String templateId, 3816 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3817 throws com.liferay.portal.kernel.exception.SystemException, 3818 com.liferay.portlet.journal.NoSuchArticleException { 3819 return getPersistence() 3820 .findByG_T_First(groupId, templateId, orderByComparator); 3821 } 3822 3823 /** 3824 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3825 * 3826 * @param groupId the group ID 3827 * @param templateId the template ID 3828 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3829 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3830 * @throws SystemException if a system exception occurred 3831 */ 3832 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First( 3833 long groupId, java.lang.String templateId, 3834 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3835 throws com.liferay.portal.kernel.exception.SystemException { 3836 return getPersistence() 3837 .fetchByG_T_First(groupId, templateId, orderByComparator); 3838 } 3839 3840 /** 3841 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3842 * 3843 * @param groupId the group ID 3844 * @param templateId the template ID 3845 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3846 * @return the last matching journal article 3847 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3848 * @throws SystemException if a system exception occurred 3849 */ 3850 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last( 3851 long groupId, java.lang.String templateId, 3852 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3853 throws com.liferay.portal.kernel.exception.SystemException, 3854 com.liferay.portlet.journal.NoSuchArticleException { 3855 return getPersistence() 3856 .findByG_T_Last(groupId, templateId, orderByComparator); 3857 } 3858 3859 /** 3860 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3861 * 3862 * @param groupId the group ID 3863 * @param templateId the template ID 3864 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3865 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3866 * @throws SystemException if a system exception occurred 3867 */ 3868 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last( 3869 long groupId, java.lang.String templateId, 3870 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3871 throws com.liferay.portal.kernel.exception.SystemException { 3872 return getPersistence() 3873 .fetchByG_T_Last(groupId, templateId, orderByComparator); 3874 } 3875 3876 /** 3877 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and templateId = ?. 3878 * 3879 * @param id the primary key of the current journal article 3880 * @param groupId the group ID 3881 * @param templateId the template ID 3882 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3883 * @return the previous, current, and next journal article 3884 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3885 * @throws SystemException if a system exception occurred 3886 */ 3887 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext( 3888 long id, long groupId, java.lang.String templateId, 3889 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3890 throws com.liferay.portal.kernel.exception.SystemException, 3891 com.liferay.portlet.journal.NoSuchArticleException { 3892 return getPersistence() 3893 .findByG_T_PrevAndNext(id, groupId, templateId, 3894 orderByComparator); 3895 } 3896 3897 /** 3898 * Returns all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3899 * 3900 * @param groupId the group ID 3901 * @param templateId the template ID 3902 * @return the matching journal articles that the user has permission to view 3903 * @throws SystemException if a system exception occurred 3904 */ 3905 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3906 long groupId, java.lang.String templateId) 3907 throws com.liferay.portal.kernel.exception.SystemException { 3908 return getPersistence().filterFindByG_T(groupId, templateId); 3909 } 3910 3911 /** 3912 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3913 * 3914 * <p> 3915 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3916 * </p> 3917 * 3918 * @param groupId the group ID 3919 * @param templateId the template ID 3920 * @param start the lower bound of the range of journal articles 3921 * @param end the upper bound of the range of journal articles (not inclusive) 3922 * @return the range of matching journal articles that the user has permission to view 3923 * @throws SystemException if a system exception occurred 3924 */ 3925 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3926 long groupId, java.lang.String templateId, int start, int end) 3927 throws com.liferay.portal.kernel.exception.SystemException { 3928 return getPersistence().filterFindByG_T(groupId, templateId, start, end); 3929 } 3930 3931 /** 3932 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and templateId = ?. 3933 * 3934 * <p> 3935 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3936 * </p> 3937 * 3938 * @param groupId the group ID 3939 * @param templateId the template ID 3940 * @param start the lower bound of the range of journal articles 3941 * @param end the upper bound of the range of journal articles (not inclusive) 3942 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3943 * @return the ordered range of matching journal articles that the user has permission to view 3944 * @throws SystemException if a system exception occurred 3945 */ 3946 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3947 long groupId, java.lang.String templateId, int start, int end, 3948 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3949 throws com.liferay.portal.kernel.exception.SystemException { 3950 return getPersistence() 3951 .filterFindByG_T(groupId, templateId, start, end, 3952 orderByComparator); 3953 } 3954 3955 /** 3956 * 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 = ?. 3957 * 3958 * @param id the primary key of the current journal article 3959 * @param groupId the group ID 3960 * @param templateId the template ID 3961 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3962 * @return the previous, current, and next journal article 3963 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3964 * @throws SystemException if a system exception occurred 3965 */ 3966 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext( 3967 long id, long groupId, java.lang.String templateId, 3968 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3969 throws com.liferay.portal.kernel.exception.SystemException, 3970 com.liferay.portlet.journal.NoSuchArticleException { 3971 return getPersistence() 3972 .filterFindByG_T_PrevAndNext(id, groupId, templateId, 3973 orderByComparator); 3974 } 3975 3976 /** 3977 * Removes all the journal articles where groupId = ? and templateId = ? from the database. 3978 * 3979 * @param groupId the group ID 3980 * @param templateId the template ID 3981 * @throws SystemException if a system exception occurred 3982 */ 3983 public static void removeByG_T(long groupId, java.lang.String templateId) 3984 throws com.liferay.portal.kernel.exception.SystemException { 3985 getPersistence().removeByG_T(groupId, templateId); 3986 } 3987 3988 /** 3989 * Returns the number of journal articles where groupId = ? and templateId = ?. 3990 * 3991 * @param groupId the group ID 3992 * @param templateId the template ID 3993 * @return the number of matching journal articles 3994 * @throws SystemException if a system exception occurred 3995 */ 3996 public static int countByG_T(long groupId, java.lang.String templateId) 3997 throws com.liferay.portal.kernel.exception.SystemException { 3998 return getPersistence().countByG_T(groupId, templateId); 3999 } 4000 4001 /** 4002 * Returns the number of journal articles that the user has permission to view where groupId = ? and templateId = ?. 4003 * 4004 * @param groupId the group ID 4005 * @param templateId the template ID 4006 * @return the number of matching journal articles that the user has permission to view 4007 * @throws SystemException if a system exception occurred 4008 */ 4009 public static int filterCountByG_T(long groupId, java.lang.String templateId) 4010 throws com.liferay.portal.kernel.exception.SystemException { 4011 return getPersistence().filterCountByG_T(groupId, templateId); 4012 } 4013 4014 /** 4015 * Returns all the journal articles where groupId = ? and layoutUuid = ?. 4016 * 4017 * @param groupId the group ID 4018 * @param layoutUuid the layout uuid 4019 * @return the matching journal articles 4020 * @throws SystemException if a system exception occurred 4021 */ 4022 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 4023 long groupId, java.lang.String layoutUuid) 4024 throws com.liferay.portal.kernel.exception.SystemException { 4025 return getPersistence().findByG_L(groupId, layoutUuid); 4026 } 4027 4028 /** 4029 * Returns a range of all the journal articles where groupId = ? and layoutUuid = ?. 4030 * 4031 * <p> 4032 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4033 * </p> 4034 * 4035 * @param groupId the group ID 4036 * @param layoutUuid the layout uuid 4037 * @param start the lower bound of the range of journal articles 4038 * @param end the upper bound of the range of journal articles (not inclusive) 4039 * @return the range of matching journal articles 4040 * @throws SystemException if a system exception occurred 4041 */ 4042 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 4043 long groupId, java.lang.String layoutUuid, int start, int end) 4044 throws com.liferay.portal.kernel.exception.SystemException { 4045 return getPersistence().findByG_L(groupId, layoutUuid, start, end); 4046 } 4047 4048 /** 4049 * Returns an ordered range of all the journal articles where groupId = ? and layoutUuid = ?. 4050 * 4051 * <p> 4052 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4053 * </p> 4054 * 4055 * @param groupId the group ID 4056 * @param layoutUuid the layout uuid 4057 * @param start the lower bound of the range of journal articles 4058 * @param end the upper bound of the range of journal articles (not inclusive) 4059 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4060 * @return the ordered range of matching journal articles 4061 * @throws SystemException if a system exception occurred 4062 */ 4063 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 4064 long groupId, java.lang.String layoutUuid, int start, int end, 4065 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4066 throws com.liferay.portal.kernel.exception.SystemException { 4067 return getPersistence() 4068 .findByG_L(groupId, layoutUuid, start, end, orderByComparator); 4069 } 4070 4071 /** 4072 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 4073 * 4074 * @param groupId the group ID 4075 * @param layoutUuid the layout uuid 4076 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4077 * @return the first matching journal article 4078 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4079 * @throws SystemException if a system exception occurred 4080 */ 4081 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First( 4082 long groupId, java.lang.String layoutUuid, 4083 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4084 throws com.liferay.portal.kernel.exception.SystemException, 4085 com.liferay.portlet.journal.NoSuchArticleException { 4086 return getPersistence() 4087 .findByG_L_First(groupId, layoutUuid, orderByComparator); 4088 } 4089 4090 /** 4091 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 4092 * 4093 * @param groupId the group ID 4094 * @param layoutUuid the layout uuid 4095 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4096 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4097 * @throws SystemException if a system exception occurred 4098 */ 4099 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First( 4100 long groupId, java.lang.String layoutUuid, 4101 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4102 throws com.liferay.portal.kernel.exception.SystemException { 4103 return getPersistence() 4104 .fetchByG_L_First(groupId, layoutUuid, orderByComparator); 4105 } 4106 4107 /** 4108 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 4109 * 4110 * @param groupId the group ID 4111 * @param layoutUuid the layout uuid 4112 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4113 * @return the last matching journal article 4114 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4115 * @throws SystemException if a system exception occurred 4116 */ 4117 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last( 4118 long groupId, java.lang.String layoutUuid, 4119 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4120 throws com.liferay.portal.kernel.exception.SystemException, 4121 com.liferay.portlet.journal.NoSuchArticleException { 4122 return getPersistence() 4123 .findByG_L_Last(groupId, layoutUuid, orderByComparator); 4124 } 4125 4126 /** 4127 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 4128 * 4129 * @param groupId the group ID 4130 * @param layoutUuid the layout uuid 4131 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4132 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4133 * @throws SystemException if a system exception occurred 4134 */ 4135 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last( 4136 long groupId, java.lang.String layoutUuid, 4137 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4138 throws com.liferay.portal.kernel.exception.SystemException { 4139 return getPersistence() 4140 .fetchByG_L_Last(groupId, layoutUuid, orderByComparator); 4141 } 4142 4143 /** 4144 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and layoutUuid = ?. 4145 * 4146 * @param id the primary key of the current journal article 4147 * @param groupId the group ID 4148 * @param layoutUuid the layout uuid 4149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4150 * @return the previous, current, and next journal article 4151 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4152 * @throws SystemException if a system exception occurred 4153 */ 4154 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext( 4155 long id, long groupId, java.lang.String layoutUuid, 4156 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4157 throws com.liferay.portal.kernel.exception.SystemException, 4158 com.liferay.portlet.journal.NoSuchArticleException { 4159 return getPersistence() 4160 .findByG_L_PrevAndNext(id, groupId, layoutUuid, 4161 orderByComparator); 4162 } 4163 4164 /** 4165 * Returns all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4166 * 4167 * @param groupId the group ID 4168 * @param layoutUuid the layout uuid 4169 * @return the matching journal articles that the user has permission to view 4170 * @throws SystemException if a system exception occurred 4171 */ 4172 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4173 long groupId, java.lang.String layoutUuid) 4174 throws com.liferay.portal.kernel.exception.SystemException { 4175 return getPersistence().filterFindByG_L(groupId, layoutUuid); 4176 } 4177 4178 /** 4179 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4180 * 4181 * <p> 4182 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4183 * </p> 4184 * 4185 * @param groupId the group ID 4186 * @param layoutUuid the layout uuid 4187 * @param start the lower bound of the range of journal articles 4188 * @param end the upper bound of the range of journal articles (not inclusive) 4189 * @return the range of matching journal articles that the user has permission to view 4190 * @throws SystemException if a system exception occurred 4191 */ 4192 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4193 long groupId, java.lang.String layoutUuid, int start, int end) 4194 throws com.liferay.portal.kernel.exception.SystemException { 4195 return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end); 4196 } 4197 4198 /** 4199 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and layoutUuid = ?. 4200 * 4201 * <p> 4202 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4203 * </p> 4204 * 4205 * @param groupId the group ID 4206 * @param layoutUuid the layout uuid 4207 * @param start the lower bound of the range of journal articles 4208 * @param end the upper bound of the range of journal articles (not inclusive) 4209 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4210 * @return the ordered range of matching journal articles that the user has permission to view 4211 * @throws SystemException if a system exception occurred 4212 */ 4213 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4214 long groupId, java.lang.String layoutUuid, int start, int end, 4215 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4216 throws com.liferay.portal.kernel.exception.SystemException { 4217 return getPersistence() 4218 .filterFindByG_L(groupId, layoutUuid, start, end, 4219 orderByComparator); 4220 } 4221 4222 /** 4223 * 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 = ?. 4224 * 4225 * @param id the primary key of the current journal article 4226 * @param groupId the group ID 4227 * @param layoutUuid the layout uuid 4228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4229 * @return the previous, current, and next journal article 4230 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4231 * @throws SystemException if a system exception occurred 4232 */ 4233 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext( 4234 long id, long groupId, java.lang.String layoutUuid, 4235 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4236 throws com.liferay.portal.kernel.exception.SystemException, 4237 com.liferay.portlet.journal.NoSuchArticleException { 4238 return getPersistence() 4239 .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid, 4240 orderByComparator); 4241 } 4242 4243 /** 4244 * Removes all the journal articles where groupId = ? and layoutUuid = ? from the database. 4245 * 4246 * @param groupId the group ID 4247 * @param layoutUuid the layout uuid 4248 * @throws SystemException if a system exception occurred 4249 */ 4250 public static void removeByG_L(long groupId, java.lang.String layoutUuid) 4251 throws com.liferay.portal.kernel.exception.SystemException { 4252 getPersistence().removeByG_L(groupId, layoutUuid); 4253 } 4254 4255 /** 4256 * Returns the number of journal articles where groupId = ? and layoutUuid = ?. 4257 * 4258 * @param groupId the group ID 4259 * @param layoutUuid the layout uuid 4260 * @return the number of matching journal articles 4261 * @throws SystemException if a system exception occurred 4262 */ 4263 public static int countByG_L(long groupId, java.lang.String layoutUuid) 4264 throws com.liferay.portal.kernel.exception.SystemException { 4265 return getPersistence().countByG_L(groupId, layoutUuid); 4266 } 4267 4268 /** 4269 * Returns the number of journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4270 * 4271 * @param groupId the group ID 4272 * @param layoutUuid the layout uuid 4273 * @return the number of matching journal articles that the user has permission to view 4274 * @throws SystemException if a system exception occurred 4275 */ 4276 public static int filterCountByG_L(long groupId, java.lang.String layoutUuid) 4277 throws com.liferay.portal.kernel.exception.SystemException { 4278 return getPersistence().filterCountByG_L(groupId, layoutUuid); 4279 } 4280 4281 /** 4282 * Returns all the journal articles where groupId = ? and status = ?. 4283 * 4284 * @param groupId the group ID 4285 * @param status the status 4286 * @return the matching journal articles 4287 * @throws SystemException if a system exception occurred 4288 */ 4289 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4290 long groupId, int status) 4291 throws com.liferay.portal.kernel.exception.SystemException { 4292 return getPersistence().findByG_ST(groupId, status); 4293 } 4294 4295 /** 4296 * Returns a range of all the journal articles where groupId = ? and status = ?. 4297 * 4298 * <p> 4299 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4300 * </p> 4301 * 4302 * @param groupId the group ID 4303 * @param status the status 4304 * @param start the lower bound of the range of journal articles 4305 * @param end the upper bound of the range of journal articles (not inclusive) 4306 * @return the range of matching journal articles 4307 * @throws SystemException if a system exception occurred 4308 */ 4309 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4310 long groupId, int status, int start, int end) 4311 throws com.liferay.portal.kernel.exception.SystemException { 4312 return getPersistence().findByG_ST(groupId, status, start, end); 4313 } 4314 4315 /** 4316 * Returns an ordered range of all the journal articles where groupId = ? and status = ?. 4317 * 4318 * <p> 4319 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4320 * </p> 4321 * 4322 * @param groupId the group ID 4323 * @param status the status 4324 * @param start the lower bound of the range of journal articles 4325 * @param end the upper bound of the range of journal articles (not inclusive) 4326 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4327 * @return the ordered range of matching journal articles 4328 * @throws SystemException if a system exception occurred 4329 */ 4330 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4331 long groupId, int status, int start, int end, 4332 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4333 throws com.liferay.portal.kernel.exception.SystemException { 4334 return getPersistence() 4335 .findByG_ST(groupId, status, start, end, orderByComparator); 4336 } 4337 4338 /** 4339 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4340 * 4341 * @param groupId the group ID 4342 * @param status the status 4343 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4344 * @return the first matching journal article 4345 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4346 * @throws SystemException if a system exception occurred 4347 */ 4348 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First( 4349 long groupId, int status, 4350 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4351 throws com.liferay.portal.kernel.exception.SystemException, 4352 com.liferay.portlet.journal.NoSuchArticleException { 4353 return getPersistence() 4354 .findByG_ST_First(groupId, status, orderByComparator); 4355 } 4356 4357 /** 4358 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4359 * 4360 * @param groupId the group ID 4361 * @param status the status 4362 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4363 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4364 * @throws SystemException if a system exception occurred 4365 */ 4366 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First( 4367 long groupId, int status, 4368 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4369 throws com.liferay.portal.kernel.exception.SystemException { 4370 return getPersistence() 4371 .fetchByG_ST_First(groupId, status, orderByComparator); 4372 } 4373 4374 /** 4375 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4376 * 4377 * @param groupId the group ID 4378 * @param status the status 4379 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4380 * @return the last matching journal article 4381 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4382 * @throws SystemException if a system exception occurred 4383 */ 4384 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last( 4385 long groupId, int status, 4386 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4387 throws com.liferay.portal.kernel.exception.SystemException, 4388 com.liferay.portlet.journal.NoSuchArticleException { 4389 return getPersistence() 4390 .findByG_ST_Last(groupId, status, orderByComparator); 4391 } 4392 4393 /** 4394 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4395 * 4396 * @param groupId the group ID 4397 * @param status the status 4398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4399 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4400 * @throws SystemException if a system exception occurred 4401 */ 4402 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last( 4403 long groupId, int status, 4404 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4405 throws com.liferay.portal.kernel.exception.SystemException { 4406 return getPersistence() 4407 .fetchByG_ST_Last(groupId, status, orderByComparator); 4408 } 4409 4410 /** 4411 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and status = ?. 4412 * 4413 * @param id the primary key of the current journal article 4414 * @param groupId the group ID 4415 * @param status the status 4416 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4417 * @return the previous, current, and next journal article 4418 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4419 * @throws SystemException if a system exception occurred 4420 */ 4421 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext( 4422 long id, long groupId, int status, 4423 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4424 throws com.liferay.portal.kernel.exception.SystemException, 4425 com.liferay.portlet.journal.NoSuchArticleException { 4426 return getPersistence() 4427 .findByG_ST_PrevAndNext(id, groupId, status, 4428 orderByComparator); 4429 } 4430 4431 /** 4432 * Returns all the journal articles that the user has permission to view where groupId = ? and status = ?. 4433 * 4434 * @param groupId the group ID 4435 * @param status the status 4436 * @return the matching journal articles that the user has permission to view 4437 * @throws SystemException if a system exception occurred 4438 */ 4439 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4440 long groupId, int status) 4441 throws com.liferay.portal.kernel.exception.SystemException { 4442 return getPersistence().filterFindByG_ST(groupId, status); 4443 } 4444 4445 /** 4446 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and status = ?. 4447 * 4448 * <p> 4449 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4450 * </p> 4451 * 4452 * @param groupId the group ID 4453 * @param status the status 4454 * @param start the lower bound of the range of journal articles 4455 * @param end the upper bound of the range of journal articles (not inclusive) 4456 * @return the range of matching journal articles that the user has permission to view 4457 * @throws SystemException if a system exception occurred 4458 */ 4459 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4460 long groupId, int status, int start, int end) 4461 throws com.liferay.portal.kernel.exception.SystemException { 4462 return getPersistence().filterFindByG_ST(groupId, status, start, end); 4463 } 4464 4465 /** 4466 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and status = ?. 4467 * 4468 * <p> 4469 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4470 * </p> 4471 * 4472 * @param groupId the group ID 4473 * @param status the status 4474 * @param start the lower bound of the range of journal articles 4475 * @param end the upper bound of the range of journal articles (not inclusive) 4476 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4477 * @return the ordered range of matching journal articles that the user has permission to view 4478 * @throws SystemException if a system exception occurred 4479 */ 4480 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4481 long groupId, int status, int start, int end, 4482 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4483 throws com.liferay.portal.kernel.exception.SystemException { 4484 return getPersistence() 4485 .filterFindByG_ST(groupId, status, start, end, 4486 orderByComparator); 4487 } 4488 4489 /** 4490 * 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 = ?. 4491 * 4492 * @param id the primary key of the current journal article 4493 * @param groupId the group ID 4494 * @param status the status 4495 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4496 * @return the previous, current, and next journal article 4497 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4498 * @throws SystemException if a system exception occurred 4499 */ 4500 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext( 4501 long id, long groupId, int status, 4502 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4503 throws com.liferay.portal.kernel.exception.SystemException, 4504 com.liferay.portlet.journal.NoSuchArticleException { 4505 return getPersistence() 4506 .filterFindByG_ST_PrevAndNext(id, groupId, status, 4507 orderByComparator); 4508 } 4509 4510 /** 4511 * Removes all the journal articles where groupId = ? and status = ? from the database. 4512 * 4513 * @param groupId the group ID 4514 * @param status the status 4515 * @throws SystemException if a system exception occurred 4516 */ 4517 public static void removeByG_ST(long groupId, int status) 4518 throws com.liferay.portal.kernel.exception.SystemException { 4519 getPersistence().removeByG_ST(groupId, status); 4520 } 4521 4522 /** 4523 * Returns the number of journal articles where groupId = ? and status = ?. 4524 * 4525 * @param groupId the group ID 4526 * @param status the status 4527 * @return the number of matching journal articles 4528 * @throws SystemException if a system exception occurred 4529 */ 4530 public static int countByG_ST(long groupId, int status) 4531 throws com.liferay.portal.kernel.exception.SystemException { 4532 return getPersistence().countByG_ST(groupId, status); 4533 } 4534 4535 /** 4536 * Returns the number of journal articles that the user has permission to view where groupId = ? and status = ?. 4537 * 4538 * @param groupId the group ID 4539 * @param status the status 4540 * @return the number of matching journal articles that the user has permission to view 4541 * @throws SystemException if a system exception occurred 4542 */ 4543 public static int filterCountByG_ST(long groupId, int status) 4544 throws com.liferay.portal.kernel.exception.SystemException { 4545 return getPersistence().filterCountByG_ST(groupId, status); 4546 } 4547 4548 /** 4549 * Returns all the journal articles where companyId = ? and version = ?. 4550 * 4551 * @param companyId the company ID 4552 * @param version the version 4553 * @return the matching journal articles 4554 * @throws SystemException if a system exception occurred 4555 */ 4556 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4557 long companyId, double version) 4558 throws com.liferay.portal.kernel.exception.SystemException { 4559 return getPersistence().findByC_V(companyId, version); 4560 } 4561 4562 /** 4563 * Returns a range of all the journal articles where companyId = ? and version = ?. 4564 * 4565 * <p> 4566 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4567 * </p> 4568 * 4569 * @param companyId the company ID 4570 * @param version the version 4571 * @param start the lower bound of the range of journal articles 4572 * @param end the upper bound of the range of journal articles (not inclusive) 4573 * @return the range of matching journal articles 4574 * @throws SystemException if a system exception occurred 4575 */ 4576 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4577 long companyId, double version, int start, int end) 4578 throws com.liferay.portal.kernel.exception.SystemException { 4579 return getPersistence().findByC_V(companyId, version, start, end); 4580 } 4581 4582 /** 4583 * Returns an ordered range of all the journal articles where companyId = ? and version = ?. 4584 * 4585 * <p> 4586 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4587 * </p> 4588 * 4589 * @param companyId the company ID 4590 * @param version the version 4591 * @param start the lower bound of the range of journal articles 4592 * @param end the upper bound of the range of journal articles (not inclusive) 4593 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4594 * @return the ordered range of matching journal articles 4595 * @throws SystemException if a system exception occurred 4596 */ 4597 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4598 long companyId, double version, int start, int end, 4599 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4600 throws com.liferay.portal.kernel.exception.SystemException { 4601 return getPersistence() 4602 .findByC_V(companyId, version, start, end, orderByComparator); 4603 } 4604 4605 /** 4606 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 4607 * 4608 * @param companyId the company ID 4609 * @param version the version 4610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4611 * @return the first matching journal article 4612 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4613 * @throws SystemException if a system exception occurred 4614 */ 4615 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First( 4616 long companyId, double version, 4617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4618 throws com.liferay.portal.kernel.exception.SystemException, 4619 com.liferay.portlet.journal.NoSuchArticleException { 4620 return getPersistence() 4621 .findByC_V_First(companyId, version, orderByComparator); 4622 } 4623 4624 /** 4625 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 4626 * 4627 * @param companyId the company ID 4628 * @param version the version 4629 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4630 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4631 * @throws SystemException if a system exception occurred 4632 */ 4633 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First( 4634 long companyId, double version, 4635 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4636 throws com.liferay.portal.kernel.exception.SystemException { 4637 return getPersistence() 4638 .fetchByC_V_First(companyId, version, orderByComparator); 4639 } 4640 4641 /** 4642 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 4643 * 4644 * @param companyId the company ID 4645 * @param version the version 4646 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4647 * @return the last matching journal article 4648 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4649 * @throws SystemException if a system exception occurred 4650 */ 4651 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last( 4652 long companyId, double version, 4653 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4654 throws com.liferay.portal.kernel.exception.SystemException, 4655 com.liferay.portlet.journal.NoSuchArticleException { 4656 return getPersistence() 4657 .findByC_V_Last(companyId, version, orderByComparator); 4658 } 4659 4660 /** 4661 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 4662 * 4663 * @param companyId the company ID 4664 * @param version the version 4665 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4666 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4667 * @throws SystemException if a system exception occurred 4668 */ 4669 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last( 4670 long companyId, double version, 4671 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4672 throws com.liferay.portal.kernel.exception.SystemException { 4673 return getPersistence() 4674 .fetchByC_V_Last(companyId, version, orderByComparator); 4675 } 4676 4677 /** 4678 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ?. 4679 * 4680 * @param id the primary key of the current journal article 4681 * @param companyId the company ID 4682 * @param version the version 4683 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4684 * @return the previous, current, and next journal article 4685 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4686 * @throws SystemException if a system exception occurred 4687 */ 4688 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext( 4689 long id, long companyId, double version, 4690 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4691 throws com.liferay.portal.kernel.exception.SystemException, 4692 com.liferay.portlet.journal.NoSuchArticleException { 4693 return getPersistence() 4694 .findByC_V_PrevAndNext(id, companyId, version, 4695 orderByComparator); 4696 } 4697 4698 /** 4699 * Removes all the journal articles where companyId = ? and version = ? from the database. 4700 * 4701 * @param companyId the company ID 4702 * @param version the version 4703 * @throws SystemException if a system exception occurred 4704 */ 4705 public static void removeByC_V(long companyId, double version) 4706 throws com.liferay.portal.kernel.exception.SystemException { 4707 getPersistence().removeByC_V(companyId, version); 4708 } 4709 4710 /** 4711 * Returns the number of journal articles where companyId = ? and version = ?. 4712 * 4713 * @param companyId the company ID 4714 * @param version the version 4715 * @return the number of matching journal articles 4716 * @throws SystemException if a system exception occurred 4717 */ 4718 public static int countByC_V(long companyId, double version) 4719 throws com.liferay.portal.kernel.exception.SystemException { 4720 return getPersistence().countByC_V(companyId, version); 4721 } 4722 4723 /** 4724 * Returns all the journal articles where companyId = ? and status = ?. 4725 * 4726 * @param companyId the company ID 4727 * @param status the status 4728 * @return the matching journal articles 4729 * @throws SystemException if a system exception occurred 4730 */ 4731 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4732 long companyId, int status) 4733 throws com.liferay.portal.kernel.exception.SystemException { 4734 return getPersistence().findByC_ST(companyId, status); 4735 } 4736 4737 /** 4738 * Returns a range of all the journal articles where companyId = ? and status = ?. 4739 * 4740 * <p> 4741 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4742 * </p> 4743 * 4744 * @param companyId the company ID 4745 * @param status the status 4746 * @param start the lower bound of the range of journal articles 4747 * @param end the upper bound of the range of journal articles (not inclusive) 4748 * @return the range of matching journal articles 4749 * @throws SystemException if a system exception occurred 4750 */ 4751 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4752 long companyId, int status, int start, int end) 4753 throws com.liferay.portal.kernel.exception.SystemException { 4754 return getPersistence().findByC_ST(companyId, status, start, end); 4755 } 4756 4757 /** 4758 * Returns an ordered range of all the journal articles where companyId = ? and status = ?. 4759 * 4760 * <p> 4761 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4762 * </p> 4763 * 4764 * @param companyId the company ID 4765 * @param status the status 4766 * @param start the lower bound of the range of journal articles 4767 * @param end the upper bound of the range of journal articles (not inclusive) 4768 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4769 * @return the ordered range of matching journal articles 4770 * @throws SystemException if a system exception occurred 4771 */ 4772 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4773 long companyId, int status, int start, int end, 4774 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4775 throws com.liferay.portal.kernel.exception.SystemException { 4776 return getPersistence() 4777 .findByC_ST(companyId, status, start, end, orderByComparator); 4778 } 4779 4780 /** 4781 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 4782 * 4783 * @param companyId the company ID 4784 * @param status the status 4785 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4786 * @return the first matching journal article 4787 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4788 * @throws SystemException if a system exception occurred 4789 */ 4790 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First( 4791 long companyId, int status, 4792 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4793 throws com.liferay.portal.kernel.exception.SystemException, 4794 com.liferay.portlet.journal.NoSuchArticleException { 4795 return getPersistence() 4796 .findByC_ST_First(companyId, status, orderByComparator); 4797 } 4798 4799 /** 4800 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 4801 * 4802 * @param companyId the company ID 4803 * @param status the status 4804 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4805 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4806 * @throws SystemException if a system exception occurred 4807 */ 4808 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First( 4809 long companyId, int status, 4810 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4811 throws com.liferay.portal.kernel.exception.SystemException { 4812 return getPersistence() 4813 .fetchByC_ST_First(companyId, status, orderByComparator); 4814 } 4815 4816 /** 4817 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 4818 * 4819 * @param companyId the company ID 4820 * @param status the status 4821 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4822 * @return the last matching journal article 4823 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4824 * @throws SystemException if a system exception occurred 4825 */ 4826 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last( 4827 long companyId, int status, 4828 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4829 throws com.liferay.portal.kernel.exception.SystemException, 4830 com.liferay.portlet.journal.NoSuchArticleException { 4831 return getPersistence() 4832 .findByC_ST_Last(companyId, status, orderByComparator); 4833 } 4834 4835 /** 4836 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 4837 * 4838 * @param companyId the company ID 4839 * @param status the status 4840 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4841 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4842 * @throws SystemException if a system exception occurred 4843 */ 4844 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last( 4845 long companyId, int status, 4846 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4847 throws com.liferay.portal.kernel.exception.SystemException { 4848 return getPersistence() 4849 .fetchByC_ST_Last(companyId, status, orderByComparator); 4850 } 4851 4852 /** 4853 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status = ?. 4854 * 4855 * @param id the primary key of the current journal article 4856 * @param companyId the company ID 4857 * @param status the status 4858 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4859 * @return the previous, current, and next journal article 4860 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4861 * @throws SystemException if a system exception occurred 4862 */ 4863 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext( 4864 long id, long companyId, int status, 4865 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4866 throws com.liferay.portal.kernel.exception.SystemException, 4867 com.liferay.portlet.journal.NoSuchArticleException { 4868 return getPersistence() 4869 .findByC_ST_PrevAndNext(id, companyId, status, 4870 orderByComparator); 4871 } 4872 4873 /** 4874 * Removes all the journal articles where companyId = ? and status = ? from the database. 4875 * 4876 * @param companyId the company ID 4877 * @param status the status 4878 * @throws SystemException if a system exception occurred 4879 */ 4880 public static void removeByC_ST(long companyId, int status) 4881 throws com.liferay.portal.kernel.exception.SystemException { 4882 getPersistence().removeByC_ST(companyId, status); 4883 } 4884 4885 /** 4886 * Returns the number of journal articles where companyId = ? and status = ?. 4887 * 4888 * @param companyId the company ID 4889 * @param status the status 4890 * @return the number of matching journal articles 4891 * @throws SystemException if a system exception occurred 4892 */ 4893 public static int countByC_ST(long companyId, int status) 4894 throws com.liferay.portal.kernel.exception.SystemException { 4895 return getPersistence().countByC_ST(companyId, status); 4896 } 4897 4898 /** 4899 * Returns all the journal articles where companyId = ? and status ≠ ?. 4900 * 4901 * @param companyId the company ID 4902 * @param status the status 4903 * @return the matching journal articles 4904 * @throws SystemException if a system exception occurred 4905 */ 4906 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4907 long companyId, int status) 4908 throws com.liferay.portal.kernel.exception.SystemException { 4909 return getPersistence().findByC_NotST(companyId, status); 4910 } 4911 4912 /** 4913 * Returns a range of all the journal articles where companyId = ? and status ≠ ?. 4914 * 4915 * <p> 4916 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4917 * </p> 4918 * 4919 * @param companyId the company ID 4920 * @param status the status 4921 * @param start the lower bound of the range of journal articles 4922 * @param end the upper bound of the range of journal articles (not inclusive) 4923 * @return the range of matching journal articles 4924 * @throws SystemException if a system exception occurred 4925 */ 4926 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4927 long companyId, int status, int start, int end) 4928 throws com.liferay.portal.kernel.exception.SystemException { 4929 return getPersistence().findByC_NotST(companyId, status, start, end); 4930 } 4931 4932 /** 4933 * Returns an ordered range of all the journal articles where companyId = ? and status ≠ ?. 4934 * 4935 * <p> 4936 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4937 * </p> 4938 * 4939 * @param companyId the company ID 4940 * @param status the status 4941 * @param start the lower bound of the range of journal articles 4942 * @param end the upper bound of the range of journal articles (not inclusive) 4943 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4944 * @return the ordered range of matching journal articles 4945 * @throws SystemException if a system exception occurred 4946 */ 4947 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4948 long companyId, int status, int start, int end, 4949 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4950 throws com.liferay.portal.kernel.exception.SystemException { 4951 return getPersistence() 4952 .findByC_NotST(companyId, status, start, end, 4953 orderByComparator); 4954 } 4955 4956 /** 4957 * Returns the first journal article in the ordered set where companyId = ? and status ≠ ?. 4958 * 4959 * @param companyId the company ID 4960 * @param status the status 4961 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4962 * @return the first matching journal article 4963 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4964 * @throws SystemException if a system exception occurred 4965 */ 4966 public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_First( 4967 long companyId, int status, 4968 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4969 throws com.liferay.portal.kernel.exception.SystemException, 4970 com.liferay.portlet.journal.NoSuchArticleException { 4971 return getPersistence() 4972 .findByC_NotST_First(companyId, status, orderByComparator); 4973 } 4974 4975 /** 4976 * Returns the first journal article in the ordered set where companyId = ? and status ≠ ?. 4977 * 4978 * @param companyId the company ID 4979 * @param status the status 4980 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4981 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4982 * @throws SystemException if a system exception occurred 4983 */ 4984 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_First( 4985 long companyId, int status, 4986 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4987 throws com.liferay.portal.kernel.exception.SystemException { 4988 return getPersistence() 4989 .fetchByC_NotST_First(companyId, status, orderByComparator); 4990 } 4991 4992 /** 4993 * Returns the last journal article in the ordered set where companyId = ? and status ≠ ?. 4994 * 4995 * @param companyId the company ID 4996 * @param status the status 4997 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4998 * @return the last matching journal article 4999 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5000 * @throws SystemException if a system exception occurred 5001 */ 5002 public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_Last( 5003 long companyId, int status, 5004 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5005 throws com.liferay.portal.kernel.exception.SystemException, 5006 com.liferay.portlet.journal.NoSuchArticleException { 5007 return getPersistence() 5008 .findByC_NotST_Last(companyId, status, orderByComparator); 5009 } 5010 5011 /** 5012 * Returns the last journal article in the ordered set where companyId = ? and status ≠ ?. 5013 * 5014 * @param companyId the company ID 5015 * @param status the status 5016 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5017 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5018 * @throws SystemException if a system exception occurred 5019 */ 5020 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_Last( 5021 long companyId, int status, 5022 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5023 throws com.liferay.portal.kernel.exception.SystemException { 5024 return getPersistence() 5025 .fetchByC_NotST_Last(companyId, status, orderByComparator); 5026 } 5027 5028 /** 5029 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status ≠ ?. 5030 * 5031 * @param id the primary key of the current journal article 5032 * @param companyId the company ID 5033 * @param status the status 5034 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5035 * @return the previous, current, and next journal article 5036 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5037 * @throws SystemException if a system exception occurred 5038 */ 5039 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_NotST_PrevAndNext( 5040 long id, long companyId, int status, 5041 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5042 throws com.liferay.portal.kernel.exception.SystemException, 5043 com.liferay.portlet.journal.NoSuchArticleException { 5044 return getPersistence() 5045 .findByC_NotST_PrevAndNext(id, companyId, status, 5046 orderByComparator); 5047 } 5048 5049 /** 5050 * Removes all the journal articles where companyId = ? and status ≠ ? from the database. 5051 * 5052 * @param companyId the company ID 5053 * @param status the status 5054 * @throws SystemException if a system exception occurred 5055 */ 5056 public static void removeByC_NotST(long companyId, int status) 5057 throws com.liferay.portal.kernel.exception.SystemException { 5058 getPersistence().removeByC_NotST(companyId, status); 5059 } 5060 5061 /** 5062 * Returns the number of journal articles where companyId = ? and status ≠ ?. 5063 * 5064 * @param companyId the company ID 5065 * @param status the status 5066 * @return the number of matching journal articles 5067 * @throws SystemException if a system exception occurred 5068 */ 5069 public static int countByC_NotST(long companyId, int status) 5070 throws com.liferay.portal.kernel.exception.SystemException { 5071 return getPersistence().countByC_NotST(companyId, status); 5072 } 5073 5074 /** 5075 * Returns all the journal articles where displayDate < ? and status = ?. 5076 * 5077 * @param displayDate the display date 5078 * @param status the status 5079 * @return the matching journal articles 5080 * @throws SystemException if a system exception occurred 5081 */ 5082 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5083 java.util.Date displayDate, int status) 5084 throws com.liferay.portal.kernel.exception.SystemException { 5085 return getPersistence().findByLtD_S(displayDate, status); 5086 } 5087 5088 /** 5089 * Returns a range of all the journal articles where displayDate < ? and status = ?. 5090 * 5091 * <p> 5092 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5093 * </p> 5094 * 5095 * @param displayDate the display date 5096 * @param status the status 5097 * @param start the lower bound of the range of journal articles 5098 * @param end the upper bound of the range of journal articles (not inclusive) 5099 * @return the range of matching journal articles 5100 * @throws SystemException if a system exception occurred 5101 */ 5102 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5103 java.util.Date displayDate, int status, int start, int end) 5104 throws com.liferay.portal.kernel.exception.SystemException { 5105 return getPersistence().findByLtD_S(displayDate, status, start, end); 5106 } 5107 5108 /** 5109 * Returns an ordered range of all the journal articles where displayDate < ? and status = ?. 5110 * 5111 * <p> 5112 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5113 * </p> 5114 * 5115 * @param displayDate the display date 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 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5120 * @return the ordered range of matching journal articles 5121 * @throws SystemException if a system exception occurred 5122 */ 5123 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5124 java.util.Date displayDate, int status, int start, int end, 5125 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5126 throws com.liferay.portal.kernel.exception.SystemException { 5127 return getPersistence() 5128 .findByLtD_S(displayDate, status, start, end, 5129 orderByComparator); 5130 } 5131 5132 /** 5133 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 5134 * 5135 * @param displayDate the display date 5136 * @param status the status 5137 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5138 * @return the first matching journal article 5139 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5140 * @throws SystemException if a system exception occurred 5141 */ 5142 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First( 5143 java.util.Date displayDate, int status, 5144 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5145 throws com.liferay.portal.kernel.exception.SystemException, 5146 com.liferay.portlet.journal.NoSuchArticleException { 5147 return getPersistence() 5148 .findByLtD_S_First(displayDate, status, orderByComparator); 5149 } 5150 5151 /** 5152 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 5153 * 5154 * @param displayDate the display date 5155 * @param status the status 5156 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5157 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5158 * @throws SystemException if a system exception occurred 5159 */ 5160 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First( 5161 java.util.Date displayDate, int status, 5162 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5163 throws com.liferay.portal.kernel.exception.SystemException { 5164 return getPersistence() 5165 .fetchByLtD_S_First(displayDate, status, orderByComparator); 5166 } 5167 5168 /** 5169 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 5170 * 5171 * @param displayDate the display date 5172 * @param status the status 5173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5174 * @return the last matching journal article 5175 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5176 * @throws SystemException if a system exception occurred 5177 */ 5178 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_Last( 5179 java.util.Date displayDate, int status, 5180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5181 throws com.liferay.portal.kernel.exception.SystemException, 5182 com.liferay.portlet.journal.NoSuchArticleException { 5183 return getPersistence() 5184 .findByLtD_S_Last(displayDate, status, orderByComparator); 5185 } 5186 5187 /** 5188 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 5189 * 5190 * @param displayDate the display date 5191 * @param status the status 5192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5193 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5194 * @throws SystemException if a system exception occurred 5195 */ 5196 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last( 5197 java.util.Date displayDate, int status, 5198 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5199 throws com.liferay.portal.kernel.exception.SystemException { 5200 return getPersistence() 5201 .fetchByLtD_S_Last(displayDate, status, orderByComparator); 5202 } 5203 5204 /** 5205 * Returns the journal articles before and after the current journal article in the ordered set where displayDate < ? and status = ?. 5206 * 5207 * @param id the primary key of the current journal article 5208 * @param displayDate the display date 5209 * @param status the status 5210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5211 * @return the previous, current, and next journal article 5212 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5213 * @throws SystemException if a system exception occurred 5214 */ 5215 public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext( 5216 long id, java.util.Date displayDate, int status, 5217 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5218 throws com.liferay.portal.kernel.exception.SystemException, 5219 com.liferay.portlet.journal.NoSuchArticleException { 5220 return getPersistence() 5221 .findByLtD_S_PrevAndNext(id, displayDate, status, 5222 orderByComparator); 5223 } 5224 5225 /** 5226 * Removes all the journal articles where displayDate < ? and status = ? from the database. 5227 * 5228 * @param displayDate the display date 5229 * @param status the status 5230 * @throws SystemException if a system exception occurred 5231 */ 5232 public static void removeByLtD_S(java.util.Date displayDate, int status) 5233 throws com.liferay.portal.kernel.exception.SystemException { 5234 getPersistence().removeByLtD_S(displayDate, status); 5235 } 5236 5237 /** 5238 * Returns the number of journal articles where displayDate < ? and status = ?. 5239 * 5240 * @param displayDate the display date 5241 * @param status the status 5242 * @return the number of matching journal articles 5243 * @throws SystemException if a system exception occurred 5244 */ 5245 public static int countByLtD_S(java.util.Date displayDate, int status) 5246 throws com.liferay.portal.kernel.exception.SystemException { 5247 return getPersistence().countByLtD_S(displayDate, status); 5248 } 5249 5250 /** 5251 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5252 * 5253 * @param resourcePrimKey the resource prim key 5254 * @param indexable the indexable 5255 * @param status the status 5256 * @return the matching journal articles 5257 * @throws SystemException if a system exception occurred 5258 */ 5259 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5260 long resourcePrimKey, boolean indexable, int status) 5261 throws com.liferay.portal.kernel.exception.SystemException { 5262 return getPersistence().findByR_I_S(resourcePrimKey, indexable, status); 5263 } 5264 5265 /** 5266 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5267 * 5268 * <p> 5269 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5270 * </p> 5271 * 5272 * @param resourcePrimKey the resource prim key 5273 * @param indexable the indexable 5274 * @param status the status 5275 * @param start the lower bound of the range of journal articles 5276 * @param end the upper bound of the range of journal articles (not inclusive) 5277 * @return the range of matching journal articles 5278 * @throws SystemException if a system exception occurred 5279 */ 5280 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5281 long resourcePrimKey, boolean indexable, int status, int start, int end) 5282 throws com.liferay.portal.kernel.exception.SystemException { 5283 return getPersistence() 5284 .findByR_I_S(resourcePrimKey, indexable, status, start, end); 5285 } 5286 5287 /** 5288 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5289 * 5290 * <p> 5291 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5292 * </p> 5293 * 5294 * @param resourcePrimKey the resource prim key 5295 * @param indexable the indexable 5296 * @param status the status 5297 * @param start the lower bound of the range of journal articles 5298 * @param end the upper bound of the range of journal articles (not inclusive) 5299 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5300 * @return the ordered range of matching journal articles 5301 * @throws SystemException if a system exception occurred 5302 */ 5303 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5304 long resourcePrimKey, boolean indexable, int status, int start, 5305 int end, 5306 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5307 throws com.liferay.portal.kernel.exception.SystemException { 5308 return getPersistence() 5309 .findByR_I_S(resourcePrimKey, indexable, status, start, end, 5310 orderByComparator); 5311 } 5312 5313 /** 5314 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5315 * 5316 * @param resourcePrimKey the resource prim key 5317 * @param indexable the indexable 5318 * @param status the status 5319 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5320 * @return the first matching journal article 5321 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5322 * @throws SystemException if a system exception occurred 5323 */ 5324 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First( 5325 long resourcePrimKey, boolean indexable, int status, 5326 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5327 throws com.liferay.portal.kernel.exception.SystemException, 5328 com.liferay.portlet.journal.NoSuchArticleException { 5329 return getPersistence() 5330 .findByR_I_S_First(resourcePrimKey, indexable, status, 5331 orderByComparator); 5332 } 5333 5334 /** 5335 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5336 * 5337 * @param resourcePrimKey the resource prim key 5338 * @param indexable the indexable 5339 * @param status the status 5340 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5341 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5342 * @throws SystemException if a system exception occurred 5343 */ 5344 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First( 5345 long resourcePrimKey, boolean indexable, int status, 5346 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5347 throws com.liferay.portal.kernel.exception.SystemException { 5348 return getPersistence() 5349 .fetchByR_I_S_First(resourcePrimKey, indexable, status, 5350 orderByComparator); 5351 } 5352 5353 /** 5354 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5355 * 5356 * @param resourcePrimKey the resource prim key 5357 * @param indexable the indexable 5358 * @param status the status 5359 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5360 * @return the last matching journal article 5361 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5362 * @throws SystemException if a system exception occurred 5363 */ 5364 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last( 5365 long resourcePrimKey, boolean indexable, int status, 5366 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5367 throws com.liferay.portal.kernel.exception.SystemException, 5368 com.liferay.portlet.journal.NoSuchArticleException { 5369 return getPersistence() 5370 .findByR_I_S_Last(resourcePrimKey, indexable, status, 5371 orderByComparator); 5372 } 5373 5374 /** 5375 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5376 * 5377 * @param resourcePrimKey the resource prim key 5378 * @param indexable the indexable 5379 * @param status the status 5380 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5381 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5382 * @throws SystemException if a system exception occurred 5383 */ 5384 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last( 5385 long resourcePrimKey, boolean indexable, int status, 5386 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5387 throws com.liferay.portal.kernel.exception.SystemException { 5388 return getPersistence() 5389 .fetchByR_I_S_Last(resourcePrimKey, indexable, status, 5390 orderByComparator); 5391 } 5392 5393 /** 5394 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5395 * 5396 * @param id the primary key of the current journal article 5397 * @param resourcePrimKey the resource prim key 5398 * @param indexable the indexable 5399 * @param status the status 5400 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5401 * @return the previous, current, and next journal article 5402 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5403 * @throws SystemException if a system exception occurred 5404 */ 5405 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext( 5406 long id, long resourcePrimKey, boolean indexable, int status, 5407 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5408 throws com.liferay.portal.kernel.exception.SystemException, 5409 com.liferay.portlet.journal.NoSuchArticleException { 5410 return getPersistence() 5411 .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable, 5412 status, orderByComparator); 5413 } 5414 5415 /** 5416 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5417 * 5418 * <p> 5419 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5420 * </p> 5421 * 5422 * @param resourcePrimKey the resource prim key 5423 * @param indexable the indexable 5424 * @param statuses the statuses 5425 * @return the matching journal articles 5426 * @throws SystemException if a system exception occurred 5427 */ 5428 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5429 long resourcePrimKey, boolean indexable, int[] statuses) 5430 throws com.liferay.portal.kernel.exception.SystemException { 5431 return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses); 5432 } 5433 5434 /** 5435 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5436 * 5437 * <p> 5438 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5439 * </p> 5440 * 5441 * @param resourcePrimKey the resource prim key 5442 * @param indexable the indexable 5443 * @param statuses the statuses 5444 * @param start the lower bound of the range of journal articles 5445 * @param end the upper bound of the range of journal articles (not inclusive) 5446 * @return the range of matching journal articles 5447 * @throws SystemException if a system exception occurred 5448 */ 5449 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5450 long resourcePrimKey, boolean indexable, int[] statuses, int start, 5451 int end) throws com.liferay.portal.kernel.exception.SystemException { 5452 return getPersistence() 5453 .findByR_I_S(resourcePrimKey, indexable, statuses, start, end); 5454 } 5455 5456 /** 5457 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5458 * 5459 * <p> 5460 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5461 * </p> 5462 * 5463 * @param resourcePrimKey the resource prim key 5464 * @param indexable the indexable 5465 * @param statuses the statuses 5466 * @param start the lower bound of the range of journal articles 5467 * @param end the upper bound of the range of journal articles (not inclusive) 5468 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5469 * @return the ordered range of matching journal articles 5470 * @throws SystemException if a system exception occurred 5471 */ 5472 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5473 long resourcePrimKey, boolean indexable, int[] statuses, int start, 5474 int end, 5475 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5476 throws com.liferay.portal.kernel.exception.SystemException { 5477 return getPersistence() 5478 .findByR_I_S(resourcePrimKey, indexable, statuses, start, 5479 end, orderByComparator); 5480 } 5481 5482 /** 5483 * Removes all the journal articles where resourcePrimKey = ? and indexable = ? and status = ? from the database. 5484 * 5485 * @param resourcePrimKey the resource prim key 5486 * @param indexable the indexable 5487 * @param status the status 5488 * @throws SystemException if a system exception occurred 5489 */ 5490 public static void removeByR_I_S(long resourcePrimKey, boolean indexable, 5491 int status) throws com.liferay.portal.kernel.exception.SystemException { 5492 getPersistence().removeByR_I_S(resourcePrimKey, indexable, status); 5493 } 5494 5495 /** 5496 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5497 * 5498 * @param resourcePrimKey the resource prim key 5499 * @param indexable the indexable 5500 * @param status the status 5501 * @return the number of matching journal articles 5502 * @throws SystemException if a system exception occurred 5503 */ 5504 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 5505 int status) throws com.liferay.portal.kernel.exception.SystemException { 5506 return getPersistence().countByR_I_S(resourcePrimKey, indexable, status); 5507 } 5508 5509 /** 5510 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5511 * 5512 * @param resourcePrimKey the resource prim key 5513 * @param indexable the indexable 5514 * @param statuses the statuses 5515 * @return the number of matching journal articles 5516 * @throws SystemException if a system exception occurred 5517 */ 5518 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 5519 int[] statuses) 5520 throws com.liferay.portal.kernel.exception.SystemException { 5521 return getPersistence() 5522 .countByR_I_S(resourcePrimKey, indexable, statuses); 5523 } 5524 5525 /** 5526 * Returns all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5527 * 5528 * @param groupId the group ID 5529 * @param userId the user ID 5530 * @param classNameId the class name ID 5531 * @return the matching journal articles 5532 * @throws SystemException if a system exception occurred 5533 */ 5534 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5535 long groupId, long userId, long classNameId) 5536 throws com.liferay.portal.kernel.exception.SystemException { 5537 return getPersistence().findByG_U_C(groupId, userId, classNameId); 5538 } 5539 5540 /** 5541 * Returns a range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5542 * 5543 * <p> 5544 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5545 * </p> 5546 * 5547 * @param groupId the group ID 5548 * @param userId the user ID 5549 * @param classNameId the class name ID 5550 * @param start the lower bound of the range of journal articles 5551 * @param end the upper bound of the range of journal articles (not inclusive) 5552 * @return the range of matching journal articles 5553 * @throws SystemException if a system exception occurred 5554 */ 5555 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5556 long groupId, long userId, long classNameId, int start, int end) 5557 throws com.liferay.portal.kernel.exception.SystemException { 5558 return getPersistence() 5559 .findByG_U_C(groupId, userId, classNameId, start, end); 5560 } 5561 5562 /** 5563 * Returns an ordered range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5564 * 5565 * <p> 5566 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5567 * </p> 5568 * 5569 * @param groupId the group ID 5570 * @param userId the user ID 5571 * @param classNameId the class name ID 5572 * @param start the lower bound of the range of journal articles 5573 * @param end the upper bound of the range of journal articles (not inclusive) 5574 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5575 * @return the ordered range of matching journal articles 5576 * @throws SystemException if a system exception occurred 5577 */ 5578 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5579 long groupId, long userId, long classNameId, int start, int end, 5580 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5581 throws com.liferay.portal.kernel.exception.SystemException { 5582 return getPersistence() 5583 .findByG_U_C(groupId, userId, classNameId, start, end, 5584 orderByComparator); 5585 } 5586 5587 /** 5588 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5589 * 5590 * @param groupId the group ID 5591 * @param userId the user ID 5592 * @param classNameId the class name ID 5593 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5594 * @return the first matching journal article 5595 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5596 * @throws SystemException if a system exception occurred 5597 */ 5598 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First( 5599 long groupId, long userId, long classNameId, 5600 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5601 throws com.liferay.portal.kernel.exception.SystemException, 5602 com.liferay.portlet.journal.NoSuchArticleException { 5603 return getPersistence() 5604 .findByG_U_C_First(groupId, userId, classNameId, 5605 orderByComparator); 5606 } 5607 5608 /** 5609 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5610 * 5611 * @param groupId the group ID 5612 * @param userId the user ID 5613 * @param classNameId the class name ID 5614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5615 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5616 * @throws SystemException if a system exception occurred 5617 */ 5618 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First( 5619 long groupId, long userId, long classNameId, 5620 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5621 throws com.liferay.portal.kernel.exception.SystemException { 5622 return getPersistence() 5623 .fetchByG_U_C_First(groupId, userId, classNameId, 5624 orderByComparator); 5625 } 5626 5627 /** 5628 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5629 * 5630 * @param groupId the group ID 5631 * @param userId the user ID 5632 * @param classNameId the class name ID 5633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5634 * @return the last matching journal article 5635 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5636 * @throws SystemException if a system exception occurred 5637 */ 5638 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last( 5639 long groupId, long userId, long classNameId, 5640 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5641 throws com.liferay.portal.kernel.exception.SystemException, 5642 com.liferay.portlet.journal.NoSuchArticleException { 5643 return getPersistence() 5644 .findByG_U_C_Last(groupId, userId, classNameId, 5645 orderByComparator); 5646 } 5647 5648 /** 5649 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5650 * 5651 * @param groupId the group ID 5652 * @param userId the user ID 5653 * @param classNameId the class name ID 5654 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5655 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5656 * @throws SystemException if a system exception occurred 5657 */ 5658 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last( 5659 long groupId, long userId, long classNameId, 5660 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5661 throws com.liferay.portal.kernel.exception.SystemException { 5662 return getPersistence() 5663 .fetchByG_U_C_Last(groupId, userId, classNameId, 5664 orderByComparator); 5665 } 5666 5667 /** 5668 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5669 * 5670 * @param id the primary key of the current journal article 5671 * @param groupId the group ID 5672 * @param userId the user ID 5673 * @param classNameId the class name ID 5674 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5675 * @return the previous, current, and next journal article 5676 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5677 * @throws SystemException if a system exception occurred 5678 */ 5679 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext( 5680 long id, long groupId, long userId, long classNameId, 5681 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5682 throws com.liferay.portal.kernel.exception.SystemException, 5683 com.liferay.portlet.journal.NoSuchArticleException { 5684 return getPersistence() 5685 .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId, 5686 orderByComparator); 5687 } 5688 5689 /** 5690 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5691 * 5692 * @param groupId the group ID 5693 * @param userId the user ID 5694 * @param classNameId the class name ID 5695 * @return the matching journal articles that the user has permission to view 5696 * @throws SystemException if a system exception occurred 5697 */ 5698 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5699 long groupId, long userId, long classNameId) 5700 throws com.liferay.portal.kernel.exception.SystemException { 5701 return getPersistence().filterFindByG_U_C(groupId, userId, classNameId); 5702 } 5703 5704 /** 5705 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5706 * 5707 * <p> 5708 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5709 * </p> 5710 * 5711 * @param groupId the group ID 5712 * @param userId the user ID 5713 * @param classNameId the class name ID 5714 * @param start the lower bound of the range of journal articles 5715 * @param end the upper bound of the range of journal articles (not inclusive) 5716 * @return the range of matching journal articles that the user has permission to view 5717 * @throws SystemException if a system exception occurred 5718 */ 5719 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5720 long groupId, long userId, long classNameId, int start, int end) 5721 throws com.liferay.portal.kernel.exception.SystemException { 5722 return getPersistence() 5723 .filterFindByG_U_C(groupId, userId, classNameId, start, end); 5724 } 5725 5726 /** 5727 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ? and classNameId = ?. 5728 * 5729 * <p> 5730 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5731 * </p> 5732 * 5733 * @param groupId the group ID 5734 * @param userId the user ID 5735 * @param classNameId the class name ID 5736 * @param start the lower bound of the range of journal articles 5737 * @param end the upper bound of the range of journal articles (not inclusive) 5738 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5739 * @return the ordered range of matching journal articles that the user has permission to view 5740 * @throws SystemException if a system exception occurred 5741 */ 5742 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5743 long groupId, long userId, long classNameId, int start, int end, 5744 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5745 throws com.liferay.portal.kernel.exception.SystemException { 5746 return getPersistence() 5747 .filterFindByG_U_C(groupId, userId, classNameId, start, end, 5748 orderByComparator); 5749 } 5750 5751 /** 5752 * 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 = ?. 5753 * 5754 * @param id the primary key of the current journal article 5755 * @param groupId the group ID 5756 * @param userId the user ID 5757 * @param classNameId the class name ID 5758 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5759 * @return the previous, current, and next journal article 5760 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5761 * @throws SystemException if a system exception occurred 5762 */ 5763 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext( 5764 long id, long groupId, long userId, long classNameId, 5765 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5766 throws com.liferay.portal.kernel.exception.SystemException, 5767 com.liferay.portlet.journal.NoSuchArticleException { 5768 return getPersistence() 5769 .filterFindByG_U_C_PrevAndNext(id, groupId, userId, 5770 classNameId, orderByComparator); 5771 } 5772 5773 /** 5774 * Removes all the journal articles where groupId = ? and userId = ? and classNameId = ? from the database. 5775 * 5776 * @param groupId the group ID 5777 * @param userId the user ID 5778 * @param classNameId the class name ID 5779 * @throws SystemException if a system exception occurred 5780 */ 5781 public static void removeByG_U_C(long groupId, long userId, long classNameId) 5782 throws com.liferay.portal.kernel.exception.SystemException { 5783 getPersistence().removeByG_U_C(groupId, userId, classNameId); 5784 } 5785 5786 /** 5787 * Returns the number of journal articles where groupId = ? and userId = ? and classNameId = ?. 5788 * 5789 * @param groupId the group ID 5790 * @param userId the user ID 5791 * @param classNameId the class name ID 5792 * @return the number of matching journal articles 5793 * @throws SystemException if a system exception occurred 5794 */ 5795 public static int countByG_U_C(long groupId, long userId, long classNameId) 5796 throws com.liferay.portal.kernel.exception.SystemException { 5797 return getPersistence().countByG_U_C(groupId, userId, classNameId); 5798 } 5799 5800 /** 5801 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5802 * 5803 * @param groupId the group ID 5804 * @param userId the user ID 5805 * @param classNameId the class name ID 5806 * @return the number of matching journal articles that the user has permission to view 5807 * @throws SystemException if a system exception occurred 5808 */ 5809 public static int filterCountByG_U_C(long groupId, long userId, 5810 long classNameId) 5811 throws com.liferay.portal.kernel.exception.SystemException { 5812 return getPersistence().filterCountByG_U_C(groupId, userId, classNameId); 5813 } 5814 5815 /** 5816 * Returns all the journal articles where groupId = ? and folderId = ? and status = ?. 5817 * 5818 * @param groupId the group ID 5819 * @param folderId the folder ID 5820 * @param status the status 5821 * @return the matching journal articles 5822 * @throws SystemException if a system exception occurred 5823 */ 5824 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5825 long groupId, long folderId, int status) 5826 throws com.liferay.portal.kernel.exception.SystemException { 5827 return getPersistence().findByG_F_ST(groupId, folderId, status); 5828 } 5829 5830 /** 5831 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = ?. 5832 * 5833 * <p> 5834 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5835 * </p> 5836 * 5837 * @param groupId the group ID 5838 * @param folderId the folder ID 5839 * @param status the status 5840 * @param start the lower bound of the range of journal articles 5841 * @param end the upper bound of the range of journal articles (not inclusive) 5842 * @return the range of matching journal articles 5843 * @throws SystemException if a system exception occurred 5844 */ 5845 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5846 long groupId, long folderId, int status, int start, int end) 5847 throws com.liferay.portal.kernel.exception.SystemException { 5848 return getPersistence() 5849 .findByG_F_ST(groupId, folderId, status, start, end); 5850 } 5851 5852 /** 5853 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = ?. 5854 * 5855 * <p> 5856 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5857 * </p> 5858 * 5859 * @param groupId the group ID 5860 * @param folderId the folder ID 5861 * @param status the status 5862 * @param start the lower bound of the range of journal articles 5863 * @param end the upper bound of the range of journal articles (not inclusive) 5864 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5865 * @return the ordered range of matching journal articles 5866 * @throws SystemException if a system exception occurred 5867 */ 5868 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5869 long groupId, long folderId, int status, int start, int end, 5870 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5871 throws com.liferay.portal.kernel.exception.SystemException { 5872 return getPersistence() 5873 .findByG_F_ST(groupId, folderId, status, start, end, 5874 orderByComparator); 5875 } 5876 5877 /** 5878 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5879 * 5880 * @param groupId the group ID 5881 * @param folderId the folder ID 5882 * @param status the status 5883 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5884 * @return the first matching journal article 5885 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5886 * @throws SystemException if a system exception occurred 5887 */ 5888 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First( 5889 long groupId, long folderId, int status, 5890 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5891 throws com.liferay.portal.kernel.exception.SystemException, 5892 com.liferay.portlet.journal.NoSuchArticleException { 5893 return getPersistence() 5894 .findByG_F_ST_First(groupId, folderId, status, 5895 orderByComparator); 5896 } 5897 5898 /** 5899 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5900 * 5901 * @param groupId the group ID 5902 * @param folderId the folder ID 5903 * @param status the status 5904 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5905 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5906 * @throws SystemException if a system exception occurred 5907 */ 5908 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First( 5909 long groupId, long folderId, int status, 5910 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5911 throws com.liferay.portal.kernel.exception.SystemException { 5912 return getPersistence() 5913 .fetchByG_F_ST_First(groupId, folderId, status, 5914 orderByComparator); 5915 } 5916 5917 /** 5918 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5919 * 5920 * @param groupId the group ID 5921 * @param folderId the folder ID 5922 * @param status the status 5923 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5924 * @return the last matching journal article 5925 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5926 * @throws SystemException if a system exception occurred 5927 */ 5928 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last( 5929 long groupId, long folderId, int status, 5930 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5931 throws com.liferay.portal.kernel.exception.SystemException, 5932 com.liferay.portlet.journal.NoSuchArticleException { 5933 return getPersistence() 5934 .findByG_F_ST_Last(groupId, folderId, status, 5935 orderByComparator); 5936 } 5937 5938 /** 5939 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5940 * 5941 * @param groupId the group ID 5942 * @param folderId the folder ID 5943 * @param status the status 5944 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5945 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5946 * @throws SystemException if a system exception occurred 5947 */ 5948 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last( 5949 long groupId, long folderId, int status, 5950 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5951 throws com.liferay.portal.kernel.exception.SystemException { 5952 return getPersistence() 5953 .fetchByG_F_ST_Last(groupId, folderId, status, 5954 orderByComparator); 5955 } 5956 5957 /** 5958 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5959 * 5960 * @param id the primary key of the current journal article 5961 * @param groupId the group ID 5962 * @param folderId the folder ID 5963 * @param status the status 5964 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5965 * @return the previous, current, and next journal article 5966 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5967 * @throws SystemException if a system exception occurred 5968 */ 5969 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext( 5970 long id, long groupId, long folderId, int status, 5971 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5972 throws com.liferay.portal.kernel.exception.SystemException, 5973 com.liferay.portlet.journal.NoSuchArticleException { 5974 return getPersistence() 5975 .findByG_F_ST_PrevAndNext(id, groupId, folderId, status, 5976 orderByComparator); 5977 } 5978 5979 /** 5980 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5981 * 5982 * @param groupId the group ID 5983 * @param folderId the folder ID 5984 * @param status the status 5985 * @return the matching journal articles that the user has permission to view 5986 * @throws SystemException if a system exception occurred 5987 */ 5988 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5989 long groupId, long folderId, int status) 5990 throws com.liferay.portal.kernel.exception.SystemException { 5991 return getPersistence().filterFindByG_F_ST(groupId, folderId, status); 5992 } 5993 5994 /** 5995 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5996 * 5997 * <p> 5998 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5999 * </p> 6000 * 6001 * @param groupId the group ID 6002 * @param folderId the folder ID 6003 * @param status the status 6004 * @param start the lower bound of the range of journal articles 6005 * @param end the upper bound of the range of journal articles (not inclusive) 6006 * @return the range of matching journal articles that the user has permission to view 6007 * @throws SystemException if a system exception occurred 6008 */ 6009 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6010 long groupId, long folderId, int status, int start, int end) 6011 throws com.liferay.portal.kernel.exception.SystemException { 6012 return getPersistence() 6013 .filterFindByG_F_ST(groupId, folderId, status, start, end); 6014 } 6015 6016 /** 6017 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 6018 * 6019 * <p> 6020 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6021 * </p> 6022 * 6023 * @param groupId the group ID 6024 * @param folderId the folder ID 6025 * @param status the status 6026 * @param start the lower bound of the range of journal articles 6027 * @param end the upper bound of the range of journal articles (not inclusive) 6028 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6029 * @return the ordered range of matching journal articles that the user has permission to view 6030 * @throws SystemException if a system exception occurred 6031 */ 6032 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6033 long groupId, long folderId, int status, int start, int end, 6034 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6035 throws com.liferay.portal.kernel.exception.SystemException { 6036 return getPersistence() 6037 .filterFindByG_F_ST(groupId, folderId, status, start, end, 6038 orderByComparator); 6039 } 6040 6041 /** 6042 * 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 = ?. 6043 * 6044 * @param id the primary key of the current journal article 6045 * @param groupId the group ID 6046 * @param folderId the folder ID 6047 * @param status the status 6048 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6049 * @return the previous, current, and next journal article 6050 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6051 * @throws SystemException if a system exception occurred 6052 */ 6053 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext( 6054 long id, long groupId, long folderId, int status, 6055 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6056 throws com.liferay.portal.kernel.exception.SystemException, 6057 com.liferay.portlet.journal.NoSuchArticleException { 6058 return getPersistence() 6059 .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId, 6060 status, orderByComparator); 6061 } 6062 6063 /** 6064 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6065 * 6066 * @param groupId the group ID 6067 * @param folderId the folder ID 6068 * @param statuses the statuses 6069 * @return the matching journal articles that the user has permission to view 6070 * @throws SystemException if a system exception occurred 6071 */ 6072 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6073 long groupId, long folderId, int[] statuses) 6074 throws com.liferay.portal.kernel.exception.SystemException { 6075 return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses); 6076 } 6077 6078 /** 6079 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6080 * 6081 * <p> 6082 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6083 * </p> 6084 * 6085 * @param groupId the group ID 6086 * @param folderId the folder ID 6087 * @param statuses the statuses 6088 * @param start the lower bound of the range of journal articles 6089 * @param end the upper bound of the range of journal articles (not inclusive) 6090 * @return the range of matching journal articles that the user has permission to view 6091 * @throws SystemException if a system exception occurred 6092 */ 6093 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6094 long groupId, long folderId, int[] statuses, int start, int end) 6095 throws com.liferay.portal.kernel.exception.SystemException { 6096 return getPersistence() 6097 .filterFindByG_F_ST(groupId, folderId, statuses, start, end); 6098 } 6099 6100 /** 6101 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6102 * 6103 * <p> 6104 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6105 * </p> 6106 * 6107 * @param groupId the group ID 6108 * @param folderId the folder ID 6109 * @param statuses the statuses 6110 * @param start the lower bound of the range of journal articles 6111 * @param end the upper bound of the range of journal articles (not inclusive) 6112 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6113 * @return the ordered range of matching journal articles that the user has permission to view 6114 * @throws SystemException if a system exception occurred 6115 */ 6116 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6117 long groupId, long folderId, int[] statuses, int start, int end, 6118 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6119 throws com.liferay.portal.kernel.exception.SystemException { 6120 return getPersistence() 6121 .filterFindByG_F_ST(groupId, folderId, statuses, start, end, 6122 orderByComparator); 6123 } 6124 6125 /** 6126 * Returns all the journal articles where groupId = ? and folderId = ? and status = any ?. 6127 * 6128 * <p> 6129 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6130 * </p> 6131 * 6132 * @param groupId the group ID 6133 * @param folderId the folder ID 6134 * @param statuses the statuses 6135 * @return the matching journal articles 6136 * @throws SystemException if a system exception occurred 6137 */ 6138 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6139 long groupId, long folderId, int[] statuses) 6140 throws com.liferay.portal.kernel.exception.SystemException { 6141 return getPersistence().findByG_F_ST(groupId, folderId, statuses); 6142 } 6143 6144 /** 6145 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 6146 * 6147 * <p> 6148 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6149 * </p> 6150 * 6151 * @param groupId the group ID 6152 * @param folderId the folder ID 6153 * @param statuses the statuses 6154 * @param start the lower bound of the range of journal articles 6155 * @param end the upper bound of the range of journal articles (not inclusive) 6156 * @return the range of matching journal articles 6157 * @throws SystemException if a system exception occurred 6158 */ 6159 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6160 long groupId, long folderId, int[] statuses, int start, int end) 6161 throws com.liferay.portal.kernel.exception.SystemException { 6162 return getPersistence() 6163 .findByG_F_ST(groupId, folderId, statuses, start, end); 6164 } 6165 6166 /** 6167 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 6168 * 6169 * <p> 6170 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6171 * </p> 6172 * 6173 * @param groupId the group ID 6174 * @param folderId the folder ID 6175 * @param statuses the statuses 6176 * @param start the lower bound of the range of journal articles 6177 * @param end the upper bound of the range of journal articles (not inclusive) 6178 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6179 * @return the ordered range of matching journal articles 6180 * @throws SystemException if a system exception occurred 6181 */ 6182 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6183 long groupId, long folderId, int[] statuses, int start, int end, 6184 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6185 throws com.liferay.portal.kernel.exception.SystemException { 6186 return getPersistence() 6187 .findByG_F_ST(groupId, folderId, statuses, start, end, 6188 orderByComparator); 6189 } 6190 6191 /** 6192 * Removes all the journal articles where groupId = ? and folderId = ? and status = ? from the database. 6193 * 6194 * @param groupId the group ID 6195 * @param folderId the folder ID 6196 * @param status the status 6197 * @throws SystemException if a system exception occurred 6198 */ 6199 public static void removeByG_F_ST(long groupId, long folderId, int status) 6200 throws com.liferay.portal.kernel.exception.SystemException { 6201 getPersistence().removeByG_F_ST(groupId, folderId, status); 6202 } 6203 6204 /** 6205 * Returns the number of journal articles where groupId = ? and folderId = ? and status = ?. 6206 * 6207 * @param groupId the group ID 6208 * @param folderId the folder ID 6209 * @param status the status 6210 * @return the number of matching journal articles 6211 * @throws SystemException if a system exception occurred 6212 */ 6213 public static int countByG_F_ST(long groupId, long folderId, int status) 6214 throws com.liferay.portal.kernel.exception.SystemException { 6215 return getPersistence().countByG_F_ST(groupId, folderId, status); 6216 } 6217 6218 /** 6219 * Returns the number of journal articles where groupId = ? and folderId = ? and status = any ?. 6220 * 6221 * @param groupId the group ID 6222 * @param folderId the folder ID 6223 * @param statuses the statuses 6224 * @return the number of matching journal articles 6225 * @throws SystemException if a system exception occurred 6226 */ 6227 public static int countByG_F_ST(long groupId, long folderId, int[] statuses) 6228 throws com.liferay.portal.kernel.exception.SystemException { 6229 return getPersistence().countByG_F_ST(groupId, folderId, statuses); 6230 } 6231 6232 /** 6233 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 6234 * 6235 * @param groupId the group ID 6236 * @param folderId the folder ID 6237 * @param status the status 6238 * @return the number of matching journal articles that the user has permission to view 6239 * @throws SystemException if a system exception occurred 6240 */ 6241 public static int filterCountByG_F_ST(long groupId, long folderId, 6242 int status) throws com.liferay.portal.kernel.exception.SystemException { 6243 return getPersistence().filterCountByG_F_ST(groupId, folderId, status); 6244 } 6245 6246 /** 6247 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6248 * 6249 * @param groupId the group ID 6250 * @param folderId the folder ID 6251 * @param statuses the statuses 6252 * @return the number of matching journal articles that the user has permission to view 6253 * @throws SystemException if a system exception occurred 6254 */ 6255 public static int filterCountByG_F_ST(long groupId, long folderId, 6256 int[] statuses) 6257 throws com.liferay.portal.kernel.exception.SystemException { 6258 return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses); 6259 } 6260 6261 /** 6262 * Returns all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6263 * 6264 * @param groupId the group ID 6265 * @param classNameId the class name ID 6266 * @param classPK the class p k 6267 * @return the matching journal articles 6268 * @throws SystemException if a system exception occurred 6269 */ 6270 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6271 long groupId, long classNameId, long classPK) 6272 throws com.liferay.portal.kernel.exception.SystemException { 6273 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 6274 } 6275 6276 /** 6277 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6278 * 6279 * <p> 6280 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6281 * </p> 6282 * 6283 * @param groupId the group ID 6284 * @param classNameId the class name ID 6285 * @param classPK the class p k 6286 * @param start the lower bound of the range of journal articles 6287 * @param end the upper bound of the range of journal articles (not inclusive) 6288 * @return the range of matching journal articles 6289 * @throws SystemException if a system exception occurred 6290 */ 6291 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6292 long groupId, long classNameId, long classPK, int start, int end) 6293 throws com.liferay.portal.kernel.exception.SystemException { 6294 return getPersistence() 6295 .findByG_C_C(groupId, classNameId, classPK, start, end); 6296 } 6297 6298 /** 6299 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6300 * 6301 * <p> 6302 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6303 * </p> 6304 * 6305 * @param groupId the group ID 6306 * @param classNameId the class name ID 6307 * @param classPK the class p k 6308 * @param start the lower bound of the range of journal articles 6309 * @param end the upper bound of the range of journal articles (not inclusive) 6310 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6311 * @return the ordered range of matching journal articles 6312 * @throws SystemException if a system exception occurred 6313 */ 6314 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6315 long groupId, long classNameId, long classPK, int start, int end, 6316 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6317 throws com.liferay.portal.kernel.exception.SystemException { 6318 return getPersistence() 6319 .findByG_C_C(groupId, classNameId, classPK, start, end, 6320 orderByComparator); 6321 } 6322 6323 /** 6324 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6325 * 6326 * @param groupId the group ID 6327 * @param classNameId the class name ID 6328 * @param classPK the class p k 6329 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6330 * @return the first matching journal article 6331 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6332 * @throws SystemException if a system exception occurred 6333 */ 6334 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First( 6335 long groupId, long classNameId, long classPK, 6336 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6337 throws com.liferay.portal.kernel.exception.SystemException, 6338 com.liferay.portlet.journal.NoSuchArticleException { 6339 return getPersistence() 6340 .findByG_C_C_First(groupId, classNameId, classPK, 6341 orderByComparator); 6342 } 6343 6344 /** 6345 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6346 * 6347 * @param groupId the group ID 6348 * @param classNameId the class name ID 6349 * @param classPK the class p k 6350 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6351 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6352 * @throws SystemException if a system exception occurred 6353 */ 6354 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First( 6355 long groupId, long classNameId, long classPK, 6356 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6357 throws com.liferay.portal.kernel.exception.SystemException { 6358 return getPersistence() 6359 .fetchByG_C_C_First(groupId, classNameId, classPK, 6360 orderByComparator); 6361 } 6362 6363 /** 6364 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6365 * 6366 * @param groupId the group ID 6367 * @param classNameId the class name ID 6368 * @param classPK the class p k 6369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6370 * @return the last matching journal article 6371 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6372 * @throws SystemException if a system exception occurred 6373 */ 6374 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last( 6375 long groupId, long classNameId, long classPK, 6376 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6377 throws com.liferay.portal.kernel.exception.SystemException, 6378 com.liferay.portlet.journal.NoSuchArticleException { 6379 return getPersistence() 6380 .findByG_C_C_Last(groupId, classNameId, classPK, 6381 orderByComparator); 6382 } 6383 6384 /** 6385 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6386 * 6387 * @param groupId the group ID 6388 * @param classNameId the class name ID 6389 * @param classPK the class p k 6390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6391 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6392 * @throws SystemException if a system exception occurred 6393 */ 6394 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last( 6395 long groupId, long classNameId, long classPK, 6396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6397 throws com.liferay.portal.kernel.exception.SystemException { 6398 return getPersistence() 6399 .fetchByG_C_C_Last(groupId, classNameId, classPK, 6400 orderByComparator); 6401 } 6402 6403 /** 6404 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6405 * 6406 * @param id the primary key of the current journal article 6407 * @param groupId the group ID 6408 * @param classNameId the class name ID 6409 * @param classPK the class p k 6410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6411 * @return the previous, current, and next journal article 6412 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6413 * @throws SystemException if a system exception occurred 6414 */ 6415 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext( 6416 long id, long groupId, long classNameId, long classPK, 6417 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6418 throws com.liferay.portal.kernel.exception.SystemException, 6419 com.liferay.portlet.journal.NoSuchArticleException { 6420 return getPersistence() 6421 .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK, 6422 orderByComparator); 6423 } 6424 6425 /** 6426 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6427 * 6428 * @param groupId the group ID 6429 * @param classNameId the class name ID 6430 * @param classPK the class p k 6431 * @return the matching journal articles that the user has permission to view 6432 * @throws SystemException if a system exception occurred 6433 */ 6434 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6435 long groupId, long classNameId, long classPK) 6436 throws com.liferay.portal.kernel.exception.SystemException { 6437 return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK); 6438 } 6439 6440 /** 6441 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6442 * 6443 * <p> 6444 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6445 * </p> 6446 * 6447 * @param groupId the group ID 6448 * @param classNameId the class name ID 6449 * @param classPK the class p k 6450 * @param start the lower bound of the range of journal articles 6451 * @param end the upper bound of the range of journal articles (not inclusive) 6452 * @return the range of matching journal articles that the user has permission to view 6453 * @throws SystemException if a system exception occurred 6454 */ 6455 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6456 long groupId, long classNameId, long classPK, int start, int end) 6457 throws com.liferay.portal.kernel.exception.SystemException { 6458 return getPersistence() 6459 .filterFindByG_C_C(groupId, classNameId, classPK, start, end); 6460 } 6461 6462 /** 6463 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and classPK = ?. 6464 * 6465 * <p> 6466 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6467 * </p> 6468 * 6469 * @param groupId the group ID 6470 * @param classNameId the class name ID 6471 * @param classPK the class p k 6472 * @param start the lower bound of the range of journal articles 6473 * @param end the upper bound of the range of journal articles (not inclusive) 6474 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6475 * @return the ordered range of matching journal articles that the user has permission to view 6476 * @throws SystemException if a system exception occurred 6477 */ 6478 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6479 long groupId, long classNameId, long classPK, int start, int end, 6480 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6481 throws com.liferay.portal.kernel.exception.SystemException { 6482 return getPersistence() 6483 .filterFindByG_C_C(groupId, classNameId, classPK, start, 6484 end, orderByComparator); 6485 } 6486 6487 /** 6488 * 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 = ?. 6489 * 6490 * @param id the primary key of the current journal article 6491 * @param groupId the group ID 6492 * @param classNameId the class name ID 6493 * @param classPK the class p k 6494 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6495 * @return the previous, current, and next journal article 6496 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6497 * @throws SystemException if a system exception occurred 6498 */ 6499 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext( 6500 long id, long groupId, long classNameId, long classPK, 6501 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6502 throws com.liferay.portal.kernel.exception.SystemException, 6503 com.liferay.portlet.journal.NoSuchArticleException { 6504 return getPersistence() 6505 .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId, 6506 classPK, orderByComparator); 6507 } 6508 6509 /** 6510 * Removes all the journal articles where groupId = ? and classNameId = ? and classPK = ? from the database. 6511 * 6512 * @param groupId the group ID 6513 * @param classNameId the class name ID 6514 * @param classPK the class p k 6515 * @throws SystemException if a system exception occurred 6516 */ 6517 public static void removeByG_C_C(long groupId, long classNameId, 6518 long classPK) 6519 throws com.liferay.portal.kernel.exception.SystemException { 6520 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 6521 } 6522 6523 /** 6524 * Returns the number of journal articles where groupId = ? and classNameId = ? and classPK = ?. 6525 * 6526 * @param groupId the group ID 6527 * @param classNameId the class name ID 6528 * @param classPK the class p k 6529 * @return the number of matching journal articles 6530 * @throws SystemException if a system exception occurred 6531 */ 6532 public static int countByG_C_C(long groupId, long classNameId, long classPK) 6533 throws com.liferay.portal.kernel.exception.SystemException { 6534 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 6535 } 6536 6537 /** 6538 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6539 * 6540 * @param groupId the group ID 6541 * @param classNameId the class name ID 6542 * @param classPK the class p k 6543 * @return the number of matching journal articles that the user has permission to view 6544 * @throws SystemException if a system exception occurred 6545 */ 6546 public static int filterCountByG_C_C(long groupId, long classNameId, 6547 long classPK) 6548 throws com.liferay.portal.kernel.exception.SystemException { 6549 return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK); 6550 } 6551 6552 /** 6553 * 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. 6554 * 6555 * @param groupId the group ID 6556 * @param classNameId the class name ID 6557 * @param structureId the structure ID 6558 * @return the matching journal article 6559 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6560 * @throws SystemException if a system exception occurred 6561 */ 6562 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S( 6563 long groupId, long classNameId, java.lang.String structureId) 6564 throws com.liferay.portal.kernel.exception.SystemException, 6565 com.liferay.portlet.journal.NoSuchArticleException { 6566 return getPersistence().findByG_C_S(groupId, classNameId, structureId); 6567 } 6568 6569 /** 6570 * 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. 6571 * 6572 * @param groupId the group ID 6573 * @param classNameId the class name ID 6574 * @param structureId the structure ID 6575 * @return the matching journal article, or <code>null</code> 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 fetchByG_C_S( 6579 long groupId, long classNameId, java.lang.String structureId) 6580 throws com.liferay.portal.kernel.exception.SystemException { 6581 return getPersistence().fetchByG_C_S(groupId, classNameId, structureId); 6582 } 6583 6584 /** 6585 * 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. 6586 * 6587 * @param groupId the group ID 6588 * @param classNameId the class name ID 6589 * @param structureId the structure ID 6590 * @param retrieveFromCache whether to use the finder cache 6591 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6592 * @throws SystemException if a system exception occurred 6593 */ 6594 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 6595 long groupId, long classNameId, java.lang.String structureId, 6596 boolean retrieveFromCache) 6597 throws com.liferay.portal.kernel.exception.SystemException { 6598 return getPersistence() 6599 .fetchByG_C_S(groupId, classNameId, structureId, 6600 retrieveFromCache); 6601 } 6602 6603 /** 6604 * Removes the journal article where groupId = ? and classNameId = ? and structureId = ? from the database. 6605 * 6606 * @param groupId the group ID 6607 * @param classNameId the class name ID 6608 * @param structureId the structure ID 6609 * @return the journal article that was removed 6610 * @throws SystemException if a system exception occurred 6611 */ 6612 public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S( 6613 long groupId, long classNameId, java.lang.String structureId) 6614 throws com.liferay.portal.kernel.exception.SystemException, 6615 com.liferay.portlet.journal.NoSuchArticleException { 6616 return getPersistence().removeByG_C_S(groupId, classNameId, structureId); 6617 } 6618 6619 /** 6620 * Returns the number of journal articles where groupId = ? and classNameId = ? and structureId = ?. 6621 * 6622 * @param groupId the group ID 6623 * @param classNameId the class name ID 6624 * @param structureId the structure ID 6625 * @return the number of matching journal articles 6626 * @throws SystemException if a system exception occurred 6627 */ 6628 public static int countByG_C_S(long groupId, long classNameId, 6629 java.lang.String structureId) 6630 throws com.liferay.portal.kernel.exception.SystemException { 6631 return getPersistence().countByG_C_S(groupId, classNameId, structureId); 6632 } 6633 6634 /** 6635 * Returns all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6636 * 6637 * @param groupId the group ID 6638 * @param classNameId the class name ID 6639 * @param templateId the template ID 6640 * @return the matching journal articles 6641 * @throws SystemException if a system exception occurred 6642 */ 6643 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6644 long groupId, long classNameId, java.lang.String templateId) 6645 throws com.liferay.portal.kernel.exception.SystemException { 6646 return getPersistence().findByG_C_T(groupId, classNameId, templateId); 6647 } 6648 6649 /** 6650 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6651 * 6652 * <p> 6653 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6654 * </p> 6655 * 6656 * @param groupId the group ID 6657 * @param classNameId the class name ID 6658 * @param templateId the template ID 6659 * @param start the lower bound of the range of journal articles 6660 * @param end the upper bound of the range of journal articles (not inclusive) 6661 * @return the range of matching journal articles 6662 * @throws SystemException if a system exception occurred 6663 */ 6664 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6665 long groupId, long classNameId, java.lang.String templateId, int start, 6666 int end) throws com.liferay.portal.kernel.exception.SystemException { 6667 return getPersistence() 6668 .findByG_C_T(groupId, classNameId, templateId, start, end); 6669 } 6670 6671 /** 6672 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6673 * 6674 * <p> 6675 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6676 * </p> 6677 * 6678 * @param groupId the group ID 6679 * @param classNameId the class name ID 6680 * @param templateId the template ID 6681 * @param start the lower bound of the range of journal articles 6682 * @param end the upper bound of the range of journal articles (not inclusive) 6683 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6684 * @return the ordered range of matching journal articles 6685 * @throws SystemException if a system exception occurred 6686 */ 6687 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6688 long groupId, long classNameId, java.lang.String templateId, int start, 6689 int end, 6690 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6691 throws com.liferay.portal.kernel.exception.SystemException { 6692 return getPersistence() 6693 .findByG_C_T(groupId, classNameId, templateId, start, end, 6694 orderByComparator); 6695 } 6696 6697 /** 6698 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6699 * 6700 * @param groupId the group ID 6701 * @param classNameId the class name ID 6702 * @param templateId the template ID 6703 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6704 * @return the first matching journal article 6705 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6706 * @throws SystemException if a system exception occurred 6707 */ 6708 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First( 6709 long groupId, long classNameId, java.lang.String templateId, 6710 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6711 throws com.liferay.portal.kernel.exception.SystemException, 6712 com.liferay.portlet.journal.NoSuchArticleException { 6713 return getPersistence() 6714 .findByG_C_T_First(groupId, classNameId, templateId, 6715 orderByComparator); 6716 } 6717 6718 /** 6719 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6720 * 6721 * @param groupId the group ID 6722 * @param classNameId the class name ID 6723 * @param templateId the template ID 6724 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6725 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6726 * @throws SystemException if a system exception occurred 6727 */ 6728 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First( 6729 long groupId, long classNameId, java.lang.String templateId, 6730 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6731 throws com.liferay.portal.kernel.exception.SystemException { 6732 return getPersistence() 6733 .fetchByG_C_T_First(groupId, classNameId, templateId, 6734 orderByComparator); 6735 } 6736 6737 /** 6738 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6739 * 6740 * @param groupId the group ID 6741 * @param classNameId the class name ID 6742 * @param templateId the template ID 6743 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6744 * @return the last matching journal article 6745 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6746 * @throws SystemException if a system exception occurred 6747 */ 6748 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last( 6749 long groupId, long classNameId, java.lang.String templateId, 6750 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6751 throws com.liferay.portal.kernel.exception.SystemException, 6752 com.liferay.portlet.journal.NoSuchArticleException { 6753 return getPersistence() 6754 .findByG_C_T_Last(groupId, classNameId, templateId, 6755 orderByComparator); 6756 } 6757 6758 /** 6759 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6760 * 6761 * @param groupId the group ID 6762 * @param classNameId the class name ID 6763 * @param templateId the template ID 6764 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6765 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6766 * @throws SystemException if a system exception occurred 6767 */ 6768 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last( 6769 long groupId, long classNameId, java.lang.String templateId, 6770 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6771 throws com.liferay.portal.kernel.exception.SystemException { 6772 return getPersistence() 6773 .fetchByG_C_T_Last(groupId, classNameId, templateId, 6774 orderByComparator); 6775 } 6776 6777 /** 6778 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6779 * 6780 * @param id the primary key of the current journal article 6781 * @param groupId the group ID 6782 * @param classNameId the class name ID 6783 * @param templateId the template ID 6784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6785 * @return the previous, current, and next journal article 6786 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6787 * @throws SystemException if a system exception occurred 6788 */ 6789 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext( 6790 long id, long groupId, long classNameId, java.lang.String templateId, 6791 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6792 throws com.liferay.portal.kernel.exception.SystemException, 6793 com.liferay.portlet.journal.NoSuchArticleException { 6794 return getPersistence() 6795 .findByG_C_T_PrevAndNext(id, groupId, classNameId, 6796 templateId, orderByComparator); 6797 } 6798 6799 /** 6800 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6801 * 6802 * @param groupId the group ID 6803 * @param classNameId the class name ID 6804 * @param templateId the template ID 6805 * @return the matching journal articles that the user has permission to view 6806 * @throws SystemException if a system exception occurred 6807 */ 6808 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6809 long groupId, long classNameId, java.lang.String templateId) 6810 throws com.liferay.portal.kernel.exception.SystemException { 6811 return getPersistence() 6812 .filterFindByG_C_T(groupId, classNameId, templateId); 6813 } 6814 6815 /** 6816 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6817 * 6818 * <p> 6819 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6820 * </p> 6821 * 6822 * @param groupId the group ID 6823 * @param classNameId the class name ID 6824 * @param templateId the template ID 6825 * @param start the lower bound of the range of journal articles 6826 * @param end the upper bound of the range of journal articles (not inclusive) 6827 * @return the range of matching journal articles that the user has permission to view 6828 * @throws SystemException if a system exception occurred 6829 */ 6830 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6831 long groupId, long classNameId, java.lang.String templateId, int start, 6832 int end) throws com.liferay.portal.kernel.exception.SystemException { 6833 return getPersistence() 6834 .filterFindByG_C_T(groupId, classNameId, templateId, start, 6835 end); 6836 } 6837 6838 /** 6839 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and templateId = ?. 6840 * 6841 * <p> 6842 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6843 * </p> 6844 * 6845 * @param groupId the group ID 6846 * @param classNameId the class name ID 6847 * @param templateId the template ID 6848 * @param start the lower bound of the range of journal articles 6849 * @param end the upper bound of the range of journal articles (not inclusive) 6850 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6851 * @return the ordered range of matching journal articles that the user has permission to view 6852 * @throws SystemException if a system exception occurred 6853 */ 6854 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6855 long groupId, long classNameId, java.lang.String templateId, int start, 6856 int end, 6857 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6858 throws com.liferay.portal.kernel.exception.SystemException { 6859 return getPersistence() 6860 .filterFindByG_C_T(groupId, classNameId, templateId, start, 6861 end, orderByComparator); 6862 } 6863 6864 /** 6865 * 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 = ?. 6866 * 6867 * @param id the primary key of the current journal article 6868 * @param groupId the group ID 6869 * @param classNameId the class name ID 6870 * @param templateId the template ID 6871 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6872 * @return the previous, current, and next journal article 6873 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6874 * @throws SystemException if a system exception occurred 6875 */ 6876 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext( 6877 long id, long groupId, long classNameId, java.lang.String templateId, 6878 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6879 throws com.liferay.portal.kernel.exception.SystemException, 6880 com.liferay.portlet.journal.NoSuchArticleException { 6881 return getPersistence() 6882 .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId, 6883 templateId, orderByComparator); 6884 } 6885 6886 /** 6887 * Removes all the journal articles where groupId = ? and classNameId = ? and templateId = ? from the database. 6888 * 6889 * @param groupId the group ID 6890 * @param classNameId the class name ID 6891 * @param templateId the template ID 6892 * @throws SystemException if a system exception occurred 6893 */ 6894 public static void removeByG_C_T(long groupId, long classNameId, 6895 java.lang.String templateId) 6896 throws com.liferay.portal.kernel.exception.SystemException { 6897 getPersistence().removeByG_C_T(groupId, classNameId, templateId); 6898 } 6899 6900 /** 6901 * Returns the number of journal articles where groupId = ? and classNameId = ? and templateId = ?. 6902 * 6903 * @param groupId the group ID 6904 * @param classNameId the class name ID 6905 * @param templateId the template ID 6906 * @return the number of matching journal articles 6907 * @throws SystemException if a system exception occurred 6908 */ 6909 public static int countByG_C_T(long groupId, long classNameId, 6910 java.lang.String templateId) 6911 throws com.liferay.portal.kernel.exception.SystemException { 6912 return getPersistence().countByG_C_T(groupId, classNameId, templateId); 6913 } 6914 6915 /** 6916 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6917 * 6918 * @param groupId the group ID 6919 * @param classNameId the class name ID 6920 * @param templateId the template ID 6921 * @return the number of matching journal articles that the user has permission to view 6922 * @throws SystemException if a system exception occurred 6923 */ 6924 public static int filterCountByG_C_T(long groupId, long classNameId, 6925 java.lang.String templateId) 6926 throws com.liferay.portal.kernel.exception.SystemException { 6927 return getPersistence() 6928 .filterCountByG_C_T(groupId, classNameId, templateId); 6929 } 6930 6931 /** 6932 * Returns all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6933 * 6934 * @param groupId the group ID 6935 * @param classNameId the class name ID 6936 * @param layoutUuid the layout uuid 6937 * @return the matching journal articles 6938 * @throws SystemException if a system exception occurred 6939 */ 6940 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6941 long groupId, long classNameId, java.lang.String layoutUuid) 6942 throws com.liferay.portal.kernel.exception.SystemException { 6943 return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid); 6944 } 6945 6946 /** 6947 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6948 * 6949 * <p> 6950 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6951 * </p> 6952 * 6953 * @param groupId the group ID 6954 * @param classNameId the class name ID 6955 * @param layoutUuid the layout uuid 6956 * @param start the lower bound of the range of journal articles 6957 * @param end the upper bound of the range of journal articles (not inclusive) 6958 * @return the range of matching journal articles 6959 * @throws SystemException if a system exception occurred 6960 */ 6961 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6962 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6963 int end) throws com.liferay.portal.kernel.exception.SystemException { 6964 return getPersistence() 6965 .findByG_C_L(groupId, classNameId, layoutUuid, start, end); 6966 } 6967 6968 /** 6969 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6970 * 6971 * <p> 6972 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6973 * </p> 6974 * 6975 * @param groupId the group ID 6976 * @param classNameId the class name ID 6977 * @param layoutUuid the layout uuid 6978 * @param start the lower bound of the range of journal articles 6979 * @param end the upper bound of the range of journal articles (not inclusive) 6980 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6981 * @return the ordered range of matching journal articles 6982 * @throws SystemException if a system exception occurred 6983 */ 6984 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6985 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6986 int end, 6987 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6988 throws com.liferay.portal.kernel.exception.SystemException { 6989 return getPersistence() 6990 .findByG_C_L(groupId, classNameId, layoutUuid, start, end, 6991 orderByComparator); 6992 } 6993 6994 /** 6995 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6996 * 6997 * @param groupId the group ID 6998 * @param classNameId the class name ID 6999 * @param layoutUuid the layout uuid 7000 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7001 * @return the first matching journal article 7002 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7003 * @throws SystemException if a system exception occurred 7004 */ 7005 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First( 7006 long groupId, long classNameId, java.lang.String layoutUuid, 7007 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7008 throws com.liferay.portal.kernel.exception.SystemException, 7009 com.liferay.portlet.journal.NoSuchArticleException { 7010 return getPersistence() 7011 .findByG_C_L_First(groupId, classNameId, layoutUuid, 7012 orderByComparator); 7013 } 7014 7015 /** 7016 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7017 * 7018 * @param groupId the group ID 7019 * @param classNameId the class name ID 7020 * @param layoutUuid the layout uuid 7021 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7022 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7023 * @throws SystemException if a system exception occurred 7024 */ 7025 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First( 7026 long groupId, long classNameId, java.lang.String layoutUuid, 7027 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7028 throws com.liferay.portal.kernel.exception.SystemException { 7029 return getPersistence() 7030 .fetchByG_C_L_First(groupId, classNameId, layoutUuid, 7031 orderByComparator); 7032 } 7033 7034 /** 7035 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7036 * 7037 * @param groupId the group ID 7038 * @param classNameId the class name ID 7039 * @param layoutUuid the layout uuid 7040 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7041 * @return the last matching journal article 7042 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7043 * @throws SystemException if a system exception occurred 7044 */ 7045 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last( 7046 long groupId, long classNameId, java.lang.String layoutUuid, 7047 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7048 throws com.liferay.portal.kernel.exception.SystemException, 7049 com.liferay.portlet.journal.NoSuchArticleException { 7050 return getPersistence() 7051 .findByG_C_L_Last(groupId, classNameId, layoutUuid, 7052 orderByComparator); 7053 } 7054 7055 /** 7056 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7057 * 7058 * @param groupId the group ID 7059 * @param classNameId the class name ID 7060 * @param layoutUuid the layout uuid 7061 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7062 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7063 * @throws SystemException if a system exception occurred 7064 */ 7065 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last( 7066 long groupId, long classNameId, java.lang.String layoutUuid, 7067 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7068 throws com.liferay.portal.kernel.exception.SystemException { 7069 return getPersistence() 7070 .fetchByG_C_L_Last(groupId, classNameId, layoutUuid, 7071 orderByComparator); 7072 } 7073 7074 /** 7075 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7076 * 7077 * @param id the primary key of the current journal article 7078 * @param groupId the group ID 7079 * @param classNameId the class name ID 7080 * @param layoutUuid the layout uuid 7081 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7082 * @return the previous, current, and next journal article 7083 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7084 * @throws SystemException if a system exception occurred 7085 */ 7086 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext( 7087 long id, long groupId, long classNameId, java.lang.String layoutUuid, 7088 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7089 throws com.liferay.portal.kernel.exception.SystemException, 7090 com.liferay.portlet.journal.NoSuchArticleException { 7091 return getPersistence() 7092 .findByG_C_L_PrevAndNext(id, groupId, classNameId, 7093 layoutUuid, orderByComparator); 7094 } 7095 7096 /** 7097 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7098 * 7099 * @param groupId the group ID 7100 * @param classNameId the class name ID 7101 * @param layoutUuid the layout uuid 7102 * @return the matching journal articles that the user has permission to view 7103 * @throws SystemException if a system exception occurred 7104 */ 7105 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7106 long groupId, long classNameId, java.lang.String layoutUuid) 7107 throws com.liferay.portal.kernel.exception.SystemException { 7108 return getPersistence() 7109 .filterFindByG_C_L(groupId, classNameId, layoutUuid); 7110 } 7111 7112 /** 7113 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7114 * 7115 * <p> 7116 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7117 * </p> 7118 * 7119 * @param groupId the group ID 7120 * @param classNameId the class name ID 7121 * @param layoutUuid the layout uuid 7122 * @param start the lower bound of the range of journal articles 7123 * @param end the upper bound of the range of journal articles (not inclusive) 7124 * @return the range of matching journal articles that the user has permission to view 7125 * @throws SystemException if a system exception occurred 7126 */ 7127 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7128 long groupId, long classNameId, java.lang.String layoutUuid, int start, 7129 int end) throws com.liferay.portal.kernel.exception.SystemException { 7130 return getPersistence() 7131 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 7132 end); 7133 } 7134 7135 /** 7136 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7137 * 7138 * <p> 7139 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7140 * </p> 7141 * 7142 * @param groupId the group ID 7143 * @param classNameId the class name ID 7144 * @param layoutUuid the layout uuid 7145 * @param start the lower bound of the range of journal articles 7146 * @param end the upper bound of the range of journal articles (not inclusive) 7147 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7148 * @return the ordered range of matching journal articles that the user has permission to view 7149 * @throws SystemException if a system exception occurred 7150 */ 7151 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7152 long groupId, long classNameId, java.lang.String layoutUuid, int start, 7153 int end, 7154 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7155 throws com.liferay.portal.kernel.exception.SystemException { 7156 return getPersistence() 7157 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 7158 end, orderByComparator); 7159 } 7160 7161 /** 7162 * 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 = ?. 7163 * 7164 * @param id the primary key of the current journal article 7165 * @param groupId the group ID 7166 * @param classNameId the class name ID 7167 * @param layoutUuid the layout uuid 7168 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7169 * @return the previous, current, and next journal article 7170 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7171 * @throws SystemException if a system exception occurred 7172 */ 7173 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext( 7174 long id, long groupId, long classNameId, java.lang.String layoutUuid, 7175 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7176 throws com.liferay.portal.kernel.exception.SystemException, 7177 com.liferay.portlet.journal.NoSuchArticleException { 7178 return getPersistence() 7179 .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId, 7180 layoutUuid, orderByComparator); 7181 } 7182 7183 /** 7184 * Removes all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ? from the database. 7185 * 7186 * @param groupId the group ID 7187 * @param classNameId the class name ID 7188 * @param layoutUuid the layout uuid 7189 * @throws SystemException if a system exception occurred 7190 */ 7191 public static void removeByG_C_L(long groupId, long classNameId, 7192 java.lang.String layoutUuid) 7193 throws com.liferay.portal.kernel.exception.SystemException { 7194 getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid); 7195 } 7196 7197 /** 7198 * Returns the number of journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 7199 * 7200 * @param groupId the group ID 7201 * @param classNameId the class name ID 7202 * @param layoutUuid the layout uuid 7203 * @return the number of matching journal articles 7204 * @throws SystemException if a system exception occurred 7205 */ 7206 public static int countByG_C_L(long groupId, long classNameId, 7207 java.lang.String layoutUuid) 7208 throws com.liferay.portal.kernel.exception.SystemException { 7209 return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid); 7210 } 7211 7212 /** 7213 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7214 * 7215 * @param groupId the group ID 7216 * @param classNameId the class name ID 7217 * @param layoutUuid the layout uuid 7218 * @return the number of matching journal articles that the user has permission to view 7219 * @throws SystemException if a system exception occurred 7220 */ 7221 public static int filterCountByG_C_L(long groupId, long classNameId, 7222 java.lang.String layoutUuid) 7223 throws com.liferay.portal.kernel.exception.SystemException { 7224 return getPersistence() 7225 .filterCountByG_C_L(groupId, classNameId, layoutUuid); 7226 } 7227 7228 /** 7229 * 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. 7230 * 7231 * @param groupId the group ID 7232 * @param articleId the article ID 7233 * @param version the version 7234 * @return the matching journal article 7235 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7236 * @throws SystemException if a system exception occurred 7237 */ 7238 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V( 7239 long groupId, java.lang.String articleId, double version) 7240 throws com.liferay.portal.kernel.exception.SystemException, 7241 com.liferay.portlet.journal.NoSuchArticleException { 7242 return getPersistence().findByG_A_V(groupId, articleId, version); 7243 } 7244 7245 /** 7246 * 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. 7247 * 7248 * @param groupId the group ID 7249 * @param articleId the article ID 7250 * @param version the version 7251 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7252 * @throws SystemException if a system exception occurred 7253 */ 7254 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 7255 long groupId, java.lang.String articleId, double version) 7256 throws com.liferay.portal.kernel.exception.SystemException { 7257 return getPersistence().fetchByG_A_V(groupId, articleId, version); 7258 } 7259 7260 /** 7261 * 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. 7262 * 7263 * @param groupId the group ID 7264 * @param articleId the article ID 7265 * @param version the version 7266 * @param retrieveFromCache whether to use the finder cache 7267 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7268 * @throws SystemException if a system exception occurred 7269 */ 7270 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 7271 long groupId, java.lang.String articleId, double version, 7272 boolean retrieveFromCache) 7273 throws com.liferay.portal.kernel.exception.SystemException { 7274 return getPersistence() 7275 .fetchByG_A_V(groupId, articleId, version, retrieveFromCache); 7276 } 7277 7278 /** 7279 * Removes the journal article where groupId = ? and articleId = ? and version = ? from the database. 7280 * 7281 * @param groupId the group ID 7282 * @param articleId the article ID 7283 * @param version the version 7284 * @return the journal article that was removed 7285 * @throws SystemException if a system exception occurred 7286 */ 7287 public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V( 7288 long groupId, java.lang.String articleId, double version) 7289 throws com.liferay.portal.kernel.exception.SystemException, 7290 com.liferay.portlet.journal.NoSuchArticleException { 7291 return getPersistence().removeByG_A_V(groupId, articleId, version); 7292 } 7293 7294 /** 7295 * Returns the number of journal articles where groupId = ? and articleId = ? and version = ?. 7296 * 7297 * @param groupId the group ID 7298 * @param articleId the article ID 7299 * @param version the version 7300 * @return the number of matching journal articles 7301 * @throws SystemException if a system exception occurred 7302 */ 7303 public static int countByG_A_V(long groupId, java.lang.String articleId, 7304 double version) 7305 throws com.liferay.portal.kernel.exception.SystemException { 7306 return getPersistence().countByG_A_V(groupId, articleId, version); 7307 } 7308 7309 /** 7310 * Returns all the journal articles where groupId = ? and articleId = ? and status = ?. 7311 * 7312 * @param groupId the group ID 7313 * @param articleId the article ID 7314 * @param status the status 7315 * @return the matching journal articles 7316 * @throws SystemException if a system exception occurred 7317 */ 7318 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7319 long groupId, java.lang.String articleId, int status) 7320 throws com.liferay.portal.kernel.exception.SystemException { 7321 return getPersistence().findByG_A_ST(groupId, articleId, status); 7322 } 7323 7324 /** 7325 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = ?. 7326 * 7327 * <p> 7328 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7329 * </p> 7330 * 7331 * @param groupId the group ID 7332 * @param articleId the article ID 7333 * @param status the status 7334 * @param start the lower bound of the range of journal articles 7335 * @param end the upper bound of the range of journal articles (not inclusive) 7336 * @return the range of matching journal articles 7337 * @throws SystemException if a system exception occurred 7338 */ 7339 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7340 long groupId, java.lang.String articleId, int status, int start, int end) 7341 throws com.liferay.portal.kernel.exception.SystemException { 7342 return getPersistence() 7343 .findByG_A_ST(groupId, articleId, status, start, end); 7344 } 7345 7346 /** 7347 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = ?. 7348 * 7349 * <p> 7350 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7351 * </p> 7352 * 7353 * @param groupId the group ID 7354 * @param articleId the article ID 7355 * @param status the status 7356 * @param start the lower bound of the range of journal articles 7357 * @param end the upper bound of the range of journal articles (not inclusive) 7358 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7359 * @return the ordered range of matching journal articles 7360 * @throws SystemException if a system exception occurred 7361 */ 7362 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7363 long groupId, java.lang.String articleId, int status, int start, 7364 int end, 7365 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7366 throws com.liferay.portal.kernel.exception.SystemException { 7367 return getPersistence() 7368 .findByG_A_ST(groupId, articleId, status, start, end, 7369 orderByComparator); 7370 } 7371 7372 /** 7373 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7374 * 7375 * @param groupId the group ID 7376 * @param articleId the article ID 7377 * @param status the status 7378 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7379 * @return the first matching journal article 7380 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7381 * @throws SystemException if a system exception occurred 7382 */ 7383 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First( 7384 long groupId, java.lang.String articleId, int status, 7385 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7386 throws com.liferay.portal.kernel.exception.SystemException, 7387 com.liferay.portlet.journal.NoSuchArticleException { 7388 return getPersistence() 7389 .findByG_A_ST_First(groupId, articleId, status, 7390 orderByComparator); 7391 } 7392 7393 /** 7394 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7395 * 7396 * @param groupId the group ID 7397 * @param articleId the article ID 7398 * @param status the status 7399 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7400 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7401 * @throws SystemException if a system exception occurred 7402 */ 7403 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First( 7404 long groupId, java.lang.String articleId, int status, 7405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7406 throws com.liferay.portal.kernel.exception.SystemException { 7407 return getPersistence() 7408 .fetchByG_A_ST_First(groupId, articleId, status, 7409 orderByComparator); 7410 } 7411 7412 /** 7413 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7414 * 7415 * @param groupId the group ID 7416 * @param articleId the article ID 7417 * @param status the status 7418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7419 * @return the last matching journal article 7420 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7421 * @throws SystemException if a system exception occurred 7422 */ 7423 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last( 7424 long groupId, java.lang.String articleId, int status, 7425 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7426 throws com.liferay.portal.kernel.exception.SystemException, 7427 com.liferay.portlet.journal.NoSuchArticleException { 7428 return getPersistence() 7429 .findByG_A_ST_Last(groupId, articleId, status, 7430 orderByComparator); 7431 } 7432 7433 /** 7434 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7435 * 7436 * @param groupId the group ID 7437 * @param articleId the article ID 7438 * @param status the status 7439 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7440 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7441 * @throws SystemException if a system exception occurred 7442 */ 7443 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last( 7444 long groupId, java.lang.String articleId, int status, 7445 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7446 throws com.liferay.portal.kernel.exception.SystemException { 7447 return getPersistence() 7448 .fetchByG_A_ST_Last(groupId, articleId, status, 7449 orderByComparator); 7450 } 7451 7452 /** 7453 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7454 * 7455 * @param id the primary key of the current journal article 7456 * @param groupId the group ID 7457 * @param articleId the article ID 7458 * @param status the status 7459 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7460 * @return the previous, current, and next journal article 7461 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7462 * @throws SystemException if a system exception occurred 7463 */ 7464 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext( 7465 long id, long groupId, java.lang.String articleId, int status, 7466 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7467 throws com.liferay.portal.kernel.exception.SystemException, 7468 com.liferay.portlet.journal.NoSuchArticleException { 7469 return getPersistence() 7470 .findByG_A_ST_PrevAndNext(id, groupId, articleId, status, 7471 orderByComparator); 7472 } 7473 7474 /** 7475 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7476 * 7477 * @param groupId the group ID 7478 * @param articleId the article ID 7479 * @param status the status 7480 * @return the matching journal articles that the user has permission to view 7481 * @throws SystemException if a system exception occurred 7482 */ 7483 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7484 long groupId, java.lang.String articleId, int status) 7485 throws com.liferay.portal.kernel.exception.SystemException { 7486 return getPersistence().filterFindByG_A_ST(groupId, articleId, status); 7487 } 7488 7489 /** 7490 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7491 * 7492 * <p> 7493 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7494 * </p> 7495 * 7496 * @param groupId the group ID 7497 * @param articleId the article ID 7498 * @param status the status 7499 * @param start the lower bound of the range of journal articles 7500 * @param end the upper bound of the range of journal articles (not inclusive) 7501 * @return the range of matching journal articles that the user has permission to view 7502 * @throws SystemException if a system exception occurred 7503 */ 7504 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7505 long groupId, java.lang.String articleId, int status, int start, int end) 7506 throws com.liferay.portal.kernel.exception.SystemException { 7507 return getPersistence() 7508 .filterFindByG_A_ST(groupId, articleId, status, start, end); 7509 } 7510 7511 /** 7512 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status = ?. 7513 * 7514 * <p> 7515 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7516 * </p> 7517 * 7518 * @param groupId the group ID 7519 * @param articleId the article ID 7520 * @param status the status 7521 * @param start the lower bound of the range of journal articles 7522 * @param end the upper bound of the range of journal articles (not inclusive) 7523 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7524 * @return the ordered range of matching journal articles that the user has permission to view 7525 * @throws SystemException if a system exception occurred 7526 */ 7527 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7528 long groupId, java.lang.String articleId, int status, int start, 7529 int end, 7530 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7531 throws com.liferay.portal.kernel.exception.SystemException { 7532 return getPersistence() 7533 .filterFindByG_A_ST(groupId, articleId, status, start, end, 7534 orderByComparator); 7535 } 7536 7537 /** 7538 * 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 = ?. 7539 * 7540 * @param id the primary key of the current journal article 7541 * @param groupId the group ID 7542 * @param articleId the article ID 7543 * @param status the status 7544 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7545 * @return the previous, current, and next journal article 7546 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7547 * @throws SystemException if a system exception occurred 7548 */ 7549 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext( 7550 long id, long groupId, java.lang.String articleId, int status, 7551 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7552 throws com.liferay.portal.kernel.exception.SystemException, 7553 com.liferay.portlet.journal.NoSuchArticleException { 7554 return getPersistence() 7555 .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId, 7556 status, orderByComparator); 7557 } 7558 7559 /** 7560 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7561 * 7562 * @param groupId the group ID 7563 * @param articleId the article ID 7564 * @param statuses the statuses 7565 * @return the matching journal articles that the user has permission to view 7566 * @throws SystemException if a system exception occurred 7567 */ 7568 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7569 long groupId, java.lang.String articleId, int[] statuses) 7570 throws com.liferay.portal.kernel.exception.SystemException { 7571 return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses); 7572 } 7573 7574 /** 7575 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7576 * 7577 * <p> 7578 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7579 * </p> 7580 * 7581 * @param groupId the group ID 7582 * @param articleId the article ID 7583 * @param statuses the statuses 7584 * @param start the lower bound of the range of journal articles 7585 * @param end the upper bound of the range of journal articles (not inclusive) 7586 * @return the range of matching journal articles that the user has permission to view 7587 * @throws SystemException if a system exception occurred 7588 */ 7589 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7590 long groupId, java.lang.String articleId, int[] statuses, int start, 7591 int end) throws com.liferay.portal.kernel.exception.SystemException { 7592 return getPersistence() 7593 .filterFindByG_A_ST(groupId, articleId, statuses, start, end); 7594 } 7595 7596 /** 7597 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7598 * 7599 * <p> 7600 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7601 * </p> 7602 * 7603 * @param groupId the group ID 7604 * @param articleId the article ID 7605 * @param statuses the statuses 7606 * @param start the lower bound of the range of journal articles 7607 * @param end the upper bound of the range of journal articles (not inclusive) 7608 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7609 * @return the ordered range of matching journal articles that the user has permission to view 7610 * @throws SystemException if a system exception occurred 7611 */ 7612 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7613 long groupId, java.lang.String articleId, int[] statuses, int start, 7614 int end, 7615 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7616 throws com.liferay.portal.kernel.exception.SystemException { 7617 return getPersistence() 7618 .filterFindByG_A_ST(groupId, articleId, statuses, start, 7619 end, orderByComparator); 7620 } 7621 7622 /** 7623 * Returns all the journal articles where groupId = ? and articleId = ? and status = any ?. 7624 * 7625 * <p> 7626 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7627 * </p> 7628 * 7629 * @param groupId the group ID 7630 * @param articleId the article ID 7631 * @param statuses the statuses 7632 * @return the matching journal articles 7633 * @throws SystemException if a system exception occurred 7634 */ 7635 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7636 long groupId, java.lang.String articleId, int[] statuses) 7637 throws com.liferay.portal.kernel.exception.SystemException { 7638 return getPersistence().findByG_A_ST(groupId, articleId, statuses); 7639 } 7640 7641 /** 7642 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 7643 * 7644 * <p> 7645 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7646 * </p> 7647 * 7648 * @param groupId the group ID 7649 * @param articleId the article ID 7650 * @param statuses the statuses 7651 * @param start the lower bound of the range of journal articles 7652 * @param end the upper bound of the range of journal articles (not inclusive) 7653 * @return the range of matching journal articles 7654 * @throws SystemException if a system exception occurred 7655 */ 7656 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7657 long groupId, java.lang.String articleId, int[] statuses, int start, 7658 int end) throws com.liferay.portal.kernel.exception.SystemException { 7659 return getPersistence() 7660 .findByG_A_ST(groupId, articleId, statuses, start, end); 7661 } 7662 7663 /** 7664 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 7665 * 7666 * <p> 7667 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7668 * </p> 7669 * 7670 * @param groupId the group ID 7671 * @param articleId the article ID 7672 * @param statuses the statuses 7673 * @param start the lower bound of the range of journal articles 7674 * @param end the upper bound of the range of journal articles (not inclusive) 7675 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7676 * @return the ordered range of matching journal articles 7677 * @throws SystemException if a system exception occurred 7678 */ 7679 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7680 long groupId, java.lang.String articleId, int[] statuses, int start, 7681 int end, 7682 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7683 throws com.liferay.portal.kernel.exception.SystemException { 7684 return getPersistence() 7685 .findByG_A_ST(groupId, articleId, statuses, start, end, 7686 orderByComparator); 7687 } 7688 7689 /** 7690 * Removes all the journal articles where groupId = ? and articleId = ? and status = ? from the database. 7691 * 7692 * @param groupId the group ID 7693 * @param articleId the article ID 7694 * @param status the status 7695 * @throws SystemException if a system exception occurred 7696 */ 7697 public static void removeByG_A_ST(long groupId, java.lang.String articleId, 7698 int status) throws com.liferay.portal.kernel.exception.SystemException { 7699 getPersistence().removeByG_A_ST(groupId, articleId, status); 7700 } 7701 7702 /** 7703 * Returns the number of journal articles where groupId = ? and articleId = ? and status = ?. 7704 * 7705 * @param groupId the group ID 7706 * @param articleId the article ID 7707 * @param status the status 7708 * @return the number of matching journal articles 7709 * @throws SystemException if a system exception occurred 7710 */ 7711 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7712 int status) throws com.liferay.portal.kernel.exception.SystemException { 7713 return getPersistence().countByG_A_ST(groupId, articleId, status); 7714 } 7715 7716 /** 7717 * Returns the number of journal articles where groupId = ? and articleId = ? and status = any ?. 7718 * 7719 * @param groupId the group ID 7720 * @param articleId the article ID 7721 * @param statuses the statuses 7722 * @return the number of matching journal articles 7723 * @throws SystemException if a system exception occurred 7724 */ 7725 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7726 int[] statuses) 7727 throws com.liferay.portal.kernel.exception.SystemException { 7728 return getPersistence().countByG_A_ST(groupId, articleId, statuses); 7729 } 7730 7731 /** 7732 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7733 * 7734 * @param groupId the group ID 7735 * @param articleId the article ID 7736 * @param status the status 7737 * @return the number of matching journal articles that the user has permission to view 7738 * @throws SystemException if a system exception occurred 7739 */ 7740 public static int filterCountByG_A_ST(long groupId, 7741 java.lang.String articleId, int status) 7742 throws com.liferay.portal.kernel.exception.SystemException { 7743 return getPersistence().filterCountByG_A_ST(groupId, articleId, status); 7744 } 7745 7746 /** 7747 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7748 * 7749 * @param groupId the group ID 7750 * @param articleId the article ID 7751 * @param statuses the statuses 7752 * @return the number of matching journal articles that the user has permission to view 7753 * @throws SystemException if a system exception occurred 7754 */ 7755 public static int filterCountByG_A_ST(long groupId, 7756 java.lang.String articleId, int[] statuses) 7757 throws com.liferay.portal.kernel.exception.SystemException { 7758 return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses); 7759 } 7760 7761 /** 7762 * Returns all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 7763 * 7764 * @param groupId the group ID 7765 * @param articleId the article ID 7766 * @param status the status 7767 * @return the matching journal articles 7768 * @throws SystemException if a system exception occurred 7769 */ 7770 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 7771 long groupId, java.lang.String articleId, int status) 7772 throws com.liferay.portal.kernel.exception.SystemException { 7773 return getPersistence().findByG_A_NotST(groupId, articleId, status); 7774 } 7775 7776 /** 7777 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 7778 * 7779 * <p> 7780 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7781 * </p> 7782 * 7783 * @param groupId the group ID 7784 * @param articleId the article ID 7785 * @param status the status 7786 * @param start the lower bound of the range of journal articles 7787 * @param end the upper bound of the range of journal articles (not inclusive) 7788 * @return the range of matching journal articles 7789 * @throws SystemException if a system exception occurred 7790 */ 7791 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 7792 long groupId, java.lang.String articleId, int status, int start, int end) 7793 throws com.liferay.portal.kernel.exception.SystemException { 7794 return getPersistence() 7795 .findByG_A_NotST(groupId, articleId, status, start, end); 7796 } 7797 7798 /** 7799 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 7800 * 7801 * <p> 7802 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7803 * </p> 7804 * 7805 * @param groupId the group ID 7806 * @param articleId the article ID 7807 * @param status the status 7808 * @param start the lower bound of the range of journal articles 7809 * @param end the upper bound of the range of journal articles (not inclusive) 7810 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7811 * @return the ordered range of matching journal articles 7812 * @throws SystemException if a system exception occurred 7813 */ 7814 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 7815 long groupId, java.lang.String articleId, int status, int start, 7816 int end, 7817 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7818 throws com.liferay.portal.kernel.exception.SystemException { 7819 return getPersistence() 7820 .findByG_A_NotST(groupId, articleId, status, start, end, 7821 orderByComparator); 7822 } 7823 7824 /** 7825 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7826 * 7827 * @param groupId the group ID 7828 * @param articleId the article ID 7829 * @param status the status 7830 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7831 * @return the first matching journal article 7832 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7833 * @throws SystemException if a system exception occurred 7834 */ 7835 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_First( 7836 long groupId, java.lang.String articleId, int status, 7837 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7838 throws com.liferay.portal.kernel.exception.SystemException, 7839 com.liferay.portlet.journal.NoSuchArticleException { 7840 return getPersistence() 7841 .findByG_A_NotST_First(groupId, articleId, status, 7842 orderByComparator); 7843 } 7844 7845 /** 7846 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7847 * 7848 * @param groupId the group ID 7849 * @param articleId the article ID 7850 * @param status the status 7851 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7852 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7853 * @throws SystemException if a system exception occurred 7854 */ 7855 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_First( 7856 long groupId, java.lang.String articleId, int status, 7857 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7858 throws com.liferay.portal.kernel.exception.SystemException { 7859 return getPersistence() 7860 .fetchByG_A_NotST_First(groupId, articleId, status, 7861 orderByComparator); 7862 } 7863 7864 /** 7865 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7866 * 7867 * @param groupId the group ID 7868 * @param articleId the article ID 7869 * @param status the status 7870 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7871 * @return the last matching journal article 7872 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7873 * @throws SystemException if a system exception occurred 7874 */ 7875 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_Last( 7876 long groupId, java.lang.String articleId, int status, 7877 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7878 throws com.liferay.portal.kernel.exception.SystemException, 7879 com.liferay.portlet.journal.NoSuchArticleException { 7880 return getPersistence() 7881 .findByG_A_NotST_Last(groupId, articleId, status, 7882 orderByComparator); 7883 } 7884 7885 /** 7886 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7887 * 7888 * @param groupId the group ID 7889 * @param articleId the article ID 7890 * @param status the status 7891 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7892 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7893 * @throws SystemException if a system exception occurred 7894 */ 7895 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_Last( 7896 long groupId, java.lang.String articleId, int status, 7897 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7898 throws com.liferay.portal.kernel.exception.SystemException { 7899 return getPersistence() 7900 .fetchByG_A_NotST_Last(groupId, articleId, status, 7901 orderByComparator); 7902 } 7903 7904 /** 7905 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7906 * 7907 * @param id the primary key of the current journal article 7908 * @param groupId the group ID 7909 * @param articleId the article ID 7910 * @param status the status 7911 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7912 * @return the previous, current, and next journal article 7913 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7914 * @throws SystemException if a system exception occurred 7915 */ 7916 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_NotST_PrevAndNext( 7917 long id, long groupId, java.lang.String articleId, int status, 7918 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7919 throws com.liferay.portal.kernel.exception.SystemException, 7920 com.liferay.portlet.journal.NoSuchArticleException { 7921 return getPersistence() 7922 .findByG_A_NotST_PrevAndNext(id, groupId, articleId, status, 7923 orderByComparator); 7924 } 7925 7926 /** 7927 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 7928 * 7929 * @param groupId the group ID 7930 * @param articleId the article ID 7931 * @param status the status 7932 * @return the matching journal articles that the user has permission to view 7933 * @throws SystemException if a system exception occurred 7934 */ 7935 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 7936 long groupId, java.lang.String articleId, int status) 7937 throws com.liferay.portal.kernel.exception.SystemException { 7938 return getPersistence().filterFindByG_A_NotST(groupId, articleId, status); 7939 } 7940 7941 /** 7942 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 7943 * 7944 * <p> 7945 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7946 * </p> 7947 * 7948 * @param groupId the group ID 7949 * @param articleId the article ID 7950 * @param status the status 7951 * @param start the lower bound of the range of journal articles 7952 * @param end the upper bound of the range of journal articles (not inclusive) 7953 * @return the range of matching journal articles that the user has permission to view 7954 * @throws SystemException if a system exception occurred 7955 */ 7956 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 7957 long groupId, java.lang.String articleId, int status, int start, int end) 7958 throws com.liferay.portal.kernel.exception.SystemException { 7959 return getPersistence() 7960 .filterFindByG_A_NotST(groupId, articleId, status, start, end); 7961 } 7962 7963 /** 7964 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status ≠ ?. 7965 * 7966 * <p> 7967 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7968 * </p> 7969 * 7970 * @param groupId the group ID 7971 * @param articleId the article ID 7972 * @param status the status 7973 * @param start the lower bound of the range of journal articles 7974 * @param end the upper bound of the range of journal articles (not inclusive) 7975 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7976 * @return the ordered range of matching journal articles that the user has permission to view 7977 * @throws SystemException if a system exception occurred 7978 */ 7979 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 7980 long groupId, java.lang.String articleId, int status, int start, 7981 int end, 7982 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7983 throws com.liferay.portal.kernel.exception.SystemException { 7984 return getPersistence() 7985 .filterFindByG_A_NotST(groupId, articleId, status, start, 7986 end, orderByComparator); 7987 } 7988 7989 /** 7990 * 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 ≠ ?. 7991 * 7992 * @param id the primary key of the current journal article 7993 * @param groupId the group ID 7994 * @param articleId the article ID 7995 * @param status the status 7996 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7997 * @return the previous, current, and next journal article 7998 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7999 * @throws SystemException if a system exception occurred 8000 */ 8001 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_NotST_PrevAndNext( 8002 long id, long groupId, java.lang.String articleId, int status, 8003 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8004 throws com.liferay.portal.kernel.exception.SystemException, 8005 com.liferay.portlet.journal.NoSuchArticleException { 8006 return getPersistence() 8007 .filterFindByG_A_NotST_PrevAndNext(id, groupId, articleId, 8008 status, orderByComparator); 8009 } 8010 8011 /** 8012 * Removes all the journal articles where groupId = ? and articleId = ? and status ≠ ? from the database. 8013 * 8014 * @param groupId the group ID 8015 * @param articleId the article ID 8016 * @param status the status 8017 * @throws SystemException if a system exception occurred 8018 */ 8019 public static void removeByG_A_NotST(long groupId, 8020 java.lang.String articleId, int status) 8021 throws com.liferay.portal.kernel.exception.SystemException { 8022 getPersistence().removeByG_A_NotST(groupId, articleId, status); 8023 } 8024 8025 /** 8026 * Returns the number of journal articles where groupId = ? and articleId = ? and status ≠ ?. 8027 * 8028 * @param groupId the group ID 8029 * @param articleId the article ID 8030 * @param status the status 8031 * @return the number of matching journal articles 8032 * @throws SystemException if a system exception occurred 8033 */ 8034 public static int countByG_A_NotST(long groupId, 8035 java.lang.String articleId, int status) 8036 throws com.liferay.portal.kernel.exception.SystemException { 8037 return getPersistence().countByG_A_NotST(groupId, articleId, status); 8038 } 8039 8040 /** 8041 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 8042 * 8043 * @param groupId the group ID 8044 * @param articleId the article ID 8045 * @param status the status 8046 * @return the number of matching journal articles that the user has permission to view 8047 * @throws SystemException if a system exception occurred 8048 */ 8049 public static int filterCountByG_A_NotST(long groupId, 8050 java.lang.String articleId, int status) 8051 throws com.liferay.portal.kernel.exception.SystemException { 8052 return getPersistence() 8053 .filterCountByG_A_NotST(groupId, articleId, status); 8054 } 8055 8056 /** 8057 * Returns all the journal articles where groupId = ? and urlTitle = ? and status = ?. 8058 * 8059 * @param groupId the group ID 8060 * @param urlTitle the url title 8061 * @param status the status 8062 * @return the matching journal articles 8063 * @throws SystemException if a system exception occurred 8064 */ 8065 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 8066 long groupId, java.lang.String urlTitle, int status) 8067 throws com.liferay.portal.kernel.exception.SystemException { 8068 return getPersistence().findByG_UT_ST(groupId, urlTitle, status); 8069 } 8070 8071 /** 8072 * Returns a range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 8073 * 8074 * <p> 8075 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8076 * </p> 8077 * 8078 * @param groupId the group ID 8079 * @param urlTitle the url title 8080 * @param status the status 8081 * @param start the lower bound of the range of journal articles 8082 * @param end the upper bound of the range of journal articles (not inclusive) 8083 * @return the range of matching journal articles 8084 * @throws SystemException if a system exception occurred 8085 */ 8086 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 8087 long groupId, java.lang.String urlTitle, int status, int start, int end) 8088 throws com.liferay.portal.kernel.exception.SystemException { 8089 return getPersistence() 8090 .findByG_UT_ST(groupId, urlTitle, status, start, end); 8091 } 8092 8093 /** 8094 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 8095 * 8096 * <p> 8097 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8098 * </p> 8099 * 8100 * @param groupId the group ID 8101 * @param urlTitle the url title 8102 * @param status the status 8103 * @param start the lower bound of the range of journal articles 8104 * @param end the upper bound of the range of journal articles (not inclusive) 8105 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8106 * @return the ordered range of matching journal articles 8107 * @throws SystemException if a system exception occurred 8108 */ 8109 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 8110 long groupId, java.lang.String urlTitle, int status, int start, 8111 int end, 8112 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8113 throws com.liferay.portal.kernel.exception.SystemException { 8114 return getPersistence() 8115 .findByG_UT_ST(groupId, urlTitle, status, start, end, 8116 orderByComparator); 8117 } 8118 8119 /** 8120 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8121 * 8122 * @param groupId the group ID 8123 * @param urlTitle the url title 8124 * @param status the status 8125 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8126 * @return the first matching journal article 8127 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8128 * @throws SystemException if a system exception occurred 8129 */ 8130 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First( 8131 long groupId, java.lang.String urlTitle, int status, 8132 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8133 throws com.liferay.portal.kernel.exception.SystemException, 8134 com.liferay.portlet.journal.NoSuchArticleException { 8135 return getPersistence() 8136 .findByG_UT_ST_First(groupId, urlTitle, status, 8137 orderByComparator); 8138 } 8139 8140 /** 8141 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8142 * 8143 * @param groupId the group ID 8144 * @param urlTitle the url title 8145 * @param status the status 8146 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8147 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 8148 * @throws SystemException if a system exception occurred 8149 */ 8150 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First( 8151 long groupId, java.lang.String urlTitle, int status, 8152 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8153 throws com.liferay.portal.kernel.exception.SystemException { 8154 return getPersistence() 8155 .fetchByG_UT_ST_First(groupId, urlTitle, status, 8156 orderByComparator); 8157 } 8158 8159 /** 8160 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8161 * 8162 * @param groupId the group ID 8163 * @param urlTitle the url title 8164 * @param status the status 8165 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8166 * @return the last matching journal article 8167 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8168 * @throws SystemException if a system exception occurred 8169 */ 8170 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last( 8171 long groupId, java.lang.String urlTitle, int status, 8172 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8173 throws com.liferay.portal.kernel.exception.SystemException, 8174 com.liferay.portlet.journal.NoSuchArticleException { 8175 return getPersistence() 8176 .findByG_UT_ST_Last(groupId, urlTitle, status, 8177 orderByComparator); 8178 } 8179 8180 /** 8181 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8182 * 8183 * @param groupId the group ID 8184 * @param urlTitle the url title 8185 * @param status the status 8186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8187 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 8188 * @throws SystemException if a system exception occurred 8189 */ 8190 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last( 8191 long groupId, java.lang.String urlTitle, int status, 8192 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8193 throws com.liferay.portal.kernel.exception.SystemException { 8194 return getPersistence() 8195 .fetchByG_UT_ST_Last(groupId, urlTitle, status, 8196 orderByComparator); 8197 } 8198 8199 /** 8200 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8201 * 8202 * @param id the primary key of the current journal article 8203 * @param groupId the group ID 8204 * @param urlTitle the url title 8205 * @param status the status 8206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8207 * @return the previous, current, and next journal article 8208 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8209 * @throws SystemException if a system exception occurred 8210 */ 8211 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext( 8212 long id, long groupId, java.lang.String urlTitle, int status, 8213 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8214 throws com.liferay.portal.kernel.exception.SystemException, 8215 com.liferay.portlet.journal.NoSuchArticleException { 8216 return getPersistence() 8217 .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status, 8218 orderByComparator); 8219 } 8220 8221 /** 8222 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8223 * 8224 * @param groupId the group ID 8225 * @param urlTitle the url title 8226 * @param status the status 8227 * @return the matching journal articles that the user has permission to view 8228 * @throws SystemException if a system exception occurred 8229 */ 8230 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8231 long groupId, java.lang.String urlTitle, int status) 8232 throws com.liferay.portal.kernel.exception.SystemException { 8233 return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status); 8234 } 8235 8236 /** 8237 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8238 * 8239 * <p> 8240 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8241 * </p> 8242 * 8243 * @param groupId the group ID 8244 * @param urlTitle the url title 8245 * @param status the status 8246 * @param start the lower bound of the range of journal articles 8247 * @param end the upper bound of the range of journal articles (not inclusive) 8248 * @return the range of matching journal articles that the user has permission to view 8249 * @throws SystemException if a system exception occurred 8250 */ 8251 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8252 long groupId, java.lang.String urlTitle, int status, int start, int end) 8253 throws com.liferay.portal.kernel.exception.SystemException { 8254 return getPersistence() 8255 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end); 8256 } 8257 8258 /** 8259 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ? and status = ?. 8260 * 8261 * <p> 8262 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8263 * </p> 8264 * 8265 * @param groupId the group ID 8266 * @param urlTitle the url title 8267 * @param status the status 8268 * @param start the lower bound of the range of journal articles 8269 * @param end the upper bound of the range of journal articles (not inclusive) 8270 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8271 * @return the ordered range of matching journal articles that the user has permission to view 8272 * @throws SystemException if a system exception occurred 8273 */ 8274 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8275 long groupId, java.lang.String urlTitle, int status, int start, 8276 int end, 8277 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8278 throws com.liferay.portal.kernel.exception.SystemException { 8279 return getPersistence() 8280 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end, 8281 orderByComparator); 8282 } 8283 8284 /** 8285 * 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 = ?. 8286 * 8287 * @param id the primary key of the current journal article 8288 * @param groupId the group ID 8289 * @param urlTitle the url title 8290 * @param status the status 8291 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8292 * @return the previous, current, and next journal article 8293 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8294 * @throws SystemException if a system exception occurred 8295 */ 8296 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext( 8297 long id, long groupId, java.lang.String urlTitle, int status, 8298 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8299 throws com.liferay.portal.kernel.exception.SystemException, 8300 com.liferay.portlet.journal.NoSuchArticleException { 8301 return getPersistence() 8302 .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle, 8303 status, orderByComparator); 8304 } 8305 8306 /** 8307 * Removes all the journal articles where groupId = ? and urlTitle = ? and status = ? from the database. 8308 * 8309 * @param groupId the group ID 8310 * @param urlTitle the url title 8311 * @param status the status 8312 * @throws SystemException if a system exception occurred 8313 */ 8314 public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle, 8315 int status) throws com.liferay.portal.kernel.exception.SystemException { 8316 getPersistence().removeByG_UT_ST(groupId, urlTitle, status); 8317 } 8318 8319 /** 8320 * Returns the number of journal articles where groupId = ? and urlTitle = ? and status = ?. 8321 * 8322 * @param groupId the group ID 8323 * @param urlTitle the url title 8324 * @param status the status 8325 * @return the number of matching journal articles 8326 * @throws SystemException if a system exception occurred 8327 */ 8328 public static int countByG_UT_ST(long groupId, java.lang.String urlTitle, 8329 int status) throws com.liferay.portal.kernel.exception.SystemException { 8330 return getPersistence().countByG_UT_ST(groupId, urlTitle, status); 8331 } 8332 8333 /** 8334 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8335 * 8336 * @param groupId the group ID 8337 * @param urlTitle the url title 8338 * @param status the status 8339 * @return the number of matching journal articles that the user has permission to view 8340 * @throws SystemException if a system exception occurred 8341 */ 8342 public static int filterCountByG_UT_ST(long groupId, 8343 java.lang.String urlTitle, int status) 8344 throws com.liferay.portal.kernel.exception.SystemException { 8345 return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status); 8346 } 8347 8348 /** 8349 * Returns all the journal articles where companyId = ? and version = ? and status = ?. 8350 * 8351 * @param companyId the company ID 8352 * @param version the version 8353 * @param status the status 8354 * @return the matching journal articles 8355 * @throws SystemException if a system exception occurred 8356 */ 8357 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8358 long companyId, double version, int status) 8359 throws com.liferay.portal.kernel.exception.SystemException { 8360 return getPersistence().findByC_V_ST(companyId, version, status); 8361 } 8362 8363 /** 8364 * Returns a range of all the journal articles where companyId = ? and version = ? and status = ?. 8365 * 8366 * <p> 8367 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8368 * </p> 8369 * 8370 * @param companyId the company ID 8371 * @param version the version 8372 * @param status the status 8373 * @param start the lower bound of the range of journal articles 8374 * @param end the upper bound of the range of journal articles (not inclusive) 8375 * @return the range of matching journal articles 8376 * @throws SystemException if a system exception occurred 8377 */ 8378 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8379 long companyId, double version, int status, int start, int end) 8380 throws com.liferay.portal.kernel.exception.SystemException { 8381 return getPersistence() 8382 .findByC_V_ST(companyId, version, status, start, end); 8383 } 8384 8385 /** 8386 * Returns an ordered range of all the journal articles where companyId = ? and version = ? and status = ?. 8387 * 8388 * <p> 8389 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8390 * </p> 8391 * 8392 * @param companyId the company ID 8393 * @param version the version 8394 * @param status the status 8395 * @param start the lower bound of the range of journal articles 8396 * @param end the upper bound of the range of journal articles (not inclusive) 8397 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8398 * @return the ordered range of matching journal articles 8399 * @throws SystemException if a system exception occurred 8400 */ 8401 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8402 long companyId, double version, int status, int start, int end, 8403 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8404 throws com.liferay.portal.kernel.exception.SystemException { 8405 return getPersistence() 8406 .findByC_V_ST(companyId, version, status, start, end, 8407 orderByComparator); 8408 } 8409 8410 /** 8411 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 8412 * 8413 * @param companyId the company ID 8414 * @param version the version 8415 * @param status the status 8416 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8417 * @return the first matching journal article 8418 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8419 * @throws SystemException if a system exception occurred 8420 */ 8421 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First( 8422 long companyId, double version, int status, 8423 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8424 throws com.liferay.portal.kernel.exception.SystemException, 8425 com.liferay.portlet.journal.NoSuchArticleException { 8426 return getPersistence() 8427 .findByC_V_ST_First(companyId, version, status, 8428 orderByComparator); 8429 } 8430 8431 /** 8432 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 8433 * 8434 * @param companyId the company ID 8435 * @param version the version 8436 * @param status the status 8437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8438 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 8439 * @throws SystemException if a system exception occurred 8440 */ 8441 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First( 8442 long companyId, double version, int status, 8443 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8444 throws com.liferay.portal.kernel.exception.SystemException { 8445 return getPersistence() 8446 .fetchByC_V_ST_First(companyId, version, status, 8447 orderByComparator); 8448 } 8449 8450 /** 8451 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 8452 * 8453 * @param companyId the company ID 8454 * @param version the version 8455 * @param status the status 8456 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8457 * @return the last matching journal article 8458 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8459 * @throws SystemException if a system exception occurred 8460 */ 8461 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last( 8462 long companyId, double version, int status, 8463 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8464 throws com.liferay.portal.kernel.exception.SystemException, 8465 com.liferay.portlet.journal.NoSuchArticleException { 8466 return getPersistence() 8467 .findByC_V_ST_Last(companyId, version, status, 8468 orderByComparator); 8469 } 8470 8471 /** 8472 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 8473 * 8474 * @param companyId the company ID 8475 * @param version the version 8476 * @param status the status 8477 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8478 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 8479 * @throws SystemException if a system exception occurred 8480 */ 8481 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last( 8482 long companyId, double version, int status, 8483 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8484 throws com.liferay.portal.kernel.exception.SystemException { 8485 return getPersistence() 8486 .fetchByC_V_ST_Last(companyId, version, status, 8487 orderByComparator); 8488 } 8489 8490 /** 8491 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ? and status = ?. 8492 * 8493 * @param id the primary key of the current journal article 8494 * @param companyId the company ID 8495 * @param version the version 8496 * @param status the status 8497 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8498 * @return the previous, current, and next journal article 8499 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8500 * @throws SystemException if a system exception occurred 8501 */ 8502 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext( 8503 long id, long companyId, double version, int status, 8504 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8505 throws com.liferay.portal.kernel.exception.SystemException, 8506 com.liferay.portlet.journal.NoSuchArticleException { 8507 return getPersistence() 8508 .findByC_V_ST_PrevAndNext(id, companyId, version, status, 8509 orderByComparator); 8510 } 8511 8512 /** 8513 * Removes all the journal articles where companyId = ? and version = ? and status = ? from the database. 8514 * 8515 * @param companyId the company ID 8516 * @param version the version 8517 * @param status the status 8518 * @throws SystemException if a system exception occurred 8519 */ 8520 public static void removeByC_V_ST(long companyId, double version, int status) 8521 throws com.liferay.portal.kernel.exception.SystemException { 8522 getPersistence().removeByC_V_ST(companyId, version, status); 8523 } 8524 8525 /** 8526 * Returns the number of journal articles where companyId = ? and version = ? and status = ?. 8527 * 8528 * @param companyId the company ID 8529 * @param version the version 8530 * @param status the status 8531 * @return the number of matching journal articles 8532 * @throws SystemException if a system exception occurred 8533 */ 8534 public static int countByC_V_ST(long companyId, double version, int status) 8535 throws com.liferay.portal.kernel.exception.SystemException { 8536 return getPersistence().countByC_V_ST(companyId, version, status); 8537 } 8538 8539 /** 8540 * Caches the journal article in the entity cache if it is enabled. 8541 * 8542 * @param journalArticle the journal article 8543 */ 8544 public static void cacheResult( 8545 com.liferay.portlet.journal.model.JournalArticle journalArticle) { 8546 getPersistence().cacheResult(journalArticle); 8547 } 8548 8549 /** 8550 * Caches the journal articles in the entity cache if it is enabled. 8551 * 8552 * @param journalArticles the journal articles 8553 */ 8554 public static void cacheResult( 8555 java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) { 8556 getPersistence().cacheResult(journalArticles); 8557 } 8558 8559 /** 8560 * Creates a new journal article with the primary key. Does not add the journal article to the database. 8561 * 8562 * @param id the primary key for the new journal article 8563 * @return the new journal article 8564 */ 8565 public static com.liferay.portlet.journal.model.JournalArticle create( 8566 long id) { 8567 return getPersistence().create(id); 8568 } 8569 8570 /** 8571 * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners. 8572 * 8573 * @param id the primary key of the journal article 8574 * @return the journal article that was removed 8575 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8576 * @throws SystemException if a system exception occurred 8577 */ 8578 public static com.liferay.portlet.journal.model.JournalArticle remove( 8579 long id) 8580 throws com.liferay.portal.kernel.exception.SystemException, 8581 com.liferay.portlet.journal.NoSuchArticleException { 8582 return getPersistence().remove(id); 8583 } 8584 8585 public static com.liferay.portlet.journal.model.JournalArticle updateImpl( 8586 com.liferay.portlet.journal.model.JournalArticle journalArticle) 8587 throws com.liferay.portal.kernel.exception.SystemException { 8588 return getPersistence().updateImpl(journalArticle); 8589 } 8590 8591 /** 8592 * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 8593 * 8594 * @param id the primary key of the journal article 8595 * @return the journal article 8596 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8597 * @throws SystemException if a system exception occurred 8598 */ 8599 public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey( 8600 long id) 8601 throws com.liferay.portal.kernel.exception.SystemException, 8602 com.liferay.portlet.journal.NoSuchArticleException { 8603 return getPersistence().findByPrimaryKey(id); 8604 } 8605 8606 /** 8607 * Returns the journal article with the primary key or returns <code>null</code> if it could not be found. 8608 * 8609 * @param id the primary key of the journal article 8610 * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found 8611 * @throws SystemException if a system exception occurred 8612 */ 8613 public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey( 8614 long id) throws com.liferay.portal.kernel.exception.SystemException { 8615 return getPersistence().fetchByPrimaryKey(id); 8616 } 8617 8618 /** 8619 * Returns all the journal articles. 8620 * 8621 * @return the journal articles 8622 * @throws SystemException if a system exception occurred 8623 */ 8624 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll() 8625 throws com.liferay.portal.kernel.exception.SystemException { 8626 return getPersistence().findAll(); 8627 } 8628 8629 /** 8630 * Returns a range of all the journal articles. 8631 * 8632 * <p> 8633 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8634 * </p> 8635 * 8636 * @param start the lower bound of the range of journal articles 8637 * @param end the upper bound of the range of journal articles (not inclusive) 8638 * @return the range of journal articles 8639 * @throws SystemException if a system exception occurred 8640 */ 8641 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 8642 int start, int end) 8643 throws com.liferay.portal.kernel.exception.SystemException { 8644 return getPersistence().findAll(start, end); 8645 } 8646 8647 /** 8648 * Returns an ordered range of all the journal articles. 8649 * 8650 * <p> 8651 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8652 * </p> 8653 * 8654 * @param start the lower bound of the range of journal articles 8655 * @param end the upper bound of the range of journal articles (not inclusive) 8656 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8657 * @return the ordered range of journal articles 8658 * @throws SystemException if a system exception occurred 8659 */ 8660 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 8661 int start, int end, 8662 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8663 throws com.liferay.portal.kernel.exception.SystemException { 8664 return getPersistence().findAll(start, end, orderByComparator); 8665 } 8666 8667 /** 8668 * Removes all the journal articles from the database. 8669 * 8670 * @throws SystemException if a system exception occurred 8671 */ 8672 public static void removeAll() 8673 throws com.liferay.portal.kernel.exception.SystemException { 8674 getPersistence().removeAll(); 8675 } 8676 8677 /** 8678 * Returns the number of journal articles. 8679 * 8680 * @return the number of journal articles 8681 * @throws SystemException if a system exception occurred 8682 */ 8683 public static int countAll() 8684 throws com.liferay.portal.kernel.exception.SystemException { 8685 return getPersistence().countAll(); 8686 } 8687 8688 public static JournalArticlePersistence getPersistence() { 8689 if (_persistence == null) { 8690 _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName()); 8691 8692 ReferenceRegistry.registerReference(JournalArticleUtil.class, 8693 "_persistence"); 8694 } 8695 8696 return _persistence; 8697 } 8698 8699 /** 8700 * @deprecated As of 6.2.0 8701 */ 8702 public void setPersistence(JournalArticlePersistence persistence) { 8703 } 8704 8705 private static JournalArticlePersistence _persistence; 8706 }