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 * Removes all the journal articles where resourcePrimKey = ? and status = ? from the database. 2168 * 2169 * @param resourcePrimKey the resource prim key 2170 * @param status the status 2171 * @throws SystemException if a system exception occurred 2172 */ 2173 public static void removeByR_ST(long resourcePrimKey, int status) 2174 throws com.liferay.portal.kernel.exception.SystemException { 2175 getPersistence().removeByR_ST(resourcePrimKey, status); 2176 } 2177 2178 /** 2179 * Returns the number of journal articles where resourcePrimKey = ? and status = ?. 2180 * 2181 * @param resourcePrimKey the resource prim key 2182 * @param status the status 2183 * @return the number of matching journal articles 2184 * @throws SystemException if a system exception occurred 2185 */ 2186 public static int countByR_ST(long resourcePrimKey, int status) 2187 throws com.liferay.portal.kernel.exception.SystemException { 2188 return getPersistence().countByR_ST(resourcePrimKey, status); 2189 } 2190 2191 /** 2192 * Returns all the journal articles where groupId = ? and userId = ?. 2193 * 2194 * @param groupId the group ID 2195 * @param userId the user ID 2196 * @return the matching journal articles 2197 * @throws SystemException if a system exception occurred 2198 */ 2199 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2200 long groupId, long userId) 2201 throws com.liferay.portal.kernel.exception.SystemException { 2202 return getPersistence().findByG_U(groupId, userId); 2203 } 2204 2205 /** 2206 * Returns a range of all the journal articles where groupId = ? and userId = ?. 2207 * 2208 * <p> 2209 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2210 * </p> 2211 * 2212 * @param groupId the group ID 2213 * @param userId the user ID 2214 * @param start the lower bound of the range of journal articles 2215 * @param end the upper bound of the range of journal articles (not inclusive) 2216 * @return the 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> findByG_U( 2220 long groupId, long userId, int start, int end) 2221 throws com.liferay.portal.kernel.exception.SystemException { 2222 return getPersistence().findByG_U(groupId, userId, start, end); 2223 } 2224 2225 /** 2226 * Returns an ordered range of all the journal articles where groupId = ? and userId = ?. 2227 * 2228 * <p> 2229 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2230 * </p> 2231 * 2232 * @param groupId the group ID 2233 * @param userId the user ID 2234 * @param start the lower bound of the range of journal articles 2235 * @param end the upper bound of the range of journal articles (not inclusive) 2236 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2237 * @return the ordered range of matching journal articles 2238 * @throws SystemException if a system exception occurred 2239 */ 2240 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2241 long groupId, long userId, int start, int end, 2242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2243 throws com.liferay.portal.kernel.exception.SystemException { 2244 return getPersistence() 2245 .findByG_U(groupId, userId, start, end, orderByComparator); 2246 } 2247 2248 /** 2249 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2250 * 2251 * @param groupId the group ID 2252 * @param userId the user ID 2253 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2254 * @return the first matching journal article 2255 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2256 * @throws SystemException if a system exception occurred 2257 */ 2258 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First( 2259 long groupId, long userId, 2260 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2261 throws com.liferay.portal.kernel.exception.SystemException, 2262 com.liferay.portlet.journal.NoSuchArticleException { 2263 return getPersistence() 2264 .findByG_U_First(groupId, userId, orderByComparator); 2265 } 2266 2267 /** 2268 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2269 * 2270 * @param groupId the group ID 2271 * @param userId the user ID 2272 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2273 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2274 * @throws SystemException if a system exception occurred 2275 */ 2276 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First( 2277 long groupId, long userId, 2278 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2279 throws com.liferay.portal.kernel.exception.SystemException { 2280 return getPersistence() 2281 .fetchByG_U_First(groupId, userId, orderByComparator); 2282 } 2283 2284 /** 2285 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2286 * 2287 * @param groupId the group ID 2288 * @param userId the user ID 2289 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2290 * @return the last matching journal article 2291 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2292 * @throws SystemException if a system exception occurred 2293 */ 2294 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last( 2295 long groupId, long userId, 2296 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2297 throws com.liferay.portal.kernel.exception.SystemException, 2298 com.liferay.portlet.journal.NoSuchArticleException { 2299 return getPersistence() 2300 .findByG_U_Last(groupId, userId, orderByComparator); 2301 } 2302 2303 /** 2304 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2305 * 2306 * @param groupId the group ID 2307 * @param userId the user ID 2308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2309 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2310 * @throws SystemException if a system exception occurred 2311 */ 2312 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last( 2313 long groupId, long userId, 2314 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2315 throws com.liferay.portal.kernel.exception.SystemException { 2316 return getPersistence() 2317 .fetchByG_U_Last(groupId, userId, orderByComparator); 2318 } 2319 2320 /** 2321 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ?. 2322 * 2323 * @param id the primary key of the current journal article 2324 * @param groupId the group ID 2325 * @param userId the user ID 2326 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2327 * @return the previous, current, and next journal article 2328 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2329 * @throws SystemException if a system exception occurred 2330 */ 2331 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext( 2332 long id, long groupId, long userId, 2333 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2334 throws com.liferay.portal.kernel.exception.SystemException, 2335 com.liferay.portlet.journal.NoSuchArticleException { 2336 return getPersistence() 2337 .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator); 2338 } 2339 2340 /** 2341 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2342 * 2343 * @param groupId the group ID 2344 * @param userId the user ID 2345 * @return the matching journal articles that the user has permission to view 2346 * @throws SystemException if a system exception occurred 2347 */ 2348 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2349 long groupId, long userId) 2350 throws com.liferay.portal.kernel.exception.SystemException { 2351 return getPersistence().filterFindByG_U(groupId, userId); 2352 } 2353 2354 /** 2355 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2356 * 2357 * <p> 2358 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2359 * </p> 2360 * 2361 * @param groupId the group ID 2362 * @param userId the user ID 2363 * @param start the lower bound of the range of journal articles 2364 * @param end the upper bound of the range of journal articles (not inclusive) 2365 * @return the range of matching journal articles that the user has permission to view 2366 * @throws SystemException if a system exception occurred 2367 */ 2368 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2369 long groupId, long userId, int start, int end) 2370 throws com.liferay.portal.kernel.exception.SystemException { 2371 return getPersistence().filterFindByG_U(groupId, userId, start, end); 2372 } 2373 2374 /** 2375 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ?. 2376 * 2377 * <p> 2378 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2379 * </p> 2380 * 2381 * @param groupId the group ID 2382 * @param userId the user ID 2383 * @param start the lower bound of the range of journal articles 2384 * @param end the upper bound of the range of journal articles (not inclusive) 2385 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2386 * @return the ordered range of matching journal articles that the user has permission to view 2387 * @throws SystemException if a system exception occurred 2388 */ 2389 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2390 long groupId, long userId, int start, int end, 2391 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2392 throws com.liferay.portal.kernel.exception.SystemException { 2393 return getPersistence() 2394 .filterFindByG_U(groupId, userId, start, end, 2395 orderByComparator); 2396 } 2397 2398 /** 2399 * 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 = ?. 2400 * 2401 * @param id the primary key of the current journal article 2402 * @param groupId the group ID 2403 * @param userId the user ID 2404 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2405 * @return the previous, current, and next journal article 2406 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2407 * @throws SystemException if a system exception occurred 2408 */ 2409 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext( 2410 long id, long groupId, long userId, 2411 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2412 throws com.liferay.portal.kernel.exception.SystemException, 2413 com.liferay.portlet.journal.NoSuchArticleException { 2414 return getPersistence() 2415 .filterFindByG_U_PrevAndNext(id, groupId, userId, 2416 orderByComparator); 2417 } 2418 2419 /** 2420 * Removes all the journal articles where groupId = ? and userId = ? from the database. 2421 * 2422 * @param groupId the group ID 2423 * @param userId the user ID 2424 * @throws SystemException if a system exception occurred 2425 */ 2426 public static void removeByG_U(long groupId, long userId) 2427 throws com.liferay.portal.kernel.exception.SystemException { 2428 getPersistence().removeByG_U(groupId, userId); 2429 } 2430 2431 /** 2432 * Returns the number of journal articles where groupId = ? and userId = ?. 2433 * 2434 * @param groupId the group ID 2435 * @param userId the user ID 2436 * @return the number of matching journal articles 2437 * @throws SystemException if a system exception occurred 2438 */ 2439 public static int countByG_U(long groupId, long userId) 2440 throws com.liferay.portal.kernel.exception.SystemException { 2441 return getPersistence().countByG_U(groupId, userId); 2442 } 2443 2444 /** 2445 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ?. 2446 * 2447 * @param groupId the group ID 2448 * @param userId the user ID 2449 * @return the number of matching journal articles that the user has permission to view 2450 * @throws SystemException if a system exception occurred 2451 */ 2452 public static int filterCountByG_U(long groupId, long userId) 2453 throws com.liferay.portal.kernel.exception.SystemException { 2454 return getPersistence().filterCountByG_U(groupId, userId); 2455 } 2456 2457 /** 2458 * Returns all the journal articles where groupId = ? and folderId = ?. 2459 * 2460 * @param groupId the group ID 2461 * @param folderId the folder ID 2462 * @return the matching journal articles 2463 * @throws SystemException if a system exception occurred 2464 */ 2465 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2466 long groupId, long folderId) 2467 throws com.liferay.portal.kernel.exception.SystemException { 2468 return getPersistence().findByG_F(groupId, folderId); 2469 } 2470 2471 /** 2472 * Returns a range of all the journal articles where groupId = ? and folderId = ?. 2473 * 2474 * <p> 2475 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2476 * </p> 2477 * 2478 * @param groupId the group ID 2479 * @param folderId the folder ID 2480 * @param start the lower bound of the range of journal articles 2481 * @param end the upper bound of the range of journal articles (not inclusive) 2482 * @return the range of matching journal articles 2483 * @throws SystemException if a system exception occurred 2484 */ 2485 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2486 long groupId, long folderId, int start, int end) 2487 throws com.liferay.portal.kernel.exception.SystemException { 2488 return getPersistence().findByG_F(groupId, folderId, start, end); 2489 } 2490 2491 /** 2492 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ?. 2493 * 2494 * <p> 2495 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2496 * </p> 2497 * 2498 * @param groupId the group ID 2499 * @param folderId the folder ID 2500 * @param start the lower bound of the range of journal articles 2501 * @param end the upper bound of the range of journal articles (not inclusive) 2502 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2503 * @return the ordered range of matching journal articles 2504 * @throws SystemException if a system exception occurred 2505 */ 2506 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2507 long groupId, long folderId, int start, int end, 2508 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2509 throws com.liferay.portal.kernel.exception.SystemException { 2510 return getPersistence() 2511 .findByG_F(groupId, folderId, start, end, orderByComparator); 2512 } 2513 2514 /** 2515 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2516 * 2517 * @param groupId the group ID 2518 * @param folderId the folder ID 2519 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2520 * @return the first matching journal article 2521 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2522 * @throws SystemException if a system exception occurred 2523 */ 2524 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First( 2525 long groupId, long folderId, 2526 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2527 throws com.liferay.portal.kernel.exception.SystemException, 2528 com.liferay.portlet.journal.NoSuchArticleException { 2529 return getPersistence() 2530 .findByG_F_First(groupId, folderId, orderByComparator); 2531 } 2532 2533 /** 2534 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2535 * 2536 * @param groupId the group ID 2537 * @param folderId the folder ID 2538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2539 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2540 * @throws SystemException if a system exception occurred 2541 */ 2542 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First( 2543 long groupId, long folderId, 2544 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2545 throws com.liferay.portal.kernel.exception.SystemException { 2546 return getPersistence() 2547 .fetchByG_F_First(groupId, folderId, orderByComparator); 2548 } 2549 2550 /** 2551 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2552 * 2553 * @param groupId the group ID 2554 * @param folderId the folder ID 2555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2556 * @return the last matching journal article 2557 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2558 * @throws SystemException if a system exception occurred 2559 */ 2560 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last( 2561 long groupId, long folderId, 2562 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2563 throws com.liferay.portal.kernel.exception.SystemException, 2564 com.liferay.portlet.journal.NoSuchArticleException { 2565 return getPersistence() 2566 .findByG_F_Last(groupId, folderId, orderByComparator); 2567 } 2568 2569 /** 2570 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2571 * 2572 * @param groupId the group ID 2573 * @param folderId the folder ID 2574 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2575 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2576 * @throws SystemException if a system exception occurred 2577 */ 2578 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last( 2579 long groupId, long folderId, 2580 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2581 throws com.liferay.portal.kernel.exception.SystemException { 2582 return getPersistence() 2583 .fetchByG_F_Last(groupId, folderId, orderByComparator); 2584 } 2585 2586 /** 2587 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ?. 2588 * 2589 * @param id the primary key of the current journal article 2590 * @param groupId the group ID 2591 * @param folderId the folder ID 2592 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2593 * @return the previous, current, and next journal article 2594 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2595 * @throws SystemException if a system exception occurred 2596 */ 2597 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext( 2598 long id, long groupId, long folderId, 2599 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2600 throws com.liferay.portal.kernel.exception.SystemException, 2601 com.liferay.portlet.journal.NoSuchArticleException { 2602 return getPersistence() 2603 .findByG_F_PrevAndNext(id, groupId, folderId, 2604 orderByComparator); 2605 } 2606 2607 /** 2608 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2609 * 2610 * @param groupId the group ID 2611 * @param folderId the folder ID 2612 * @return the matching journal articles that the user has permission to view 2613 * @throws SystemException if a system exception occurred 2614 */ 2615 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2616 long groupId, long folderId) 2617 throws com.liferay.portal.kernel.exception.SystemException { 2618 return getPersistence().filterFindByG_F(groupId, folderId); 2619 } 2620 2621 /** 2622 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2623 * 2624 * <p> 2625 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2626 * </p> 2627 * 2628 * @param groupId the group ID 2629 * @param folderId the folder ID 2630 * @param start the lower bound of the range of journal articles 2631 * @param end the upper bound of the range of journal articles (not inclusive) 2632 * @return the range of matching journal articles that the user has permission to view 2633 * @throws SystemException if a system exception occurred 2634 */ 2635 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2636 long groupId, long folderId, int start, int end) 2637 throws com.liferay.portal.kernel.exception.SystemException { 2638 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 2639 } 2640 2641 /** 2642 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ?. 2643 * 2644 * <p> 2645 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2646 * </p> 2647 * 2648 * @param groupId the group ID 2649 * @param folderId the folder ID 2650 * @param start the lower bound of the range of journal articles 2651 * @param end the upper bound of the range of journal articles (not inclusive) 2652 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2653 * @return the ordered range of matching journal articles that the user has permission to view 2654 * @throws SystemException if a system exception occurred 2655 */ 2656 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2657 long groupId, long folderId, int start, int end, 2658 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2659 throws com.liferay.portal.kernel.exception.SystemException { 2660 return getPersistence() 2661 .filterFindByG_F(groupId, folderId, start, end, 2662 orderByComparator); 2663 } 2664 2665 /** 2666 * 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 = ?. 2667 * 2668 * @param id the primary key of the current journal article 2669 * @param groupId the group ID 2670 * @param folderId the folder ID 2671 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2672 * @return the previous, current, and next journal article 2673 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2674 * @throws SystemException if a system exception occurred 2675 */ 2676 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext( 2677 long id, long groupId, long folderId, 2678 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2679 throws com.liferay.portal.kernel.exception.SystemException, 2680 com.liferay.portlet.journal.NoSuchArticleException { 2681 return getPersistence() 2682 .filterFindByG_F_PrevAndNext(id, groupId, folderId, 2683 orderByComparator); 2684 } 2685 2686 /** 2687 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2688 * 2689 * @param groupId the group ID 2690 * @param folderIds the folder IDs 2691 * @return the matching journal articles that the user has permission to view 2692 * @throws SystemException if a system exception occurred 2693 */ 2694 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2695 long groupId, long[] folderIds) 2696 throws com.liferay.portal.kernel.exception.SystemException { 2697 return getPersistence().filterFindByG_F(groupId, folderIds); 2698 } 2699 2700 /** 2701 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2702 * 2703 * <p> 2704 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2705 * </p> 2706 * 2707 * @param groupId the group ID 2708 * @param folderIds the folder IDs 2709 * @param start the lower bound of the range of journal articles 2710 * @param end the upper bound of the range of journal articles (not inclusive) 2711 * @return the range of matching journal articles that the user has permission to view 2712 * @throws SystemException if a system exception occurred 2713 */ 2714 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2715 long groupId, long[] folderIds, int start, int end) 2716 throws com.liferay.portal.kernel.exception.SystemException { 2717 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 2718 } 2719 2720 /** 2721 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2722 * 2723 * <p> 2724 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2725 * </p> 2726 * 2727 * @param groupId the group ID 2728 * @param folderIds the folder IDs 2729 * @param start the lower bound of the range of journal articles 2730 * @param end the upper bound of the range of journal articles (not inclusive) 2731 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2732 * @return the ordered range of matching journal articles that the user has permission to view 2733 * @throws SystemException if a system exception occurred 2734 */ 2735 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2736 long groupId, long[] folderIds, int start, int end, 2737 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2738 throws com.liferay.portal.kernel.exception.SystemException { 2739 return getPersistence() 2740 .filterFindByG_F(groupId, folderIds, start, end, 2741 orderByComparator); 2742 } 2743 2744 /** 2745 * Returns all the journal articles where groupId = ? and folderId = any ?. 2746 * 2747 * <p> 2748 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2749 * </p> 2750 * 2751 * @param groupId the group ID 2752 * @param folderIds the folder IDs 2753 * @return the matching journal articles 2754 * @throws SystemException if a system exception occurred 2755 */ 2756 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2757 long groupId, long[] folderIds) 2758 throws com.liferay.portal.kernel.exception.SystemException { 2759 return getPersistence().findByG_F(groupId, folderIds); 2760 } 2761 2762 /** 2763 * Returns a range of all the journal articles where groupId = ? and folderId = any ?. 2764 * 2765 * <p> 2766 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2767 * </p> 2768 * 2769 * @param groupId the group ID 2770 * @param folderIds the folder IDs 2771 * @param start the lower bound of the range of journal articles 2772 * @param end the upper bound of the range of journal articles (not inclusive) 2773 * @return the range of matching journal articles 2774 * @throws SystemException if a system exception occurred 2775 */ 2776 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2777 long groupId, long[] folderIds, int start, int end) 2778 throws com.liferay.portal.kernel.exception.SystemException { 2779 return getPersistence().findByG_F(groupId, folderIds, start, end); 2780 } 2781 2782 /** 2783 * Returns an ordered range of all the journal articles where groupId = ? and folderId = any ?. 2784 * 2785 * <p> 2786 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2787 * </p> 2788 * 2789 * @param groupId the group ID 2790 * @param folderIds the folder IDs 2791 * @param start the lower bound of the range of journal articles 2792 * @param end the upper bound of the range of journal articles (not inclusive) 2793 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2794 * @return the ordered range of matching journal articles 2795 * @throws SystemException if a system exception occurred 2796 */ 2797 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2798 long groupId, long[] folderIds, int start, int end, 2799 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2800 throws com.liferay.portal.kernel.exception.SystemException { 2801 return getPersistence() 2802 .findByG_F(groupId, folderIds, start, end, orderByComparator); 2803 } 2804 2805 /** 2806 * Removes all the journal articles where groupId = ? and folderId = ? from the database. 2807 * 2808 * @param groupId the group ID 2809 * @param folderId the folder ID 2810 * @throws SystemException if a system exception occurred 2811 */ 2812 public static void removeByG_F(long groupId, long folderId) 2813 throws com.liferay.portal.kernel.exception.SystemException { 2814 getPersistence().removeByG_F(groupId, folderId); 2815 } 2816 2817 /** 2818 * Returns the number of journal articles where groupId = ? and folderId = ?. 2819 * 2820 * @param groupId the group ID 2821 * @param folderId the folder ID 2822 * @return the number of matching journal articles 2823 * @throws SystemException if a system exception occurred 2824 */ 2825 public static int countByG_F(long groupId, long folderId) 2826 throws com.liferay.portal.kernel.exception.SystemException { 2827 return getPersistence().countByG_F(groupId, folderId); 2828 } 2829 2830 /** 2831 * Returns the number of journal articles where groupId = ? and folderId = any ?. 2832 * 2833 * @param groupId the group ID 2834 * @param folderIds the folder IDs 2835 * @return the number of matching journal articles 2836 * @throws SystemException if a system exception occurred 2837 */ 2838 public static int countByG_F(long groupId, long[] folderIds) 2839 throws com.liferay.portal.kernel.exception.SystemException { 2840 return getPersistence().countByG_F(groupId, folderIds); 2841 } 2842 2843 /** 2844 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ?. 2845 * 2846 * @param groupId the group ID 2847 * @param folderId the folder ID 2848 * @return the number of matching journal articles that the user has permission to view 2849 * @throws SystemException if a system exception occurred 2850 */ 2851 public static int filterCountByG_F(long groupId, long folderId) 2852 throws com.liferay.portal.kernel.exception.SystemException { 2853 return getPersistence().filterCountByG_F(groupId, folderId); 2854 } 2855 2856 /** 2857 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2858 * 2859 * @param groupId the group ID 2860 * @param folderIds the folder IDs 2861 * @return the number of matching journal articles that the user has permission to view 2862 * @throws SystemException if a system exception occurred 2863 */ 2864 public static int filterCountByG_F(long groupId, long[] folderIds) 2865 throws com.liferay.portal.kernel.exception.SystemException { 2866 return getPersistence().filterCountByG_F(groupId, folderIds); 2867 } 2868 2869 /** 2870 * Returns all the journal articles where groupId = ? and articleId = ?. 2871 * 2872 * @param groupId the group ID 2873 * @param articleId the article ID 2874 * @return the matching journal articles 2875 * @throws SystemException if a system exception occurred 2876 */ 2877 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2878 long groupId, java.lang.String articleId) 2879 throws com.liferay.portal.kernel.exception.SystemException { 2880 return getPersistence().findByG_A(groupId, articleId); 2881 } 2882 2883 /** 2884 * Returns a range of all the journal articles where groupId = ? and articleId = ?. 2885 * 2886 * <p> 2887 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2888 * </p> 2889 * 2890 * @param groupId the group ID 2891 * @param articleId the article ID 2892 * @param start the lower bound of the range of journal articles 2893 * @param end the upper bound of the range of journal articles (not inclusive) 2894 * @return the range of matching journal articles 2895 * @throws SystemException if a system exception occurred 2896 */ 2897 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2898 long groupId, java.lang.String articleId, int start, int end) 2899 throws com.liferay.portal.kernel.exception.SystemException { 2900 return getPersistence().findByG_A(groupId, articleId, start, end); 2901 } 2902 2903 /** 2904 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ?. 2905 * 2906 * <p> 2907 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 2908 * </p> 2909 * 2910 * @param groupId the group ID 2911 * @param articleId the article ID 2912 * @param start the lower bound of the range of journal articles 2913 * @param end the upper bound of the range of journal articles (not inclusive) 2914 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2915 * @return the ordered range of matching journal articles 2916 * @throws SystemException if a system exception occurred 2917 */ 2918 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2919 long groupId, java.lang.String articleId, int start, int end, 2920 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2921 throws com.liferay.portal.kernel.exception.SystemException { 2922 return getPersistence() 2923 .findByG_A(groupId, articleId, start, end, orderByComparator); 2924 } 2925 2926 /** 2927 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 2928 * 2929 * @param groupId the group ID 2930 * @param articleId the article ID 2931 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2932 * @return the first matching journal article 2933 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2934 * @throws SystemException if a system exception occurred 2935 */ 2936 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First( 2937 long groupId, java.lang.String articleId, 2938 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2939 throws com.liferay.portal.kernel.exception.SystemException, 2940 com.liferay.portlet.journal.NoSuchArticleException { 2941 return getPersistence() 2942 .findByG_A_First(groupId, articleId, orderByComparator); 2943 } 2944 2945 /** 2946 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 2947 * 2948 * @param groupId the group ID 2949 * @param articleId the article ID 2950 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2951 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2952 * @throws SystemException if a system exception occurred 2953 */ 2954 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First( 2955 long groupId, java.lang.String articleId, 2956 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2957 throws com.liferay.portal.kernel.exception.SystemException { 2958 return getPersistence() 2959 .fetchByG_A_First(groupId, articleId, orderByComparator); 2960 } 2961 2962 /** 2963 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 2964 * 2965 * @param groupId the group ID 2966 * @param articleId the article ID 2967 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2968 * @return the last matching journal article 2969 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2970 * @throws SystemException if a system exception occurred 2971 */ 2972 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last( 2973 long groupId, java.lang.String articleId, 2974 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2975 throws com.liferay.portal.kernel.exception.SystemException, 2976 com.liferay.portlet.journal.NoSuchArticleException { 2977 return getPersistence() 2978 .findByG_A_Last(groupId, articleId, orderByComparator); 2979 } 2980 2981 /** 2982 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 2983 * 2984 * @param groupId the group ID 2985 * @param articleId the article ID 2986 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2987 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2988 * @throws SystemException if a system exception occurred 2989 */ 2990 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last( 2991 long groupId, java.lang.String articleId, 2992 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2993 throws com.liferay.portal.kernel.exception.SystemException { 2994 return getPersistence() 2995 .fetchByG_A_Last(groupId, articleId, orderByComparator); 2996 } 2997 2998 /** 2999 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ?. 3000 * 3001 * @param id the primary key of the current journal article 3002 * @param groupId the group ID 3003 * @param articleId the article ID 3004 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3005 * @return the previous, current, and next journal article 3006 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3007 * @throws SystemException if a system exception occurred 3008 */ 3009 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext( 3010 long id, long groupId, java.lang.String articleId, 3011 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3012 throws com.liferay.portal.kernel.exception.SystemException, 3013 com.liferay.portlet.journal.NoSuchArticleException { 3014 return getPersistence() 3015 .findByG_A_PrevAndNext(id, groupId, articleId, 3016 orderByComparator); 3017 } 3018 3019 /** 3020 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 3021 * 3022 * @param groupId the group ID 3023 * @param articleId the article ID 3024 * @return the matching journal articles that the user has permission to view 3025 * @throws SystemException if a system exception occurred 3026 */ 3027 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3028 long groupId, java.lang.String articleId) 3029 throws com.liferay.portal.kernel.exception.SystemException { 3030 return getPersistence().filterFindByG_A(groupId, articleId); 3031 } 3032 3033 /** 3034 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 3035 * 3036 * <p> 3037 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3038 * </p> 3039 * 3040 * @param groupId the group ID 3041 * @param articleId the article ID 3042 * @param start the lower bound of the range of journal articles 3043 * @param end the upper bound of the range of journal articles (not inclusive) 3044 * @return the range of matching journal articles that the user has permission to view 3045 * @throws SystemException if a system exception occurred 3046 */ 3047 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3048 long groupId, java.lang.String articleId, int start, int end) 3049 throws com.liferay.portal.kernel.exception.SystemException { 3050 return getPersistence().filterFindByG_A(groupId, articleId, start, end); 3051 } 3052 3053 /** 3054 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ?. 3055 * 3056 * <p> 3057 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3058 * </p> 3059 * 3060 * @param groupId the group ID 3061 * @param articleId the article ID 3062 * @param start the lower bound of the range of journal articles 3063 * @param end the upper bound of the range of journal articles (not inclusive) 3064 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3065 * @return the ordered range of matching journal articles that the user has permission to view 3066 * @throws SystemException if a system exception occurred 3067 */ 3068 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3069 long groupId, java.lang.String articleId, int start, int end, 3070 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3071 throws com.liferay.portal.kernel.exception.SystemException { 3072 return getPersistence() 3073 .filterFindByG_A(groupId, articleId, start, end, 3074 orderByComparator); 3075 } 3076 3077 /** 3078 * 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 = ?. 3079 * 3080 * @param id the primary key of the current journal article 3081 * @param groupId the group ID 3082 * @param articleId the article ID 3083 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3084 * @return the previous, current, and next journal article 3085 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3086 * @throws SystemException if a system exception occurred 3087 */ 3088 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext( 3089 long id, long groupId, java.lang.String articleId, 3090 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3091 throws com.liferay.portal.kernel.exception.SystemException, 3092 com.liferay.portlet.journal.NoSuchArticleException { 3093 return getPersistence() 3094 .filterFindByG_A_PrevAndNext(id, groupId, articleId, 3095 orderByComparator); 3096 } 3097 3098 /** 3099 * Removes all the journal articles where groupId = ? and articleId = ? from the database. 3100 * 3101 * @param groupId the group ID 3102 * @param articleId the article ID 3103 * @throws SystemException if a system exception occurred 3104 */ 3105 public static void removeByG_A(long groupId, java.lang.String articleId) 3106 throws com.liferay.portal.kernel.exception.SystemException { 3107 getPersistence().removeByG_A(groupId, articleId); 3108 } 3109 3110 /** 3111 * Returns the number of journal articles where groupId = ? and articleId = ?. 3112 * 3113 * @param groupId the group ID 3114 * @param articleId the article ID 3115 * @return the number of matching journal articles 3116 * @throws SystemException if a system exception occurred 3117 */ 3118 public static int countByG_A(long groupId, java.lang.String articleId) 3119 throws com.liferay.portal.kernel.exception.SystemException { 3120 return getPersistence().countByG_A(groupId, articleId); 3121 } 3122 3123 /** 3124 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ?. 3125 * 3126 * @param groupId the group ID 3127 * @param articleId the article ID 3128 * @return the number of matching journal articles that the user has permission to view 3129 * @throws SystemException if a system exception occurred 3130 */ 3131 public static int filterCountByG_A(long groupId, java.lang.String articleId) 3132 throws com.liferay.portal.kernel.exception.SystemException { 3133 return getPersistence().filterCountByG_A(groupId, articleId); 3134 } 3135 3136 /** 3137 * Returns all the journal articles where groupId = ? and urlTitle = ?. 3138 * 3139 * @param groupId the group ID 3140 * @param urlTitle the url title 3141 * @return the matching journal articles 3142 * @throws SystemException if a system exception occurred 3143 */ 3144 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3145 long groupId, java.lang.String urlTitle) 3146 throws com.liferay.portal.kernel.exception.SystemException { 3147 return getPersistence().findByG_UT(groupId, urlTitle); 3148 } 3149 3150 /** 3151 * Returns a range of all the journal articles where groupId = ? and urlTitle = ?. 3152 * 3153 * <p> 3154 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3155 * </p> 3156 * 3157 * @param groupId the group ID 3158 * @param urlTitle the url title 3159 * @param start the lower bound of the range of journal articles 3160 * @param end the upper bound of the range of journal articles (not inclusive) 3161 * @return the range of matching journal articles 3162 * @throws SystemException if a system exception occurred 3163 */ 3164 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3165 long groupId, java.lang.String urlTitle, int start, int end) 3166 throws com.liferay.portal.kernel.exception.SystemException { 3167 return getPersistence().findByG_UT(groupId, urlTitle, start, end); 3168 } 3169 3170 /** 3171 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ?. 3172 * 3173 * <p> 3174 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3175 * </p> 3176 * 3177 * @param groupId the group ID 3178 * @param urlTitle the url title 3179 * @param start the lower bound of the range of journal articles 3180 * @param end the upper bound of the range of journal articles (not inclusive) 3181 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3182 * @return the ordered range of matching journal articles 3183 * @throws SystemException if a system exception occurred 3184 */ 3185 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3186 long groupId, java.lang.String urlTitle, int start, int end, 3187 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3188 throws com.liferay.portal.kernel.exception.SystemException { 3189 return getPersistence() 3190 .findByG_UT(groupId, urlTitle, start, end, orderByComparator); 3191 } 3192 3193 /** 3194 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3195 * 3196 * @param groupId the group ID 3197 * @param urlTitle the url title 3198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3199 * @return the first matching journal article 3200 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3201 * @throws SystemException if a system exception occurred 3202 */ 3203 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First( 3204 long groupId, java.lang.String urlTitle, 3205 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3206 throws com.liferay.portal.kernel.exception.SystemException, 3207 com.liferay.portlet.journal.NoSuchArticleException { 3208 return getPersistence() 3209 .findByG_UT_First(groupId, urlTitle, orderByComparator); 3210 } 3211 3212 /** 3213 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3214 * 3215 * @param groupId the group ID 3216 * @param urlTitle the url title 3217 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3218 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3219 * @throws SystemException if a system exception occurred 3220 */ 3221 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First( 3222 long groupId, java.lang.String urlTitle, 3223 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3224 throws com.liferay.portal.kernel.exception.SystemException { 3225 return getPersistence() 3226 .fetchByG_UT_First(groupId, urlTitle, orderByComparator); 3227 } 3228 3229 /** 3230 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3231 * 3232 * @param groupId the group ID 3233 * @param urlTitle the url title 3234 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3235 * @return the last matching journal article 3236 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3237 * @throws SystemException if a system exception occurred 3238 */ 3239 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last( 3240 long groupId, java.lang.String urlTitle, 3241 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3242 throws com.liferay.portal.kernel.exception.SystemException, 3243 com.liferay.portlet.journal.NoSuchArticleException { 3244 return getPersistence() 3245 .findByG_UT_Last(groupId, urlTitle, orderByComparator); 3246 } 3247 3248 /** 3249 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3250 * 3251 * @param groupId the group ID 3252 * @param urlTitle the url title 3253 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3254 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3255 * @throws SystemException if a system exception occurred 3256 */ 3257 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last( 3258 long groupId, java.lang.String urlTitle, 3259 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3260 throws com.liferay.portal.kernel.exception.SystemException { 3261 return getPersistence() 3262 .fetchByG_UT_Last(groupId, urlTitle, orderByComparator); 3263 } 3264 3265 /** 3266 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ?. 3267 * 3268 * @param id the primary key of the current journal article 3269 * @param groupId the group ID 3270 * @param urlTitle the url title 3271 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3272 * @return the previous, current, and next journal article 3273 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3274 * @throws SystemException if a system exception occurred 3275 */ 3276 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext( 3277 long id, long groupId, java.lang.String urlTitle, 3278 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3279 throws com.liferay.portal.kernel.exception.SystemException, 3280 com.liferay.portlet.journal.NoSuchArticleException { 3281 return getPersistence() 3282 .findByG_UT_PrevAndNext(id, groupId, urlTitle, 3283 orderByComparator); 3284 } 3285 3286 /** 3287 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3288 * 3289 * @param groupId the group ID 3290 * @param urlTitle the url title 3291 * @return the matching journal articles that the user has permission to view 3292 * @throws SystemException if a system exception occurred 3293 */ 3294 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3295 long groupId, java.lang.String urlTitle) 3296 throws com.liferay.portal.kernel.exception.SystemException { 3297 return getPersistence().filterFindByG_UT(groupId, urlTitle); 3298 } 3299 3300 /** 3301 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3302 * 3303 * <p> 3304 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3305 * </p> 3306 * 3307 * @param groupId the group ID 3308 * @param urlTitle the url title 3309 * @param start the lower bound of the range of journal articles 3310 * @param end the upper bound of the range of journal articles (not inclusive) 3311 * @return the range of matching journal articles that the user has permission to view 3312 * @throws SystemException if a system exception occurred 3313 */ 3314 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3315 long groupId, java.lang.String urlTitle, int start, int end) 3316 throws com.liferay.portal.kernel.exception.SystemException { 3317 return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end); 3318 } 3319 3320 /** 3321 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ?. 3322 * 3323 * <p> 3324 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3325 * </p> 3326 * 3327 * @param groupId the group ID 3328 * @param urlTitle the url title 3329 * @param start the lower bound of the range of journal articles 3330 * @param end the upper bound of the range of journal articles (not inclusive) 3331 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3332 * @return the ordered range of matching journal articles that the user has permission to view 3333 * @throws SystemException if a system exception occurred 3334 */ 3335 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3336 long groupId, java.lang.String urlTitle, int start, int end, 3337 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3338 throws com.liferay.portal.kernel.exception.SystemException { 3339 return getPersistence() 3340 .filterFindByG_UT(groupId, urlTitle, start, end, 3341 orderByComparator); 3342 } 3343 3344 /** 3345 * 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 = ?. 3346 * 3347 * @param id the primary key of the current journal article 3348 * @param groupId the group ID 3349 * @param urlTitle the url title 3350 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3351 * @return the previous, current, and next journal article 3352 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3353 * @throws SystemException if a system exception occurred 3354 */ 3355 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext( 3356 long id, long groupId, java.lang.String urlTitle, 3357 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3358 throws com.liferay.portal.kernel.exception.SystemException, 3359 com.liferay.portlet.journal.NoSuchArticleException { 3360 return getPersistence() 3361 .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle, 3362 orderByComparator); 3363 } 3364 3365 /** 3366 * Removes all the journal articles where groupId = ? and urlTitle = ? from the database. 3367 * 3368 * @param groupId the group ID 3369 * @param urlTitle the url title 3370 * @throws SystemException if a system exception occurred 3371 */ 3372 public static void removeByG_UT(long groupId, java.lang.String urlTitle) 3373 throws com.liferay.portal.kernel.exception.SystemException { 3374 getPersistence().removeByG_UT(groupId, urlTitle); 3375 } 3376 3377 /** 3378 * Returns the number of journal articles where groupId = ? and urlTitle = ?. 3379 * 3380 * @param groupId the group ID 3381 * @param urlTitle the url title 3382 * @return the number of matching journal articles 3383 * @throws SystemException if a system exception occurred 3384 */ 3385 public static int countByG_UT(long groupId, java.lang.String urlTitle) 3386 throws com.liferay.portal.kernel.exception.SystemException { 3387 return getPersistence().countByG_UT(groupId, urlTitle); 3388 } 3389 3390 /** 3391 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3392 * 3393 * @param groupId the group ID 3394 * @param urlTitle the url title 3395 * @return the number of matching journal articles that the user has permission to view 3396 * @throws SystemException if a system exception occurred 3397 */ 3398 public static int filterCountByG_UT(long groupId, java.lang.String urlTitle) 3399 throws com.liferay.portal.kernel.exception.SystemException { 3400 return getPersistence().filterCountByG_UT(groupId, urlTitle); 3401 } 3402 3403 /** 3404 * Returns all the journal articles where groupId = ? and structureId = ?. 3405 * 3406 * @param groupId the group ID 3407 * @param structureId the structure ID 3408 * @return the matching journal articles 3409 * @throws SystemException if a system exception occurred 3410 */ 3411 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3412 long groupId, java.lang.String structureId) 3413 throws com.liferay.portal.kernel.exception.SystemException { 3414 return getPersistence().findByG_S(groupId, structureId); 3415 } 3416 3417 /** 3418 * Returns a range of all the journal articles where groupId = ? and structureId = ?. 3419 * 3420 * <p> 3421 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3422 * </p> 3423 * 3424 * @param groupId the group ID 3425 * @param structureId the structure ID 3426 * @param start the lower bound of the range of journal articles 3427 * @param end the upper bound of the range of journal articles (not inclusive) 3428 * @return the range of matching journal articles 3429 * @throws SystemException if a system exception occurred 3430 */ 3431 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3432 long groupId, java.lang.String structureId, int start, int end) 3433 throws com.liferay.portal.kernel.exception.SystemException { 3434 return getPersistence().findByG_S(groupId, structureId, start, end); 3435 } 3436 3437 /** 3438 * Returns an ordered range of all the journal articles where groupId = ? and structureId = ?. 3439 * 3440 * <p> 3441 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3442 * </p> 3443 * 3444 * @param groupId the group ID 3445 * @param structureId the structure ID 3446 * @param start the lower bound of the range of journal articles 3447 * @param end the upper bound of the range of journal articles (not inclusive) 3448 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3449 * @return the ordered range of matching journal articles 3450 * @throws SystemException if a system exception occurred 3451 */ 3452 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3453 long groupId, java.lang.String structureId, int start, int end, 3454 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3455 throws com.liferay.portal.kernel.exception.SystemException { 3456 return getPersistence() 3457 .findByG_S(groupId, structureId, start, end, 3458 orderByComparator); 3459 } 3460 3461 /** 3462 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3463 * 3464 * @param groupId the group ID 3465 * @param structureId the structure ID 3466 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3467 * @return the first matching journal article 3468 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3469 * @throws SystemException if a system exception occurred 3470 */ 3471 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First( 3472 long groupId, java.lang.String structureId, 3473 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3474 throws com.liferay.portal.kernel.exception.SystemException, 3475 com.liferay.portlet.journal.NoSuchArticleException { 3476 return getPersistence() 3477 .findByG_S_First(groupId, structureId, orderByComparator); 3478 } 3479 3480 /** 3481 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3482 * 3483 * @param groupId the group ID 3484 * @param structureId the structure ID 3485 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3486 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3487 * @throws SystemException if a system exception occurred 3488 */ 3489 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First( 3490 long groupId, java.lang.String structureId, 3491 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3492 throws com.liferay.portal.kernel.exception.SystemException { 3493 return getPersistence() 3494 .fetchByG_S_First(groupId, structureId, orderByComparator); 3495 } 3496 3497 /** 3498 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3499 * 3500 * @param groupId the group ID 3501 * @param structureId the structure ID 3502 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3503 * @return the last matching journal article 3504 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3505 * @throws SystemException if a system exception occurred 3506 */ 3507 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last( 3508 long groupId, java.lang.String structureId, 3509 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3510 throws com.liferay.portal.kernel.exception.SystemException, 3511 com.liferay.portlet.journal.NoSuchArticleException { 3512 return getPersistence() 3513 .findByG_S_Last(groupId, structureId, orderByComparator); 3514 } 3515 3516 /** 3517 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3518 * 3519 * @param groupId the group ID 3520 * @param structureId the structure ID 3521 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3522 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3523 * @throws SystemException if a system exception occurred 3524 */ 3525 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last( 3526 long groupId, java.lang.String structureId, 3527 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3528 throws com.liferay.portal.kernel.exception.SystemException { 3529 return getPersistence() 3530 .fetchByG_S_Last(groupId, structureId, orderByComparator); 3531 } 3532 3533 /** 3534 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and structureId = ?. 3535 * 3536 * @param id the primary key of the current journal article 3537 * @param groupId the group ID 3538 * @param structureId the structure ID 3539 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3540 * @return the previous, current, and next journal article 3541 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3542 * @throws SystemException if a system exception occurred 3543 */ 3544 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext( 3545 long id, long groupId, java.lang.String structureId, 3546 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3547 throws com.liferay.portal.kernel.exception.SystemException, 3548 com.liferay.portlet.journal.NoSuchArticleException { 3549 return getPersistence() 3550 .findByG_S_PrevAndNext(id, groupId, structureId, 3551 orderByComparator); 3552 } 3553 3554 /** 3555 * Returns all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3556 * 3557 * @param groupId the group ID 3558 * @param structureId the structure ID 3559 * @return the matching journal articles that the user has permission to view 3560 * @throws SystemException if a system exception occurred 3561 */ 3562 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3563 long groupId, java.lang.String structureId) 3564 throws com.liferay.portal.kernel.exception.SystemException { 3565 return getPersistence().filterFindByG_S(groupId, structureId); 3566 } 3567 3568 /** 3569 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3570 * 3571 * <p> 3572 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3573 * </p> 3574 * 3575 * @param groupId the group ID 3576 * @param structureId the structure ID 3577 * @param start the lower bound of the range of journal articles 3578 * @param end the upper bound of the range of journal articles (not inclusive) 3579 * @return the range of matching journal articles that the user has permission to view 3580 * @throws SystemException if a system exception occurred 3581 */ 3582 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3583 long groupId, java.lang.String structureId, int start, int end) 3584 throws com.liferay.portal.kernel.exception.SystemException { 3585 return getPersistence().filterFindByG_S(groupId, structureId, start, end); 3586 } 3587 3588 /** 3589 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and structureId = ?. 3590 * 3591 * <p> 3592 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3593 * </p> 3594 * 3595 * @param groupId the group ID 3596 * @param structureId the structure ID 3597 * @param start the lower bound of the range of journal articles 3598 * @param end the upper bound of the range of journal articles (not inclusive) 3599 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3600 * @return the ordered range of matching journal articles that the user has permission to view 3601 * @throws SystemException if a system exception occurred 3602 */ 3603 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3604 long groupId, java.lang.String structureId, int start, int end, 3605 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3606 throws com.liferay.portal.kernel.exception.SystemException { 3607 return getPersistence() 3608 .filterFindByG_S(groupId, structureId, start, end, 3609 orderByComparator); 3610 } 3611 3612 /** 3613 * 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 = ?. 3614 * 3615 * @param id the primary key of the current journal article 3616 * @param groupId the group ID 3617 * @param structureId the structure ID 3618 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3619 * @return the previous, current, and next journal article 3620 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3621 * @throws SystemException if a system exception occurred 3622 */ 3623 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext( 3624 long id, long groupId, java.lang.String structureId, 3625 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3626 throws com.liferay.portal.kernel.exception.SystemException, 3627 com.liferay.portlet.journal.NoSuchArticleException { 3628 return getPersistence() 3629 .filterFindByG_S_PrevAndNext(id, groupId, structureId, 3630 orderByComparator); 3631 } 3632 3633 /** 3634 * Removes all the journal articles where groupId = ? and structureId = ? from the database. 3635 * 3636 * @param groupId the group ID 3637 * @param structureId the structure ID 3638 * @throws SystemException if a system exception occurred 3639 */ 3640 public static void removeByG_S(long groupId, java.lang.String structureId) 3641 throws com.liferay.portal.kernel.exception.SystemException { 3642 getPersistence().removeByG_S(groupId, structureId); 3643 } 3644 3645 /** 3646 * Returns the number of journal articles where groupId = ? and structureId = ?. 3647 * 3648 * @param groupId the group ID 3649 * @param structureId the structure ID 3650 * @return the number of matching journal articles 3651 * @throws SystemException if a system exception occurred 3652 */ 3653 public static int countByG_S(long groupId, java.lang.String structureId) 3654 throws com.liferay.portal.kernel.exception.SystemException { 3655 return getPersistence().countByG_S(groupId, structureId); 3656 } 3657 3658 /** 3659 * Returns the number of journal articles that the user has permission to view where groupId = ? and structureId = ?. 3660 * 3661 * @param groupId the group ID 3662 * @param structureId the structure ID 3663 * @return the number of matching journal articles that the user has permission to view 3664 * @throws SystemException if a system exception occurred 3665 */ 3666 public static int filterCountByG_S(long groupId, 3667 java.lang.String structureId) 3668 throws com.liferay.portal.kernel.exception.SystemException { 3669 return getPersistence().filterCountByG_S(groupId, structureId); 3670 } 3671 3672 /** 3673 * Returns all the journal articles where groupId = ? and templateId = ?. 3674 * 3675 * @param groupId the group ID 3676 * @param templateId the template ID 3677 * @return the matching journal articles 3678 * @throws SystemException if a system exception occurred 3679 */ 3680 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3681 long groupId, java.lang.String templateId) 3682 throws com.liferay.portal.kernel.exception.SystemException { 3683 return getPersistence().findByG_T(groupId, templateId); 3684 } 3685 3686 /** 3687 * Returns a range of all the journal articles where groupId = ? and templateId = ?. 3688 * 3689 * <p> 3690 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3691 * </p> 3692 * 3693 * @param groupId the group ID 3694 * @param templateId the template ID 3695 * @param start the lower bound of the range of journal articles 3696 * @param end the upper bound of the range of journal articles (not inclusive) 3697 * @return the range of matching journal articles 3698 * @throws SystemException if a system exception occurred 3699 */ 3700 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3701 long groupId, java.lang.String templateId, int start, int end) 3702 throws com.liferay.portal.kernel.exception.SystemException { 3703 return getPersistence().findByG_T(groupId, templateId, start, end); 3704 } 3705 3706 /** 3707 * Returns an ordered range of all the journal articles where groupId = ? and templateId = ?. 3708 * 3709 * <p> 3710 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3711 * </p> 3712 * 3713 * @param groupId the group ID 3714 * @param templateId the template ID 3715 * @param start the lower bound of the range of journal articles 3716 * @param end the upper bound of the range of journal articles (not inclusive) 3717 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3718 * @return the ordered range of matching journal articles 3719 * @throws SystemException if a system exception occurred 3720 */ 3721 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3722 long groupId, java.lang.String templateId, int start, int end, 3723 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3724 throws com.liferay.portal.kernel.exception.SystemException { 3725 return getPersistence() 3726 .findByG_T(groupId, templateId, start, end, orderByComparator); 3727 } 3728 3729 /** 3730 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3731 * 3732 * @param groupId the group ID 3733 * @param templateId the template ID 3734 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3735 * @return the first matching journal article 3736 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3737 * @throws SystemException if a system exception occurred 3738 */ 3739 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First( 3740 long groupId, java.lang.String templateId, 3741 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3742 throws com.liferay.portal.kernel.exception.SystemException, 3743 com.liferay.portlet.journal.NoSuchArticleException { 3744 return getPersistence() 3745 .findByG_T_First(groupId, templateId, orderByComparator); 3746 } 3747 3748 /** 3749 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3750 * 3751 * @param groupId the group ID 3752 * @param templateId the template ID 3753 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3754 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3755 * @throws SystemException if a system exception occurred 3756 */ 3757 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First( 3758 long groupId, java.lang.String templateId, 3759 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3760 throws com.liferay.portal.kernel.exception.SystemException { 3761 return getPersistence() 3762 .fetchByG_T_First(groupId, templateId, orderByComparator); 3763 } 3764 3765 /** 3766 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3767 * 3768 * @param groupId the group ID 3769 * @param templateId the template ID 3770 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3771 * @return the last matching journal article 3772 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3773 * @throws SystemException if a system exception occurred 3774 */ 3775 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last( 3776 long groupId, java.lang.String templateId, 3777 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3778 throws com.liferay.portal.kernel.exception.SystemException, 3779 com.liferay.portlet.journal.NoSuchArticleException { 3780 return getPersistence() 3781 .findByG_T_Last(groupId, templateId, orderByComparator); 3782 } 3783 3784 /** 3785 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3786 * 3787 * @param groupId the group ID 3788 * @param templateId the template ID 3789 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3790 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3791 * @throws SystemException if a system exception occurred 3792 */ 3793 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last( 3794 long groupId, java.lang.String templateId, 3795 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3796 throws com.liferay.portal.kernel.exception.SystemException { 3797 return getPersistence() 3798 .fetchByG_T_Last(groupId, templateId, orderByComparator); 3799 } 3800 3801 /** 3802 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and templateId = ?. 3803 * 3804 * @param id the primary key of the current journal article 3805 * @param groupId the group ID 3806 * @param templateId the template ID 3807 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3808 * @return the previous, current, and next journal article 3809 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3810 * @throws SystemException if a system exception occurred 3811 */ 3812 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext( 3813 long id, long groupId, java.lang.String templateId, 3814 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3815 throws com.liferay.portal.kernel.exception.SystemException, 3816 com.liferay.portlet.journal.NoSuchArticleException { 3817 return getPersistence() 3818 .findByG_T_PrevAndNext(id, groupId, templateId, 3819 orderByComparator); 3820 } 3821 3822 /** 3823 * Returns all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3824 * 3825 * @param groupId the group ID 3826 * @param templateId the template ID 3827 * @return the matching journal articles that the user has permission to view 3828 * @throws SystemException if a system exception occurred 3829 */ 3830 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3831 long groupId, java.lang.String templateId) 3832 throws com.liferay.portal.kernel.exception.SystemException { 3833 return getPersistence().filterFindByG_T(groupId, templateId); 3834 } 3835 3836 /** 3837 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3838 * 3839 * <p> 3840 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3841 * </p> 3842 * 3843 * @param groupId the group ID 3844 * @param templateId the template ID 3845 * @param start the lower bound of the range of journal articles 3846 * @param end the upper bound of the range of journal articles (not inclusive) 3847 * @return the range of matching journal articles that the user has permission to view 3848 * @throws SystemException if a system exception occurred 3849 */ 3850 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3851 long groupId, java.lang.String templateId, int start, int end) 3852 throws com.liferay.portal.kernel.exception.SystemException { 3853 return getPersistence().filterFindByG_T(groupId, templateId, start, end); 3854 } 3855 3856 /** 3857 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and templateId = ?. 3858 * 3859 * <p> 3860 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3861 * </p> 3862 * 3863 * @param groupId the group ID 3864 * @param templateId the template ID 3865 * @param start the lower bound of the range of journal articles 3866 * @param end the upper bound of the range of journal articles (not inclusive) 3867 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3868 * @return the ordered range of matching journal articles that the user has permission to view 3869 * @throws SystemException if a system exception occurred 3870 */ 3871 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3872 long groupId, java.lang.String templateId, int start, int end, 3873 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3874 throws com.liferay.portal.kernel.exception.SystemException { 3875 return getPersistence() 3876 .filterFindByG_T(groupId, templateId, start, end, 3877 orderByComparator); 3878 } 3879 3880 /** 3881 * 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 = ?. 3882 * 3883 * @param id the primary key of the current journal article 3884 * @param groupId the group ID 3885 * @param templateId the template ID 3886 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3887 * @return the previous, current, and next journal article 3888 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3889 * @throws SystemException if a system exception occurred 3890 */ 3891 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext( 3892 long id, long groupId, java.lang.String templateId, 3893 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3894 throws com.liferay.portal.kernel.exception.SystemException, 3895 com.liferay.portlet.journal.NoSuchArticleException { 3896 return getPersistence() 3897 .filterFindByG_T_PrevAndNext(id, groupId, templateId, 3898 orderByComparator); 3899 } 3900 3901 /** 3902 * Removes all the journal articles where groupId = ? and templateId = ? from the database. 3903 * 3904 * @param groupId the group ID 3905 * @param templateId the template ID 3906 * @throws SystemException if a system exception occurred 3907 */ 3908 public static void removeByG_T(long groupId, java.lang.String templateId) 3909 throws com.liferay.portal.kernel.exception.SystemException { 3910 getPersistence().removeByG_T(groupId, templateId); 3911 } 3912 3913 /** 3914 * Returns the number of journal articles where groupId = ? and templateId = ?. 3915 * 3916 * @param groupId the group ID 3917 * @param templateId the template ID 3918 * @return the number of matching journal articles 3919 * @throws SystemException if a system exception occurred 3920 */ 3921 public static int countByG_T(long groupId, java.lang.String templateId) 3922 throws com.liferay.portal.kernel.exception.SystemException { 3923 return getPersistence().countByG_T(groupId, templateId); 3924 } 3925 3926 /** 3927 * Returns the number of journal articles that the user has permission to view where groupId = ? and templateId = ?. 3928 * 3929 * @param groupId the group ID 3930 * @param templateId the template ID 3931 * @return the number of matching journal articles that the user has permission to view 3932 * @throws SystemException if a system exception occurred 3933 */ 3934 public static int filterCountByG_T(long groupId, java.lang.String templateId) 3935 throws com.liferay.portal.kernel.exception.SystemException { 3936 return getPersistence().filterCountByG_T(groupId, templateId); 3937 } 3938 3939 /** 3940 * Returns all the journal articles where groupId = ? and layoutUuid = ?. 3941 * 3942 * @param groupId the group ID 3943 * @param layoutUuid the layout uuid 3944 * @return the matching journal articles 3945 * @throws SystemException if a system exception occurred 3946 */ 3947 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3948 long groupId, java.lang.String layoutUuid) 3949 throws com.liferay.portal.kernel.exception.SystemException { 3950 return getPersistence().findByG_L(groupId, layoutUuid); 3951 } 3952 3953 /** 3954 * Returns a range of all the journal articles where groupId = ? and layoutUuid = ?. 3955 * 3956 * <p> 3957 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3958 * </p> 3959 * 3960 * @param groupId the group ID 3961 * @param layoutUuid the layout uuid 3962 * @param start the lower bound of the range of journal articles 3963 * @param end the upper bound of the range of journal articles (not inclusive) 3964 * @return the range of matching journal articles 3965 * @throws SystemException if a system exception occurred 3966 */ 3967 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3968 long groupId, java.lang.String layoutUuid, int start, int end) 3969 throws com.liferay.portal.kernel.exception.SystemException { 3970 return getPersistence().findByG_L(groupId, layoutUuid, start, end); 3971 } 3972 3973 /** 3974 * Returns an ordered range of all the journal articles where groupId = ? and layoutUuid = ?. 3975 * 3976 * <p> 3977 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 3978 * </p> 3979 * 3980 * @param groupId the group ID 3981 * @param layoutUuid the layout uuid 3982 * @param start the lower bound of the range of journal articles 3983 * @param end the upper bound of the range of journal articles (not inclusive) 3984 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3985 * @return the ordered range of matching journal articles 3986 * @throws SystemException if a system exception occurred 3987 */ 3988 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3989 long groupId, java.lang.String layoutUuid, int start, int end, 3990 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3991 throws com.liferay.portal.kernel.exception.SystemException { 3992 return getPersistence() 3993 .findByG_L(groupId, layoutUuid, start, end, orderByComparator); 3994 } 3995 3996 /** 3997 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 3998 * 3999 * @param groupId the group ID 4000 * @param layoutUuid the layout uuid 4001 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4002 * @return the first matching journal article 4003 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4004 * @throws SystemException if a system exception occurred 4005 */ 4006 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First( 4007 long groupId, java.lang.String layoutUuid, 4008 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4009 throws com.liferay.portal.kernel.exception.SystemException, 4010 com.liferay.portlet.journal.NoSuchArticleException { 4011 return getPersistence() 4012 .findByG_L_First(groupId, layoutUuid, orderByComparator); 4013 } 4014 4015 /** 4016 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 4017 * 4018 * @param groupId the group ID 4019 * @param layoutUuid the layout uuid 4020 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4021 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4022 * @throws SystemException if a system exception occurred 4023 */ 4024 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First( 4025 long groupId, java.lang.String layoutUuid, 4026 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4027 throws com.liferay.portal.kernel.exception.SystemException { 4028 return getPersistence() 4029 .fetchByG_L_First(groupId, layoutUuid, orderByComparator); 4030 } 4031 4032 /** 4033 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 4034 * 4035 * @param groupId the group ID 4036 * @param layoutUuid the layout uuid 4037 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4038 * @return the last matching journal article 4039 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4040 * @throws SystemException if a system exception occurred 4041 */ 4042 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last( 4043 long groupId, java.lang.String layoutUuid, 4044 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4045 throws com.liferay.portal.kernel.exception.SystemException, 4046 com.liferay.portlet.journal.NoSuchArticleException { 4047 return getPersistence() 4048 .findByG_L_Last(groupId, layoutUuid, orderByComparator); 4049 } 4050 4051 /** 4052 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 4053 * 4054 * @param groupId the group ID 4055 * @param layoutUuid the layout uuid 4056 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4057 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4058 * @throws SystemException if a system exception occurred 4059 */ 4060 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last( 4061 long groupId, java.lang.String layoutUuid, 4062 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4063 throws com.liferay.portal.kernel.exception.SystemException { 4064 return getPersistence() 4065 .fetchByG_L_Last(groupId, layoutUuid, orderByComparator); 4066 } 4067 4068 /** 4069 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and layoutUuid = ?. 4070 * 4071 * @param id the primary key of the current journal article 4072 * @param groupId the group ID 4073 * @param layoutUuid the layout uuid 4074 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4075 * @return the previous, current, and next journal article 4076 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4077 * @throws SystemException if a system exception occurred 4078 */ 4079 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext( 4080 long id, long groupId, java.lang.String layoutUuid, 4081 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4082 throws com.liferay.portal.kernel.exception.SystemException, 4083 com.liferay.portlet.journal.NoSuchArticleException { 4084 return getPersistence() 4085 .findByG_L_PrevAndNext(id, groupId, layoutUuid, 4086 orderByComparator); 4087 } 4088 4089 /** 4090 * Returns all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4091 * 4092 * @param groupId the group ID 4093 * @param layoutUuid the layout uuid 4094 * @return the matching journal articles that the user has permission to view 4095 * @throws SystemException if a system exception occurred 4096 */ 4097 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4098 long groupId, java.lang.String layoutUuid) 4099 throws com.liferay.portal.kernel.exception.SystemException { 4100 return getPersistence().filterFindByG_L(groupId, layoutUuid); 4101 } 4102 4103 /** 4104 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4105 * 4106 * <p> 4107 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4108 * </p> 4109 * 4110 * @param groupId the group ID 4111 * @param layoutUuid the layout uuid 4112 * @param start the lower bound of the range of journal articles 4113 * @param end the upper bound of the range of journal articles (not inclusive) 4114 * @return the range of matching journal articles that the user has permission to view 4115 * @throws SystemException if a system exception occurred 4116 */ 4117 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4118 long groupId, java.lang.String layoutUuid, int start, int end) 4119 throws com.liferay.portal.kernel.exception.SystemException { 4120 return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end); 4121 } 4122 4123 /** 4124 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and layoutUuid = ?. 4125 * 4126 * <p> 4127 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4128 * </p> 4129 * 4130 * @param groupId the group ID 4131 * @param layoutUuid the layout uuid 4132 * @param start the lower bound of the range of journal articles 4133 * @param end the upper bound of the range of journal articles (not inclusive) 4134 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4135 * @return the ordered range of matching journal articles that the user has permission to view 4136 * @throws SystemException if a system exception occurred 4137 */ 4138 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4139 long groupId, java.lang.String layoutUuid, int start, int end, 4140 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4141 throws com.liferay.portal.kernel.exception.SystemException { 4142 return getPersistence() 4143 .filterFindByG_L(groupId, layoutUuid, start, end, 4144 orderByComparator); 4145 } 4146 4147 /** 4148 * 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 = ?. 4149 * 4150 * @param id the primary key of the current journal article 4151 * @param groupId the group ID 4152 * @param layoutUuid the layout uuid 4153 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4154 * @return the previous, current, and next journal article 4155 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4156 * @throws SystemException if a system exception occurred 4157 */ 4158 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext( 4159 long id, long groupId, java.lang.String layoutUuid, 4160 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4161 throws com.liferay.portal.kernel.exception.SystemException, 4162 com.liferay.portlet.journal.NoSuchArticleException { 4163 return getPersistence() 4164 .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid, 4165 orderByComparator); 4166 } 4167 4168 /** 4169 * Removes all the journal articles where groupId = ? and layoutUuid = ? from the database. 4170 * 4171 * @param groupId the group ID 4172 * @param layoutUuid the layout uuid 4173 * @throws SystemException if a system exception occurred 4174 */ 4175 public static void removeByG_L(long groupId, java.lang.String layoutUuid) 4176 throws com.liferay.portal.kernel.exception.SystemException { 4177 getPersistence().removeByG_L(groupId, layoutUuid); 4178 } 4179 4180 /** 4181 * Returns the number of journal articles where groupId = ? and layoutUuid = ?. 4182 * 4183 * @param groupId the group ID 4184 * @param layoutUuid the layout uuid 4185 * @return the number of matching journal articles 4186 * @throws SystemException if a system exception occurred 4187 */ 4188 public static int countByG_L(long groupId, java.lang.String layoutUuid) 4189 throws com.liferay.portal.kernel.exception.SystemException { 4190 return getPersistence().countByG_L(groupId, layoutUuid); 4191 } 4192 4193 /** 4194 * Returns the number of journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4195 * 4196 * @param groupId the group ID 4197 * @param layoutUuid the layout uuid 4198 * @return the number of matching journal articles that the user has permission to view 4199 * @throws SystemException if a system exception occurred 4200 */ 4201 public static int filterCountByG_L(long groupId, java.lang.String layoutUuid) 4202 throws com.liferay.portal.kernel.exception.SystemException { 4203 return getPersistence().filterCountByG_L(groupId, layoutUuid); 4204 } 4205 4206 /** 4207 * Returns all the journal articles where groupId = ? and status = ?. 4208 * 4209 * @param groupId the group ID 4210 * @param status the status 4211 * @return the matching journal articles 4212 * @throws SystemException if a system exception occurred 4213 */ 4214 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4215 long groupId, int status) 4216 throws com.liferay.portal.kernel.exception.SystemException { 4217 return getPersistence().findByG_ST(groupId, status); 4218 } 4219 4220 /** 4221 * Returns a range of all the journal articles where groupId = ? and status = ?. 4222 * 4223 * <p> 4224 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4225 * </p> 4226 * 4227 * @param groupId the group ID 4228 * @param status the status 4229 * @param start the lower bound of the range of journal articles 4230 * @param end the upper bound of the range of journal articles (not inclusive) 4231 * @return the range of matching journal articles 4232 * @throws SystemException if a system exception occurred 4233 */ 4234 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4235 long groupId, int status, int start, int end) 4236 throws com.liferay.portal.kernel.exception.SystemException { 4237 return getPersistence().findByG_ST(groupId, status, start, end); 4238 } 4239 4240 /** 4241 * Returns an ordered range of all the journal articles where groupId = ? and status = ?. 4242 * 4243 * <p> 4244 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4245 * </p> 4246 * 4247 * @param groupId the group ID 4248 * @param status the status 4249 * @param start the lower bound of the range of journal articles 4250 * @param end the upper bound of the range of journal articles (not inclusive) 4251 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4252 * @return the ordered range of matching journal articles 4253 * @throws SystemException if a system exception occurred 4254 */ 4255 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4256 long groupId, int status, int start, int end, 4257 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4258 throws com.liferay.portal.kernel.exception.SystemException { 4259 return getPersistence() 4260 .findByG_ST(groupId, status, start, end, orderByComparator); 4261 } 4262 4263 /** 4264 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4265 * 4266 * @param groupId the group ID 4267 * @param status the status 4268 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4269 * @return the first matching journal article 4270 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4271 * @throws SystemException if a system exception occurred 4272 */ 4273 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First( 4274 long groupId, int status, 4275 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4276 throws com.liferay.portal.kernel.exception.SystemException, 4277 com.liferay.portlet.journal.NoSuchArticleException { 4278 return getPersistence() 4279 .findByG_ST_First(groupId, status, orderByComparator); 4280 } 4281 4282 /** 4283 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4284 * 4285 * @param groupId the group ID 4286 * @param status the status 4287 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4288 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4289 * @throws SystemException if a system exception occurred 4290 */ 4291 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First( 4292 long groupId, int status, 4293 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4294 throws com.liferay.portal.kernel.exception.SystemException { 4295 return getPersistence() 4296 .fetchByG_ST_First(groupId, status, orderByComparator); 4297 } 4298 4299 /** 4300 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4301 * 4302 * @param groupId the group ID 4303 * @param status the status 4304 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4305 * @return the last matching journal article 4306 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4307 * @throws SystemException if a system exception occurred 4308 */ 4309 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last( 4310 long groupId, int status, 4311 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4312 throws com.liferay.portal.kernel.exception.SystemException, 4313 com.liferay.portlet.journal.NoSuchArticleException { 4314 return getPersistence() 4315 .findByG_ST_Last(groupId, status, orderByComparator); 4316 } 4317 4318 /** 4319 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4320 * 4321 * @param groupId the group ID 4322 * @param status the status 4323 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4324 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4325 * @throws SystemException if a system exception occurred 4326 */ 4327 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last( 4328 long groupId, int status, 4329 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4330 throws com.liferay.portal.kernel.exception.SystemException { 4331 return getPersistence() 4332 .fetchByG_ST_Last(groupId, status, orderByComparator); 4333 } 4334 4335 /** 4336 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and status = ?. 4337 * 4338 * @param id the primary key of the current journal article 4339 * @param groupId the group ID 4340 * @param status the status 4341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4342 * @return the previous, current, and next journal article 4343 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4344 * @throws SystemException if a system exception occurred 4345 */ 4346 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext( 4347 long id, long groupId, int status, 4348 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4349 throws com.liferay.portal.kernel.exception.SystemException, 4350 com.liferay.portlet.journal.NoSuchArticleException { 4351 return getPersistence() 4352 .findByG_ST_PrevAndNext(id, groupId, status, 4353 orderByComparator); 4354 } 4355 4356 /** 4357 * Returns all the journal articles that the user has permission to view where groupId = ? and status = ?. 4358 * 4359 * @param groupId the group ID 4360 * @param status the status 4361 * @return the matching journal articles that the user has permission to view 4362 * @throws SystemException if a system exception occurred 4363 */ 4364 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4365 long groupId, int status) 4366 throws com.liferay.portal.kernel.exception.SystemException { 4367 return getPersistence().filterFindByG_ST(groupId, status); 4368 } 4369 4370 /** 4371 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and status = ?. 4372 * 4373 * <p> 4374 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4375 * </p> 4376 * 4377 * @param groupId the group ID 4378 * @param status the status 4379 * @param start the lower bound of the range of journal articles 4380 * @param end the upper bound of the range of journal articles (not inclusive) 4381 * @return the range of matching journal articles that the user has permission to view 4382 * @throws SystemException if a system exception occurred 4383 */ 4384 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4385 long groupId, int status, int start, int end) 4386 throws com.liferay.portal.kernel.exception.SystemException { 4387 return getPersistence().filterFindByG_ST(groupId, status, start, end); 4388 } 4389 4390 /** 4391 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and status = ?. 4392 * 4393 * <p> 4394 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4395 * </p> 4396 * 4397 * @param groupId the group ID 4398 * @param status the status 4399 * @param start the lower bound of the range of journal articles 4400 * @param end the upper bound of the range of journal articles (not inclusive) 4401 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4402 * @return the ordered range of matching journal articles that the user has permission to view 4403 * @throws SystemException if a system exception occurred 4404 */ 4405 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4406 long groupId, int status, int start, int end, 4407 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4408 throws com.liferay.portal.kernel.exception.SystemException { 4409 return getPersistence() 4410 .filterFindByG_ST(groupId, status, start, end, 4411 orderByComparator); 4412 } 4413 4414 /** 4415 * 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 = ?. 4416 * 4417 * @param id the primary key of the current journal article 4418 * @param groupId the group ID 4419 * @param status the status 4420 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4421 * @return the previous, current, and next journal article 4422 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4423 * @throws SystemException if a system exception occurred 4424 */ 4425 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext( 4426 long id, long groupId, int status, 4427 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4428 throws com.liferay.portal.kernel.exception.SystemException, 4429 com.liferay.portlet.journal.NoSuchArticleException { 4430 return getPersistence() 4431 .filterFindByG_ST_PrevAndNext(id, groupId, status, 4432 orderByComparator); 4433 } 4434 4435 /** 4436 * Removes all the journal articles where groupId = ? and status = ? from the database. 4437 * 4438 * @param groupId the group ID 4439 * @param status the status 4440 * @throws SystemException if a system exception occurred 4441 */ 4442 public static void removeByG_ST(long groupId, int status) 4443 throws com.liferay.portal.kernel.exception.SystemException { 4444 getPersistence().removeByG_ST(groupId, status); 4445 } 4446 4447 /** 4448 * Returns the number of journal articles where groupId = ? and status = ?. 4449 * 4450 * @param groupId the group ID 4451 * @param status the status 4452 * @return the number of matching journal articles 4453 * @throws SystemException if a system exception occurred 4454 */ 4455 public static int countByG_ST(long groupId, int status) 4456 throws com.liferay.portal.kernel.exception.SystemException { 4457 return getPersistence().countByG_ST(groupId, status); 4458 } 4459 4460 /** 4461 * Returns the number of journal articles that the user has permission to view where groupId = ? and status = ?. 4462 * 4463 * @param groupId the group ID 4464 * @param status the status 4465 * @return the number of matching journal articles that the user has permission to view 4466 * @throws SystemException if a system exception occurred 4467 */ 4468 public static int filterCountByG_ST(long groupId, int status) 4469 throws com.liferay.portal.kernel.exception.SystemException { 4470 return getPersistence().filterCountByG_ST(groupId, status); 4471 } 4472 4473 /** 4474 * Returns all the journal articles where companyId = ? and version = ?. 4475 * 4476 * @param companyId the company ID 4477 * @param version the version 4478 * @return the matching journal articles 4479 * @throws SystemException if a system exception occurred 4480 */ 4481 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4482 long companyId, double version) 4483 throws com.liferay.portal.kernel.exception.SystemException { 4484 return getPersistence().findByC_V(companyId, version); 4485 } 4486 4487 /** 4488 * Returns a range of all the journal articles where companyId = ? and version = ?. 4489 * 4490 * <p> 4491 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4492 * </p> 4493 * 4494 * @param companyId the company ID 4495 * @param version the version 4496 * @param start the lower bound of the range of journal articles 4497 * @param end the upper bound of the range of journal articles (not inclusive) 4498 * @return the range of matching journal articles 4499 * @throws SystemException if a system exception occurred 4500 */ 4501 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4502 long companyId, double version, int start, int end) 4503 throws com.liferay.portal.kernel.exception.SystemException { 4504 return getPersistence().findByC_V(companyId, version, start, end); 4505 } 4506 4507 /** 4508 * Returns an ordered range of all the journal articles where companyId = ? and version = ?. 4509 * 4510 * <p> 4511 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4512 * </p> 4513 * 4514 * @param companyId the company ID 4515 * @param version the version 4516 * @param start the lower bound of the range of journal articles 4517 * @param end the upper bound of the range of journal articles (not inclusive) 4518 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4519 * @return the ordered range of matching journal articles 4520 * @throws SystemException if a system exception occurred 4521 */ 4522 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4523 long companyId, double version, int start, int end, 4524 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4525 throws com.liferay.portal.kernel.exception.SystemException { 4526 return getPersistence() 4527 .findByC_V(companyId, version, start, end, orderByComparator); 4528 } 4529 4530 /** 4531 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 4532 * 4533 * @param companyId the company ID 4534 * @param version the version 4535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4536 * @return the first matching journal article 4537 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4538 * @throws SystemException if a system exception occurred 4539 */ 4540 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First( 4541 long companyId, double version, 4542 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4543 throws com.liferay.portal.kernel.exception.SystemException, 4544 com.liferay.portlet.journal.NoSuchArticleException { 4545 return getPersistence() 4546 .findByC_V_First(companyId, version, orderByComparator); 4547 } 4548 4549 /** 4550 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 4551 * 4552 * @param companyId the company ID 4553 * @param version the version 4554 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4555 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4556 * @throws SystemException if a system exception occurred 4557 */ 4558 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First( 4559 long companyId, double version, 4560 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4561 throws com.liferay.portal.kernel.exception.SystemException { 4562 return getPersistence() 4563 .fetchByC_V_First(companyId, version, orderByComparator); 4564 } 4565 4566 /** 4567 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 4568 * 4569 * @param companyId the company ID 4570 * @param version the version 4571 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4572 * @return the last matching journal article 4573 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4574 * @throws SystemException if a system exception occurred 4575 */ 4576 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last( 4577 long companyId, double version, 4578 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4579 throws com.liferay.portal.kernel.exception.SystemException, 4580 com.liferay.portlet.journal.NoSuchArticleException { 4581 return getPersistence() 4582 .findByC_V_Last(companyId, version, orderByComparator); 4583 } 4584 4585 /** 4586 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 4587 * 4588 * @param companyId the company ID 4589 * @param version the version 4590 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4591 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4592 * @throws SystemException if a system exception occurred 4593 */ 4594 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last( 4595 long companyId, double version, 4596 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4597 throws com.liferay.portal.kernel.exception.SystemException { 4598 return getPersistence() 4599 .fetchByC_V_Last(companyId, version, orderByComparator); 4600 } 4601 4602 /** 4603 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ?. 4604 * 4605 * @param id the primary key of the current journal article 4606 * @param companyId the company ID 4607 * @param version the version 4608 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4609 * @return the previous, current, and next journal article 4610 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4611 * @throws SystemException if a system exception occurred 4612 */ 4613 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext( 4614 long id, long companyId, double version, 4615 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4616 throws com.liferay.portal.kernel.exception.SystemException, 4617 com.liferay.portlet.journal.NoSuchArticleException { 4618 return getPersistence() 4619 .findByC_V_PrevAndNext(id, companyId, version, 4620 orderByComparator); 4621 } 4622 4623 /** 4624 * Removes all the journal articles where companyId = ? and version = ? from the database. 4625 * 4626 * @param companyId the company ID 4627 * @param version the version 4628 * @throws SystemException if a system exception occurred 4629 */ 4630 public static void removeByC_V(long companyId, double version) 4631 throws com.liferay.portal.kernel.exception.SystemException { 4632 getPersistence().removeByC_V(companyId, version); 4633 } 4634 4635 /** 4636 * Returns the number of journal articles where companyId = ? and version = ?. 4637 * 4638 * @param companyId the company ID 4639 * @param version the version 4640 * @return the number of matching journal articles 4641 * @throws SystemException if a system exception occurred 4642 */ 4643 public static int countByC_V(long companyId, double version) 4644 throws com.liferay.portal.kernel.exception.SystemException { 4645 return getPersistence().countByC_V(companyId, version); 4646 } 4647 4648 /** 4649 * Returns all the journal articles where companyId = ? and status = ?. 4650 * 4651 * @param companyId the company ID 4652 * @param status the status 4653 * @return the matching journal articles 4654 * @throws SystemException if a system exception occurred 4655 */ 4656 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4657 long companyId, int status) 4658 throws com.liferay.portal.kernel.exception.SystemException { 4659 return getPersistence().findByC_ST(companyId, status); 4660 } 4661 4662 /** 4663 * Returns a range of all the journal articles where companyId = ? and status = ?. 4664 * 4665 * <p> 4666 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4667 * </p> 4668 * 4669 * @param companyId the company ID 4670 * @param status the status 4671 * @param start the lower bound of the range of journal articles 4672 * @param end the upper bound of the range of journal articles (not inclusive) 4673 * @return the range of matching journal articles 4674 * @throws SystemException if a system exception occurred 4675 */ 4676 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4677 long companyId, int status, int start, int end) 4678 throws com.liferay.portal.kernel.exception.SystemException { 4679 return getPersistence().findByC_ST(companyId, status, start, end); 4680 } 4681 4682 /** 4683 * Returns an ordered range of all the journal articles where companyId = ? and status = ?. 4684 * 4685 * <p> 4686 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4687 * </p> 4688 * 4689 * @param companyId the company ID 4690 * @param status the status 4691 * @param start the lower bound of the range of journal articles 4692 * @param end the upper bound of the range of journal articles (not inclusive) 4693 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4694 * @return the ordered range of matching journal articles 4695 * @throws SystemException if a system exception occurred 4696 */ 4697 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4698 long companyId, int status, int start, int end, 4699 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4700 throws com.liferay.portal.kernel.exception.SystemException { 4701 return getPersistence() 4702 .findByC_ST(companyId, status, start, end, orderByComparator); 4703 } 4704 4705 /** 4706 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 4707 * 4708 * @param companyId the company ID 4709 * @param status the status 4710 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4711 * @return the first matching journal article 4712 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4713 * @throws SystemException if a system exception occurred 4714 */ 4715 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First( 4716 long companyId, int status, 4717 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4718 throws com.liferay.portal.kernel.exception.SystemException, 4719 com.liferay.portlet.journal.NoSuchArticleException { 4720 return getPersistence() 4721 .findByC_ST_First(companyId, status, orderByComparator); 4722 } 4723 4724 /** 4725 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 4726 * 4727 * @param companyId the company ID 4728 * @param status the status 4729 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4730 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4731 * @throws SystemException if a system exception occurred 4732 */ 4733 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First( 4734 long companyId, int status, 4735 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4736 throws com.liferay.portal.kernel.exception.SystemException { 4737 return getPersistence() 4738 .fetchByC_ST_First(companyId, status, orderByComparator); 4739 } 4740 4741 /** 4742 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 4743 * 4744 * @param companyId the company ID 4745 * @param status the status 4746 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4747 * @return the last matching journal article 4748 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4749 * @throws SystemException if a system exception occurred 4750 */ 4751 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last( 4752 long companyId, int status, 4753 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4754 throws com.liferay.portal.kernel.exception.SystemException, 4755 com.liferay.portlet.journal.NoSuchArticleException { 4756 return getPersistence() 4757 .findByC_ST_Last(companyId, status, orderByComparator); 4758 } 4759 4760 /** 4761 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 4762 * 4763 * @param companyId the company ID 4764 * @param status the status 4765 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4766 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4767 * @throws SystemException if a system exception occurred 4768 */ 4769 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last( 4770 long companyId, int status, 4771 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4772 throws com.liferay.portal.kernel.exception.SystemException { 4773 return getPersistence() 4774 .fetchByC_ST_Last(companyId, status, orderByComparator); 4775 } 4776 4777 /** 4778 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status = ?. 4779 * 4780 * @param id the primary key of the current journal article 4781 * @param companyId the company ID 4782 * @param status the status 4783 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4784 * @return the previous, current, and next journal article 4785 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4786 * @throws SystemException if a system exception occurred 4787 */ 4788 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext( 4789 long id, long companyId, int status, 4790 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4791 throws com.liferay.portal.kernel.exception.SystemException, 4792 com.liferay.portlet.journal.NoSuchArticleException { 4793 return getPersistence() 4794 .findByC_ST_PrevAndNext(id, companyId, status, 4795 orderByComparator); 4796 } 4797 4798 /** 4799 * Removes all the journal articles where companyId = ? and status = ? from the database. 4800 * 4801 * @param companyId the company ID 4802 * @param status the status 4803 * @throws SystemException if a system exception occurred 4804 */ 4805 public static void removeByC_ST(long companyId, int status) 4806 throws com.liferay.portal.kernel.exception.SystemException { 4807 getPersistence().removeByC_ST(companyId, status); 4808 } 4809 4810 /** 4811 * Returns the number of journal articles where companyId = ? and status = ?. 4812 * 4813 * @param companyId the company ID 4814 * @param status the status 4815 * @return the number of matching journal articles 4816 * @throws SystemException if a system exception occurred 4817 */ 4818 public static int countByC_ST(long companyId, int status) 4819 throws com.liferay.portal.kernel.exception.SystemException { 4820 return getPersistence().countByC_ST(companyId, status); 4821 } 4822 4823 /** 4824 * Returns all the journal articles where companyId = ? and status ≠ ?. 4825 * 4826 * @param companyId the company ID 4827 * @param status the status 4828 * @return the matching journal articles 4829 * @throws SystemException if a system exception occurred 4830 */ 4831 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4832 long companyId, int status) 4833 throws com.liferay.portal.kernel.exception.SystemException { 4834 return getPersistence().findByC_NotST(companyId, status); 4835 } 4836 4837 /** 4838 * Returns a range of all the journal articles where companyId = ? and status ≠ ?. 4839 * 4840 * <p> 4841 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4842 * </p> 4843 * 4844 * @param companyId the company ID 4845 * @param status the status 4846 * @param start the lower bound of the range of journal articles 4847 * @param end the upper bound of the range of journal articles (not inclusive) 4848 * @return the range of matching journal articles 4849 * @throws SystemException if a system exception occurred 4850 */ 4851 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4852 long companyId, int status, int start, int end) 4853 throws com.liferay.portal.kernel.exception.SystemException { 4854 return getPersistence().findByC_NotST(companyId, status, start, end); 4855 } 4856 4857 /** 4858 * Returns an ordered range of all the journal articles where companyId = ? and status ≠ ?. 4859 * 4860 * <p> 4861 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 4862 * </p> 4863 * 4864 * @param companyId the company ID 4865 * @param status the status 4866 * @param start the lower bound of the range of journal articles 4867 * @param end the upper bound of the range of journal articles (not inclusive) 4868 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4869 * @return the ordered range of matching journal articles 4870 * @throws SystemException if a system exception occurred 4871 */ 4872 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4873 long companyId, int status, int start, int end, 4874 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4875 throws com.liferay.portal.kernel.exception.SystemException { 4876 return getPersistence() 4877 .findByC_NotST(companyId, status, start, end, 4878 orderByComparator); 4879 } 4880 4881 /** 4882 * Returns the first journal article in the ordered set where companyId = ? and status ≠ ?. 4883 * 4884 * @param companyId the company ID 4885 * @param status the status 4886 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4887 * @return the first matching journal article 4888 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4889 * @throws SystemException if a system exception occurred 4890 */ 4891 public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_First( 4892 long companyId, int status, 4893 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4894 throws com.liferay.portal.kernel.exception.SystemException, 4895 com.liferay.portlet.journal.NoSuchArticleException { 4896 return getPersistence() 4897 .findByC_NotST_First(companyId, status, orderByComparator); 4898 } 4899 4900 /** 4901 * Returns the first journal article in the ordered set where companyId = ? and status ≠ ?. 4902 * 4903 * @param companyId the company ID 4904 * @param status the status 4905 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4906 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4907 * @throws SystemException if a system exception occurred 4908 */ 4909 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_First( 4910 long companyId, int status, 4911 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4912 throws com.liferay.portal.kernel.exception.SystemException { 4913 return getPersistence() 4914 .fetchByC_NotST_First(companyId, status, orderByComparator); 4915 } 4916 4917 /** 4918 * Returns the last journal article in the ordered set where companyId = ? and status ≠ ?. 4919 * 4920 * @param companyId the company ID 4921 * @param status the status 4922 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4923 * @return the last matching journal article 4924 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4925 * @throws SystemException if a system exception occurred 4926 */ 4927 public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_Last( 4928 long companyId, int status, 4929 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4930 throws com.liferay.portal.kernel.exception.SystemException, 4931 com.liferay.portlet.journal.NoSuchArticleException { 4932 return getPersistence() 4933 .findByC_NotST_Last(companyId, status, orderByComparator); 4934 } 4935 4936 /** 4937 * Returns the last journal article in the ordered set where companyId = ? and status ≠ ?. 4938 * 4939 * @param companyId the company ID 4940 * @param status the status 4941 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4942 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4943 * @throws SystemException if a system exception occurred 4944 */ 4945 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_Last( 4946 long companyId, int status, 4947 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4948 throws com.liferay.portal.kernel.exception.SystemException { 4949 return getPersistence() 4950 .fetchByC_NotST_Last(companyId, status, orderByComparator); 4951 } 4952 4953 /** 4954 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status ≠ ?. 4955 * 4956 * @param id the primary key of the current journal article 4957 * @param companyId the company ID 4958 * @param status the status 4959 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4960 * @return the previous, current, and next journal article 4961 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4962 * @throws SystemException if a system exception occurred 4963 */ 4964 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_NotST_PrevAndNext( 4965 long id, long companyId, int status, 4966 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4967 throws com.liferay.portal.kernel.exception.SystemException, 4968 com.liferay.portlet.journal.NoSuchArticleException { 4969 return getPersistence() 4970 .findByC_NotST_PrevAndNext(id, companyId, status, 4971 orderByComparator); 4972 } 4973 4974 /** 4975 * Removes all the journal articles where companyId = ? and status ≠ ? from the database. 4976 * 4977 * @param companyId the company ID 4978 * @param status the status 4979 * @throws SystemException if a system exception occurred 4980 */ 4981 public static void removeByC_NotST(long companyId, int status) 4982 throws com.liferay.portal.kernel.exception.SystemException { 4983 getPersistence().removeByC_NotST(companyId, status); 4984 } 4985 4986 /** 4987 * Returns the number of journal articles where companyId = ? and status ≠ ?. 4988 * 4989 * @param companyId the company ID 4990 * @param status the status 4991 * @return the number of matching journal articles 4992 * @throws SystemException if a system exception occurred 4993 */ 4994 public static int countByC_NotST(long companyId, int status) 4995 throws com.liferay.portal.kernel.exception.SystemException { 4996 return getPersistence().countByC_NotST(companyId, status); 4997 } 4998 4999 /** 5000 * Returns all the journal articles where displayDate < ? and status = ?. 5001 * 5002 * @param displayDate the display date 5003 * @param status the status 5004 * @return the matching journal articles 5005 * @throws SystemException if a system exception occurred 5006 */ 5007 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5008 java.util.Date displayDate, int status) 5009 throws com.liferay.portal.kernel.exception.SystemException { 5010 return getPersistence().findByLtD_S(displayDate, status); 5011 } 5012 5013 /** 5014 * Returns a range of all the journal articles where displayDate < ? and status = ?. 5015 * 5016 * <p> 5017 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5018 * </p> 5019 * 5020 * @param displayDate the display date 5021 * @param status the status 5022 * @param start the lower bound of the range of journal articles 5023 * @param end the upper bound of the range of journal articles (not inclusive) 5024 * @return the range of matching journal articles 5025 * @throws SystemException if a system exception occurred 5026 */ 5027 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5028 java.util.Date displayDate, int status, int start, int end) 5029 throws com.liferay.portal.kernel.exception.SystemException { 5030 return getPersistence().findByLtD_S(displayDate, status, start, end); 5031 } 5032 5033 /** 5034 * Returns an ordered range of all the journal articles where displayDate < ? and status = ?. 5035 * 5036 * <p> 5037 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5038 * </p> 5039 * 5040 * @param displayDate the display date 5041 * @param status the status 5042 * @param start the lower bound of the range of journal articles 5043 * @param end the upper bound of the range of journal articles (not inclusive) 5044 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5045 * @return the ordered range of matching journal articles 5046 * @throws SystemException if a system exception occurred 5047 */ 5048 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5049 java.util.Date displayDate, int status, int start, int end, 5050 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5051 throws com.liferay.portal.kernel.exception.SystemException { 5052 return getPersistence() 5053 .findByLtD_S(displayDate, status, start, end, 5054 orderByComparator); 5055 } 5056 5057 /** 5058 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 5059 * 5060 * @param displayDate the display date 5061 * @param status the status 5062 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5063 * @return the first matching journal article 5064 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5065 * @throws SystemException if a system exception occurred 5066 */ 5067 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First( 5068 java.util.Date displayDate, int status, 5069 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5070 throws com.liferay.portal.kernel.exception.SystemException, 5071 com.liferay.portlet.journal.NoSuchArticleException { 5072 return getPersistence() 5073 .findByLtD_S_First(displayDate, status, orderByComparator); 5074 } 5075 5076 /** 5077 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 5078 * 5079 * @param displayDate the display date 5080 * @param status the status 5081 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5082 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5083 * @throws SystemException if a system exception occurred 5084 */ 5085 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First( 5086 java.util.Date displayDate, int status, 5087 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5088 throws com.liferay.portal.kernel.exception.SystemException { 5089 return getPersistence() 5090 .fetchByLtD_S_First(displayDate, status, orderByComparator); 5091 } 5092 5093 /** 5094 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 5095 * 5096 * @param displayDate the display date 5097 * @param status the status 5098 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5099 * @return the last matching journal article 5100 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5101 * @throws SystemException if a system exception occurred 5102 */ 5103 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_Last( 5104 java.util.Date displayDate, int status, 5105 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5106 throws com.liferay.portal.kernel.exception.SystemException, 5107 com.liferay.portlet.journal.NoSuchArticleException { 5108 return getPersistence() 5109 .findByLtD_S_Last(displayDate, status, orderByComparator); 5110 } 5111 5112 /** 5113 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 5114 * 5115 * @param displayDate the display date 5116 * @param status the status 5117 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5118 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5119 * @throws SystemException if a system exception occurred 5120 */ 5121 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last( 5122 java.util.Date displayDate, int status, 5123 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5124 throws com.liferay.portal.kernel.exception.SystemException { 5125 return getPersistence() 5126 .fetchByLtD_S_Last(displayDate, status, orderByComparator); 5127 } 5128 5129 /** 5130 * Returns the journal articles before and after the current journal article in the ordered set where displayDate < ? and status = ?. 5131 * 5132 * @param id the primary key of the current journal article 5133 * @param displayDate the display date 5134 * @param status the status 5135 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5136 * @return the previous, current, and next journal article 5137 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5138 * @throws SystemException if a system exception occurred 5139 */ 5140 public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext( 5141 long id, java.util.Date displayDate, int status, 5142 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5143 throws com.liferay.portal.kernel.exception.SystemException, 5144 com.liferay.portlet.journal.NoSuchArticleException { 5145 return getPersistence() 5146 .findByLtD_S_PrevAndNext(id, displayDate, status, 5147 orderByComparator); 5148 } 5149 5150 /** 5151 * Removes all the journal articles where displayDate < ? and status = ? from the database. 5152 * 5153 * @param displayDate the display date 5154 * @param status the status 5155 * @throws SystemException if a system exception occurred 5156 */ 5157 public static void removeByLtD_S(java.util.Date displayDate, int status) 5158 throws com.liferay.portal.kernel.exception.SystemException { 5159 getPersistence().removeByLtD_S(displayDate, status); 5160 } 5161 5162 /** 5163 * Returns the number of journal articles where displayDate < ? and status = ?. 5164 * 5165 * @param displayDate the display date 5166 * @param status the status 5167 * @return the number of matching journal articles 5168 * @throws SystemException if a system exception occurred 5169 */ 5170 public static int countByLtD_S(java.util.Date displayDate, int status) 5171 throws com.liferay.portal.kernel.exception.SystemException { 5172 return getPersistence().countByLtD_S(displayDate, status); 5173 } 5174 5175 /** 5176 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5177 * 5178 * @param resourcePrimKey the resource prim key 5179 * @param indexable the indexable 5180 * @param status the status 5181 * @return the matching journal articles 5182 * @throws SystemException if a system exception occurred 5183 */ 5184 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5185 long resourcePrimKey, boolean indexable, int status) 5186 throws com.liferay.portal.kernel.exception.SystemException { 5187 return getPersistence().findByR_I_S(resourcePrimKey, indexable, status); 5188 } 5189 5190 /** 5191 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5192 * 5193 * <p> 5194 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5195 * </p> 5196 * 5197 * @param resourcePrimKey the resource prim key 5198 * @param indexable the indexable 5199 * @param status the status 5200 * @param start the lower bound of the range of journal articles 5201 * @param end the upper bound of the range of journal articles (not inclusive) 5202 * @return the range of matching journal articles 5203 * @throws SystemException if a system exception occurred 5204 */ 5205 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5206 long resourcePrimKey, boolean indexable, int status, int start, int end) 5207 throws com.liferay.portal.kernel.exception.SystemException { 5208 return getPersistence() 5209 .findByR_I_S(resourcePrimKey, indexable, status, start, end); 5210 } 5211 5212 /** 5213 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5214 * 5215 * <p> 5216 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5217 * </p> 5218 * 5219 * @param resourcePrimKey the resource prim key 5220 * @param indexable the indexable 5221 * @param status the status 5222 * @param start the lower bound of the range of journal articles 5223 * @param end the upper bound of the range of journal articles (not inclusive) 5224 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5225 * @return the ordered range of matching journal articles 5226 * @throws SystemException if a system exception occurred 5227 */ 5228 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5229 long resourcePrimKey, boolean indexable, int status, int start, 5230 int end, 5231 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5232 throws com.liferay.portal.kernel.exception.SystemException { 5233 return getPersistence() 5234 .findByR_I_S(resourcePrimKey, indexable, status, start, end, 5235 orderByComparator); 5236 } 5237 5238 /** 5239 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5240 * 5241 * @param resourcePrimKey the resource prim key 5242 * @param indexable the indexable 5243 * @param status the status 5244 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5245 * @return the first matching journal article 5246 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5247 * @throws SystemException if a system exception occurred 5248 */ 5249 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First( 5250 long resourcePrimKey, boolean indexable, int status, 5251 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5252 throws com.liferay.portal.kernel.exception.SystemException, 5253 com.liferay.portlet.journal.NoSuchArticleException { 5254 return getPersistence() 5255 .findByR_I_S_First(resourcePrimKey, indexable, status, 5256 orderByComparator); 5257 } 5258 5259 /** 5260 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5261 * 5262 * @param resourcePrimKey the resource prim key 5263 * @param indexable the indexable 5264 * @param status the status 5265 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5266 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5267 * @throws SystemException if a system exception occurred 5268 */ 5269 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First( 5270 long resourcePrimKey, boolean indexable, int status, 5271 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5272 throws com.liferay.portal.kernel.exception.SystemException { 5273 return getPersistence() 5274 .fetchByR_I_S_First(resourcePrimKey, indexable, status, 5275 orderByComparator); 5276 } 5277 5278 /** 5279 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5280 * 5281 * @param resourcePrimKey the resource prim key 5282 * @param indexable the indexable 5283 * @param status the status 5284 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5285 * @return the last matching journal article 5286 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5287 * @throws SystemException if a system exception occurred 5288 */ 5289 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last( 5290 long resourcePrimKey, boolean indexable, int status, 5291 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5292 throws com.liferay.portal.kernel.exception.SystemException, 5293 com.liferay.portlet.journal.NoSuchArticleException { 5294 return getPersistence() 5295 .findByR_I_S_Last(resourcePrimKey, indexable, status, 5296 orderByComparator); 5297 } 5298 5299 /** 5300 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5301 * 5302 * @param resourcePrimKey the resource prim key 5303 * @param indexable the indexable 5304 * @param status the status 5305 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5306 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5307 * @throws SystemException if a system exception occurred 5308 */ 5309 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last( 5310 long resourcePrimKey, boolean indexable, int status, 5311 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5312 throws com.liferay.portal.kernel.exception.SystemException { 5313 return getPersistence() 5314 .fetchByR_I_S_Last(resourcePrimKey, indexable, status, 5315 orderByComparator); 5316 } 5317 5318 /** 5319 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5320 * 5321 * @param id the primary key of the current journal article 5322 * @param resourcePrimKey the resource prim key 5323 * @param indexable the indexable 5324 * @param status the status 5325 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5326 * @return the previous, current, and next journal article 5327 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5328 * @throws SystemException if a system exception occurred 5329 */ 5330 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext( 5331 long id, long resourcePrimKey, boolean indexable, int status, 5332 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5333 throws com.liferay.portal.kernel.exception.SystemException, 5334 com.liferay.portlet.journal.NoSuchArticleException { 5335 return getPersistence() 5336 .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable, 5337 status, orderByComparator); 5338 } 5339 5340 /** 5341 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5342 * 5343 * <p> 5344 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5345 * </p> 5346 * 5347 * @param resourcePrimKey the resource prim key 5348 * @param indexable the indexable 5349 * @param statuses the statuses 5350 * @return the matching journal articles 5351 * @throws SystemException if a system exception occurred 5352 */ 5353 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5354 long resourcePrimKey, boolean indexable, int[] statuses) 5355 throws com.liferay.portal.kernel.exception.SystemException { 5356 return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses); 5357 } 5358 5359 /** 5360 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5361 * 5362 * <p> 5363 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5364 * </p> 5365 * 5366 * @param resourcePrimKey the resource prim key 5367 * @param indexable the indexable 5368 * @param statuses the statuses 5369 * @param start the lower bound of the range of journal articles 5370 * @param end the upper bound of the range of journal articles (not inclusive) 5371 * @return the range of matching journal articles 5372 * @throws SystemException if a system exception occurred 5373 */ 5374 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5375 long resourcePrimKey, boolean indexable, int[] statuses, int start, 5376 int end) throws com.liferay.portal.kernel.exception.SystemException { 5377 return getPersistence() 5378 .findByR_I_S(resourcePrimKey, indexable, statuses, start, end); 5379 } 5380 5381 /** 5382 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5383 * 5384 * <p> 5385 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5386 * </p> 5387 * 5388 * @param resourcePrimKey the resource prim key 5389 * @param indexable the indexable 5390 * @param statuses the statuses 5391 * @param start the lower bound of the range of journal articles 5392 * @param end the upper bound of the range of journal articles (not inclusive) 5393 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5394 * @return the ordered range of matching journal articles 5395 * @throws SystemException if a system exception occurred 5396 */ 5397 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5398 long resourcePrimKey, boolean indexable, int[] statuses, int start, 5399 int end, 5400 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5401 throws com.liferay.portal.kernel.exception.SystemException { 5402 return getPersistence() 5403 .findByR_I_S(resourcePrimKey, indexable, statuses, start, 5404 end, orderByComparator); 5405 } 5406 5407 /** 5408 * Removes all the journal articles where resourcePrimKey = ? and indexable = ? and status = ? from the database. 5409 * 5410 * @param resourcePrimKey the resource prim key 5411 * @param indexable the indexable 5412 * @param status the status 5413 * @throws SystemException if a system exception occurred 5414 */ 5415 public static void removeByR_I_S(long resourcePrimKey, boolean indexable, 5416 int status) throws com.liferay.portal.kernel.exception.SystemException { 5417 getPersistence().removeByR_I_S(resourcePrimKey, indexable, status); 5418 } 5419 5420 /** 5421 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5422 * 5423 * @param resourcePrimKey the resource prim key 5424 * @param indexable the indexable 5425 * @param status the status 5426 * @return the number of matching journal articles 5427 * @throws SystemException if a system exception occurred 5428 */ 5429 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 5430 int status) throws com.liferay.portal.kernel.exception.SystemException { 5431 return getPersistence().countByR_I_S(resourcePrimKey, indexable, status); 5432 } 5433 5434 /** 5435 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5436 * 5437 * @param resourcePrimKey the resource prim key 5438 * @param indexable the indexable 5439 * @param statuses the statuses 5440 * @return the number of matching journal articles 5441 * @throws SystemException if a system exception occurred 5442 */ 5443 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 5444 int[] statuses) 5445 throws com.liferay.portal.kernel.exception.SystemException { 5446 return getPersistence() 5447 .countByR_I_S(resourcePrimKey, indexable, statuses); 5448 } 5449 5450 /** 5451 * Returns all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5452 * 5453 * @param groupId the group ID 5454 * @param userId the user ID 5455 * @param classNameId the class name ID 5456 * @return the matching journal articles 5457 * @throws SystemException if a system exception occurred 5458 */ 5459 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5460 long groupId, long userId, long classNameId) 5461 throws com.liferay.portal.kernel.exception.SystemException { 5462 return getPersistence().findByG_U_C(groupId, userId, classNameId); 5463 } 5464 5465 /** 5466 * Returns a range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5467 * 5468 * <p> 5469 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5470 * </p> 5471 * 5472 * @param groupId the group ID 5473 * @param userId the user ID 5474 * @param classNameId the class name ID 5475 * @param start the lower bound of the range of journal articles 5476 * @param end the upper bound of the range of journal articles (not inclusive) 5477 * @return the range of matching journal articles 5478 * @throws SystemException if a system exception occurred 5479 */ 5480 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5481 long groupId, long userId, long classNameId, int start, int end) 5482 throws com.liferay.portal.kernel.exception.SystemException { 5483 return getPersistence() 5484 .findByG_U_C(groupId, userId, classNameId, start, end); 5485 } 5486 5487 /** 5488 * Returns an ordered range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5489 * 5490 * <p> 5491 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5492 * </p> 5493 * 5494 * @param groupId the group ID 5495 * @param userId the user ID 5496 * @param classNameId the class name ID 5497 * @param start the lower bound of the range of journal articles 5498 * @param end the upper bound of the range of journal articles (not inclusive) 5499 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5500 * @return the ordered range of matching journal articles 5501 * @throws SystemException if a system exception occurred 5502 */ 5503 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5504 long groupId, long userId, long classNameId, int start, int end, 5505 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5506 throws com.liferay.portal.kernel.exception.SystemException { 5507 return getPersistence() 5508 .findByG_U_C(groupId, userId, classNameId, start, end, 5509 orderByComparator); 5510 } 5511 5512 /** 5513 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5514 * 5515 * @param groupId the group ID 5516 * @param userId the user ID 5517 * @param classNameId the class name ID 5518 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5519 * @return the first matching journal article 5520 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5521 * @throws SystemException if a system exception occurred 5522 */ 5523 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First( 5524 long groupId, long userId, long classNameId, 5525 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5526 throws com.liferay.portal.kernel.exception.SystemException, 5527 com.liferay.portlet.journal.NoSuchArticleException { 5528 return getPersistence() 5529 .findByG_U_C_First(groupId, userId, classNameId, 5530 orderByComparator); 5531 } 5532 5533 /** 5534 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5535 * 5536 * @param groupId the group ID 5537 * @param userId the user ID 5538 * @param classNameId the class name ID 5539 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5540 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5541 * @throws SystemException if a system exception occurred 5542 */ 5543 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First( 5544 long groupId, long userId, long classNameId, 5545 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5546 throws com.liferay.portal.kernel.exception.SystemException { 5547 return getPersistence() 5548 .fetchByG_U_C_First(groupId, userId, classNameId, 5549 orderByComparator); 5550 } 5551 5552 /** 5553 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5554 * 5555 * @param groupId the group ID 5556 * @param userId the user ID 5557 * @param classNameId the class name ID 5558 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5559 * @return the last matching journal article 5560 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5561 * @throws SystemException if a system exception occurred 5562 */ 5563 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last( 5564 long groupId, long userId, long classNameId, 5565 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5566 throws com.liferay.portal.kernel.exception.SystemException, 5567 com.liferay.portlet.journal.NoSuchArticleException { 5568 return getPersistence() 5569 .findByG_U_C_Last(groupId, userId, classNameId, 5570 orderByComparator); 5571 } 5572 5573 /** 5574 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5575 * 5576 * @param groupId the group ID 5577 * @param userId the user ID 5578 * @param classNameId the class name ID 5579 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5580 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5581 * @throws SystemException if a system exception occurred 5582 */ 5583 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last( 5584 long groupId, long userId, long classNameId, 5585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5586 throws com.liferay.portal.kernel.exception.SystemException { 5587 return getPersistence() 5588 .fetchByG_U_C_Last(groupId, userId, classNameId, 5589 orderByComparator); 5590 } 5591 5592 /** 5593 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5594 * 5595 * @param id the primary key of the current journal article 5596 * @param groupId the group ID 5597 * @param userId the user ID 5598 * @param classNameId the class name ID 5599 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5600 * @return the previous, current, and next journal article 5601 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5602 * @throws SystemException if a system exception occurred 5603 */ 5604 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext( 5605 long id, long groupId, long userId, long classNameId, 5606 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5607 throws com.liferay.portal.kernel.exception.SystemException, 5608 com.liferay.portlet.journal.NoSuchArticleException { 5609 return getPersistence() 5610 .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId, 5611 orderByComparator); 5612 } 5613 5614 /** 5615 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5616 * 5617 * @param groupId the group ID 5618 * @param userId the user ID 5619 * @param classNameId the class name ID 5620 * @return the matching journal articles that the user has permission to view 5621 * @throws SystemException if a system exception occurred 5622 */ 5623 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5624 long groupId, long userId, long classNameId) 5625 throws com.liferay.portal.kernel.exception.SystemException { 5626 return getPersistence().filterFindByG_U_C(groupId, userId, classNameId); 5627 } 5628 5629 /** 5630 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5631 * 5632 * <p> 5633 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5634 * </p> 5635 * 5636 * @param groupId the group ID 5637 * @param userId the user ID 5638 * @param classNameId the class name ID 5639 * @param start the lower bound of the range of journal articles 5640 * @param end the upper bound of the range of journal articles (not inclusive) 5641 * @return the range of matching journal articles that the user has permission to view 5642 * @throws SystemException if a system exception occurred 5643 */ 5644 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5645 long groupId, long userId, long classNameId, int start, int end) 5646 throws com.liferay.portal.kernel.exception.SystemException { 5647 return getPersistence() 5648 .filterFindByG_U_C(groupId, userId, classNameId, start, end); 5649 } 5650 5651 /** 5652 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ? and classNameId = ?. 5653 * 5654 * <p> 5655 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5656 * </p> 5657 * 5658 * @param groupId the group ID 5659 * @param userId the user ID 5660 * @param classNameId the class name ID 5661 * @param start the lower bound of the range of journal articles 5662 * @param end the upper bound of the range of journal articles (not inclusive) 5663 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5664 * @return the ordered range of matching journal articles that the user has permission to view 5665 * @throws SystemException if a system exception occurred 5666 */ 5667 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5668 long groupId, long userId, long classNameId, int start, int end, 5669 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5670 throws com.liferay.portal.kernel.exception.SystemException { 5671 return getPersistence() 5672 .filterFindByG_U_C(groupId, userId, classNameId, start, end, 5673 orderByComparator); 5674 } 5675 5676 /** 5677 * 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 = ?. 5678 * 5679 * @param id the primary key of the current journal article 5680 * @param groupId the group ID 5681 * @param userId the user ID 5682 * @param classNameId the class name ID 5683 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5684 * @return the previous, current, and next journal article 5685 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5686 * @throws SystemException if a system exception occurred 5687 */ 5688 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext( 5689 long id, long groupId, long userId, long classNameId, 5690 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5691 throws com.liferay.portal.kernel.exception.SystemException, 5692 com.liferay.portlet.journal.NoSuchArticleException { 5693 return getPersistence() 5694 .filterFindByG_U_C_PrevAndNext(id, groupId, userId, 5695 classNameId, orderByComparator); 5696 } 5697 5698 /** 5699 * Removes all the journal articles where groupId = ? and userId = ? and classNameId = ? from the database. 5700 * 5701 * @param groupId the group ID 5702 * @param userId the user ID 5703 * @param classNameId the class name ID 5704 * @throws SystemException if a system exception occurred 5705 */ 5706 public static void removeByG_U_C(long groupId, long userId, long classNameId) 5707 throws com.liferay.portal.kernel.exception.SystemException { 5708 getPersistence().removeByG_U_C(groupId, userId, classNameId); 5709 } 5710 5711 /** 5712 * Returns the number of journal articles where groupId = ? and userId = ? and classNameId = ?. 5713 * 5714 * @param groupId the group ID 5715 * @param userId the user ID 5716 * @param classNameId the class name ID 5717 * @return the number of matching journal articles 5718 * @throws SystemException if a system exception occurred 5719 */ 5720 public static int countByG_U_C(long groupId, long userId, long classNameId) 5721 throws com.liferay.portal.kernel.exception.SystemException { 5722 return getPersistence().countByG_U_C(groupId, userId, classNameId); 5723 } 5724 5725 /** 5726 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5727 * 5728 * @param groupId the group ID 5729 * @param userId the user ID 5730 * @param classNameId the class name ID 5731 * @return the number of matching journal articles that the user has permission to view 5732 * @throws SystemException if a system exception occurred 5733 */ 5734 public static int filterCountByG_U_C(long groupId, long userId, 5735 long classNameId) 5736 throws com.liferay.portal.kernel.exception.SystemException { 5737 return getPersistence().filterCountByG_U_C(groupId, userId, classNameId); 5738 } 5739 5740 /** 5741 * Returns all the journal articles where groupId = ? and folderId = ? and status = ?. 5742 * 5743 * @param groupId the group ID 5744 * @param folderId the folder ID 5745 * @param status the status 5746 * @return the matching journal articles 5747 * @throws SystemException if a system exception occurred 5748 */ 5749 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5750 long groupId, long folderId, int status) 5751 throws com.liferay.portal.kernel.exception.SystemException { 5752 return getPersistence().findByG_F_ST(groupId, folderId, status); 5753 } 5754 5755 /** 5756 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = ?. 5757 * 5758 * <p> 5759 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5760 * </p> 5761 * 5762 * @param groupId the group ID 5763 * @param folderId the folder ID 5764 * @param status the status 5765 * @param start the lower bound of the range of journal articles 5766 * @param end the upper bound of the range of journal articles (not inclusive) 5767 * @return the range of matching journal articles 5768 * @throws SystemException if a system exception occurred 5769 */ 5770 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5771 long groupId, long folderId, int status, int start, int end) 5772 throws com.liferay.portal.kernel.exception.SystemException { 5773 return getPersistence() 5774 .findByG_F_ST(groupId, folderId, status, start, end); 5775 } 5776 5777 /** 5778 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = ?. 5779 * 5780 * <p> 5781 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5782 * </p> 5783 * 5784 * @param groupId the group ID 5785 * @param folderId the folder ID 5786 * @param status the status 5787 * @param start the lower bound of the range of journal articles 5788 * @param end the upper bound of the range of journal articles (not inclusive) 5789 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5790 * @return the ordered range of matching journal articles 5791 * @throws SystemException if a system exception occurred 5792 */ 5793 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5794 long groupId, long folderId, int status, int start, int end, 5795 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5796 throws com.liferay.portal.kernel.exception.SystemException { 5797 return getPersistence() 5798 .findByG_F_ST(groupId, folderId, status, start, end, 5799 orderByComparator); 5800 } 5801 5802 /** 5803 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5804 * 5805 * @param groupId the group ID 5806 * @param folderId the folder ID 5807 * @param status the status 5808 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5809 * @return the first matching journal article 5810 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5811 * @throws SystemException if a system exception occurred 5812 */ 5813 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First( 5814 long groupId, long folderId, int status, 5815 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5816 throws com.liferay.portal.kernel.exception.SystemException, 5817 com.liferay.portlet.journal.NoSuchArticleException { 5818 return getPersistence() 5819 .findByG_F_ST_First(groupId, folderId, status, 5820 orderByComparator); 5821 } 5822 5823 /** 5824 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5825 * 5826 * @param groupId the group ID 5827 * @param folderId the folder ID 5828 * @param status the status 5829 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5830 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5831 * @throws SystemException if a system exception occurred 5832 */ 5833 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First( 5834 long groupId, long folderId, int status, 5835 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5836 throws com.liferay.portal.kernel.exception.SystemException { 5837 return getPersistence() 5838 .fetchByG_F_ST_First(groupId, folderId, status, 5839 orderByComparator); 5840 } 5841 5842 /** 5843 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5844 * 5845 * @param groupId the group ID 5846 * @param folderId the folder ID 5847 * @param status the status 5848 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5849 * @return the last matching journal article 5850 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5851 * @throws SystemException if a system exception occurred 5852 */ 5853 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last( 5854 long groupId, long folderId, int status, 5855 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5856 throws com.liferay.portal.kernel.exception.SystemException, 5857 com.liferay.portlet.journal.NoSuchArticleException { 5858 return getPersistence() 5859 .findByG_F_ST_Last(groupId, folderId, status, 5860 orderByComparator); 5861 } 5862 5863 /** 5864 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5865 * 5866 * @param groupId the group ID 5867 * @param folderId the folder ID 5868 * @param status the status 5869 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5870 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5871 * @throws SystemException if a system exception occurred 5872 */ 5873 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last( 5874 long groupId, long folderId, int status, 5875 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5876 throws com.liferay.portal.kernel.exception.SystemException { 5877 return getPersistence() 5878 .fetchByG_F_ST_Last(groupId, folderId, status, 5879 orderByComparator); 5880 } 5881 5882 /** 5883 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5884 * 5885 * @param id the primary key of the current journal article 5886 * @param groupId the group ID 5887 * @param folderId the folder ID 5888 * @param status the status 5889 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5890 * @return the previous, current, and next journal article 5891 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5892 * @throws SystemException if a system exception occurred 5893 */ 5894 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext( 5895 long id, long groupId, long folderId, int status, 5896 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5897 throws com.liferay.portal.kernel.exception.SystemException, 5898 com.liferay.portlet.journal.NoSuchArticleException { 5899 return getPersistence() 5900 .findByG_F_ST_PrevAndNext(id, groupId, folderId, status, 5901 orderByComparator); 5902 } 5903 5904 /** 5905 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5906 * 5907 * @param groupId the group ID 5908 * @param folderId the folder ID 5909 * @param status the status 5910 * @return the matching journal articles that the user has permission to view 5911 * @throws SystemException if a system exception occurred 5912 */ 5913 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5914 long groupId, long folderId, int status) 5915 throws com.liferay.portal.kernel.exception.SystemException { 5916 return getPersistence().filterFindByG_F_ST(groupId, folderId, status); 5917 } 5918 5919 /** 5920 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5921 * 5922 * <p> 5923 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5924 * </p> 5925 * 5926 * @param groupId the group ID 5927 * @param folderId the folder ID 5928 * @param status the status 5929 * @param start the lower bound of the range of journal articles 5930 * @param end the upper bound of the range of journal articles (not inclusive) 5931 * @return the range of matching journal articles that the user has permission to view 5932 * @throws SystemException if a system exception occurred 5933 */ 5934 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5935 long groupId, long folderId, int status, int start, int end) 5936 throws com.liferay.portal.kernel.exception.SystemException { 5937 return getPersistence() 5938 .filterFindByG_F_ST(groupId, folderId, status, start, end); 5939 } 5940 5941 /** 5942 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 5943 * 5944 * <p> 5945 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 5946 * </p> 5947 * 5948 * @param groupId the group ID 5949 * @param folderId the folder ID 5950 * @param status the status 5951 * @param start the lower bound of the range of journal articles 5952 * @param end the upper bound of the range of journal articles (not inclusive) 5953 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5954 * @return the ordered range of matching journal articles that the user has permission to view 5955 * @throws SystemException if a system exception occurred 5956 */ 5957 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5958 long groupId, long folderId, int status, int start, int end, 5959 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5960 throws com.liferay.portal.kernel.exception.SystemException { 5961 return getPersistence() 5962 .filterFindByG_F_ST(groupId, folderId, status, start, end, 5963 orderByComparator); 5964 } 5965 5966 /** 5967 * 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 = ?. 5968 * 5969 * @param id the primary key of the current journal article 5970 * @param groupId the group ID 5971 * @param folderId the folder ID 5972 * @param status the status 5973 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5974 * @return the previous, current, and next journal article 5975 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5976 * @throws SystemException if a system exception occurred 5977 */ 5978 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext( 5979 long id, long groupId, long folderId, int status, 5980 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5981 throws com.liferay.portal.kernel.exception.SystemException, 5982 com.liferay.portlet.journal.NoSuchArticleException { 5983 return getPersistence() 5984 .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId, 5985 status, orderByComparator); 5986 } 5987 5988 /** 5989 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5990 * 5991 * @param groupId the group ID 5992 * @param folderId the folder ID 5993 * @param statuses the statuses 5994 * @return the matching journal articles that the user has permission to view 5995 * @throws SystemException if a system exception occurred 5996 */ 5997 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5998 long groupId, long folderId, int[] statuses) 5999 throws com.liferay.portal.kernel.exception.SystemException { 6000 return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses); 6001 } 6002 6003 /** 6004 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6005 * 6006 * <p> 6007 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6008 * </p> 6009 * 6010 * @param groupId the group ID 6011 * @param folderId the folder ID 6012 * @param statuses the statuses 6013 * @param start the lower bound of the range of journal articles 6014 * @param end the upper bound of the range of journal articles (not inclusive) 6015 * @return the range of matching journal articles that the user has permission to view 6016 * @throws SystemException if a system exception occurred 6017 */ 6018 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6019 long groupId, long folderId, int[] statuses, int start, int end) 6020 throws com.liferay.portal.kernel.exception.SystemException { 6021 return getPersistence() 6022 .filterFindByG_F_ST(groupId, folderId, statuses, start, end); 6023 } 6024 6025 /** 6026 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6027 * 6028 * <p> 6029 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6030 * </p> 6031 * 6032 * @param groupId the group ID 6033 * @param folderId the folder ID 6034 * @param statuses the statuses 6035 * @param start the lower bound of the range of journal articles 6036 * @param end the upper bound of the range of journal articles (not inclusive) 6037 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6038 * @return the ordered range of matching journal articles that the user has permission to view 6039 * @throws SystemException if a system exception occurred 6040 */ 6041 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6042 long groupId, long folderId, int[] statuses, int start, int end, 6043 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6044 throws com.liferay.portal.kernel.exception.SystemException { 6045 return getPersistence() 6046 .filterFindByG_F_ST(groupId, folderId, statuses, start, end, 6047 orderByComparator); 6048 } 6049 6050 /** 6051 * Returns all the journal articles where groupId = ? and folderId = ? and status = any ?. 6052 * 6053 * <p> 6054 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6055 * </p> 6056 * 6057 * @param groupId the group ID 6058 * @param folderId the folder ID 6059 * @param statuses the statuses 6060 * @return the matching journal articles 6061 * @throws SystemException if a system exception occurred 6062 */ 6063 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6064 long groupId, long folderId, int[] statuses) 6065 throws com.liferay.portal.kernel.exception.SystemException { 6066 return getPersistence().findByG_F_ST(groupId, folderId, statuses); 6067 } 6068 6069 /** 6070 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 6071 * 6072 * <p> 6073 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6074 * </p> 6075 * 6076 * @param groupId the group ID 6077 * @param folderId the folder ID 6078 * @param statuses the statuses 6079 * @param start the lower bound of the range of journal articles 6080 * @param end the upper bound of the range of journal articles (not inclusive) 6081 * @return the range of matching journal articles 6082 * @throws SystemException if a system exception occurred 6083 */ 6084 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6085 long groupId, long folderId, int[] statuses, int start, int end) 6086 throws com.liferay.portal.kernel.exception.SystemException { 6087 return getPersistence() 6088 .findByG_F_ST(groupId, folderId, statuses, start, end); 6089 } 6090 6091 /** 6092 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 6093 * 6094 * <p> 6095 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6096 * </p> 6097 * 6098 * @param groupId the group ID 6099 * @param folderId the folder ID 6100 * @param statuses the statuses 6101 * @param start the lower bound of the range of journal articles 6102 * @param end the upper bound of the range of journal articles (not inclusive) 6103 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6104 * @return the ordered range of matching journal articles 6105 * @throws SystemException if a system exception occurred 6106 */ 6107 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6108 long groupId, long folderId, int[] statuses, int start, int end, 6109 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6110 throws com.liferay.portal.kernel.exception.SystemException { 6111 return getPersistence() 6112 .findByG_F_ST(groupId, folderId, statuses, start, end, 6113 orderByComparator); 6114 } 6115 6116 /** 6117 * Removes all the journal articles where groupId = ? and folderId = ? and status = ? from the database. 6118 * 6119 * @param groupId the group ID 6120 * @param folderId the folder ID 6121 * @param status the status 6122 * @throws SystemException if a system exception occurred 6123 */ 6124 public static void removeByG_F_ST(long groupId, long folderId, int status) 6125 throws com.liferay.portal.kernel.exception.SystemException { 6126 getPersistence().removeByG_F_ST(groupId, folderId, status); 6127 } 6128 6129 /** 6130 * Returns the number of journal articles where groupId = ? and folderId = ? and status = ?. 6131 * 6132 * @param groupId the group ID 6133 * @param folderId the folder ID 6134 * @param status the status 6135 * @return the number of matching journal articles 6136 * @throws SystemException if a system exception occurred 6137 */ 6138 public static int countByG_F_ST(long groupId, long folderId, int status) 6139 throws com.liferay.portal.kernel.exception.SystemException { 6140 return getPersistence().countByG_F_ST(groupId, folderId, status); 6141 } 6142 6143 /** 6144 * Returns the number of journal articles where groupId = ? and folderId = ? and status = any ?. 6145 * 6146 * @param groupId the group ID 6147 * @param folderId the folder ID 6148 * @param statuses the statuses 6149 * @return the number of matching journal articles 6150 * @throws SystemException if a system exception occurred 6151 */ 6152 public static int countByG_F_ST(long groupId, long folderId, int[] statuses) 6153 throws com.liferay.portal.kernel.exception.SystemException { 6154 return getPersistence().countByG_F_ST(groupId, folderId, statuses); 6155 } 6156 6157 /** 6158 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 6159 * 6160 * @param groupId the group ID 6161 * @param folderId the folder ID 6162 * @param status the status 6163 * @return the number of matching journal articles that the user has permission to view 6164 * @throws SystemException if a system exception occurred 6165 */ 6166 public static int filterCountByG_F_ST(long groupId, long folderId, 6167 int status) throws com.liferay.portal.kernel.exception.SystemException { 6168 return getPersistence().filterCountByG_F_ST(groupId, folderId, status); 6169 } 6170 6171 /** 6172 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6173 * 6174 * @param groupId the group ID 6175 * @param folderId the folder ID 6176 * @param statuses the statuses 6177 * @return the number of matching journal articles that the user has permission to view 6178 * @throws SystemException if a system exception occurred 6179 */ 6180 public static int filterCountByG_F_ST(long groupId, long folderId, 6181 int[] statuses) 6182 throws com.liferay.portal.kernel.exception.SystemException { 6183 return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses); 6184 } 6185 6186 /** 6187 * Returns all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6188 * 6189 * @param groupId the group ID 6190 * @param classNameId the class name ID 6191 * @param classPK the class p k 6192 * @return the matching journal articles 6193 * @throws SystemException if a system exception occurred 6194 */ 6195 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6196 long groupId, long classNameId, long classPK) 6197 throws com.liferay.portal.kernel.exception.SystemException { 6198 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 6199 } 6200 6201 /** 6202 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6203 * 6204 * <p> 6205 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6206 * </p> 6207 * 6208 * @param groupId the group ID 6209 * @param classNameId the class name ID 6210 * @param classPK the class p k 6211 * @param start the lower bound of the range of journal articles 6212 * @param end the upper bound of the range of journal articles (not inclusive) 6213 * @return the range of matching journal articles 6214 * @throws SystemException if a system exception occurred 6215 */ 6216 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6217 long groupId, long classNameId, long classPK, int start, int end) 6218 throws com.liferay.portal.kernel.exception.SystemException { 6219 return getPersistence() 6220 .findByG_C_C(groupId, classNameId, classPK, start, end); 6221 } 6222 6223 /** 6224 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6225 * 6226 * <p> 6227 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6228 * </p> 6229 * 6230 * @param groupId the group ID 6231 * @param classNameId the class name ID 6232 * @param classPK the class p k 6233 * @param start the lower bound of the range of journal articles 6234 * @param end the upper bound of the range of journal articles (not inclusive) 6235 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6236 * @return the ordered range of matching journal articles 6237 * @throws SystemException if a system exception occurred 6238 */ 6239 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6240 long groupId, long classNameId, long classPK, int start, int end, 6241 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6242 throws com.liferay.portal.kernel.exception.SystemException { 6243 return getPersistence() 6244 .findByG_C_C(groupId, classNameId, classPK, start, end, 6245 orderByComparator); 6246 } 6247 6248 /** 6249 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6250 * 6251 * @param groupId the group ID 6252 * @param classNameId the class name ID 6253 * @param classPK the class p k 6254 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6255 * @return the first matching journal article 6256 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6257 * @throws SystemException if a system exception occurred 6258 */ 6259 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First( 6260 long groupId, long classNameId, long classPK, 6261 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6262 throws com.liferay.portal.kernel.exception.SystemException, 6263 com.liferay.portlet.journal.NoSuchArticleException { 6264 return getPersistence() 6265 .findByG_C_C_First(groupId, classNameId, classPK, 6266 orderByComparator); 6267 } 6268 6269 /** 6270 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6271 * 6272 * @param groupId the group ID 6273 * @param classNameId the class name ID 6274 * @param classPK the class p k 6275 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6276 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6277 * @throws SystemException if a system exception occurred 6278 */ 6279 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First( 6280 long groupId, long classNameId, long classPK, 6281 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6282 throws com.liferay.portal.kernel.exception.SystemException { 6283 return getPersistence() 6284 .fetchByG_C_C_First(groupId, classNameId, classPK, 6285 orderByComparator); 6286 } 6287 6288 /** 6289 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6290 * 6291 * @param groupId the group ID 6292 * @param classNameId the class name ID 6293 * @param classPK the class p k 6294 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6295 * @return the last matching journal article 6296 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6297 * @throws SystemException if a system exception occurred 6298 */ 6299 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last( 6300 long groupId, long classNameId, long classPK, 6301 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6302 throws com.liferay.portal.kernel.exception.SystemException, 6303 com.liferay.portlet.journal.NoSuchArticleException { 6304 return getPersistence() 6305 .findByG_C_C_Last(groupId, classNameId, classPK, 6306 orderByComparator); 6307 } 6308 6309 /** 6310 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6311 * 6312 * @param groupId the group ID 6313 * @param classNameId the class name ID 6314 * @param classPK the class p k 6315 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6316 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6317 * @throws SystemException if a system exception occurred 6318 */ 6319 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last( 6320 long groupId, long classNameId, long classPK, 6321 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6322 throws com.liferay.portal.kernel.exception.SystemException { 6323 return getPersistence() 6324 .fetchByG_C_C_Last(groupId, classNameId, classPK, 6325 orderByComparator); 6326 } 6327 6328 /** 6329 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6330 * 6331 * @param id the primary key of the current journal article 6332 * @param groupId the group ID 6333 * @param classNameId the class name ID 6334 * @param classPK the class p k 6335 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6336 * @return the previous, current, and next journal article 6337 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6338 * @throws SystemException if a system exception occurred 6339 */ 6340 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext( 6341 long id, long groupId, long classNameId, long classPK, 6342 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6343 throws com.liferay.portal.kernel.exception.SystemException, 6344 com.liferay.portlet.journal.NoSuchArticleException { 6345 return getPersistence() 6346 .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK, 6347 orderByComparator); 6348 } 6349 6350 /** 6351 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6352 * 6353 * @param groupId the group ID 6354 * @param classNameId the class name ID 6355 * @param classPK the class p k 6356 * @return the matching journal articles that the user has permission to view 6357 * @throws SystemException if a system exception occurred 6358 */ 6359 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6360 long groupId, long classNameId, long classPK) 6361 throws com.liferay.portal.kernel.exception.SystemException { 6362 return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK); 6363 } 6364 6365 /** 6366 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6367 * 6368 * <p> 6369 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6370 * </p> 6371 * 6372 * @param groupId the group ID 6373 * @param classNameId the class name ID 6374 * @param classPK the class p k 6375 * @param start the lower bound of the range of journal articles 6376 * @param end the upper bound of the range of journal articles (not inclusive) 6377 * @return the range of matching journal articles that the user has permission to view 6378 * @throws SystemException if a system exception occurred 6379 */ 6380 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6381 long groupId, long classNameId, long classPK, int start, int end) 6382 throws com.liferay.portal.kernel.exception.SystemException { 6383 return getPersistence() 6384 .filterFindByG_C_C(groupId, classNameId, classPK, start, end); 6385 } 6386 6387 /** 6388 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and classPK = ?. 6389 * 6390 * <p> 6391 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6392 * </p> 6393 * 6394 * @param groupId the group ID 6395 * @param classNameId the class name ID 6396 * @param classPK the class p k 6397 * @param start the lower bound of the range of journal articles 6398 * @param end the upper bound of the range of journal articles (not inclusive) 6399 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6400 * @return the ordered range of matching journal articles that the user has permission to view 6401 * @throws SystemException if a system exception occurred 6402 */ 6403 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6404 long groupId, long classNameId, long classPK, int start, int end, 6405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6406 throws com.liferay.portal.kernel.exception.SystemException { 6407 return getPersistence() 6408 .filterFindByG_C_C(groupId, classNameId, classPK, start, 6409 end, orderByComparator); 6410 } 6411 6412 /** 6413 * 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 = ?. 6414 * 6415 * @param id the primary key of the current journal article 6416 * @param groupId the group ID 6417 * @param classNameId the class name ID 6418 * @param classPK the class p k 6419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6420 * @return the previous, current, and next journal article 6421 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6422 * @throws SystemException if a system exception occurred 6423 */ 6424 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext( 6425 long id, long groupId, long classNameId, long classPK, 6426 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6427 throws com.liferay.portal.kernel.exception.SystemException, 6428 com.liferay.portlet.journal.NoSuchArticleException { 6429 return getPersistence() 6430 .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId, 6431 classPK, orderByComparator); 6432 } 6433 6434 /** 6435 * Removes all the journal articles where groupId = ? and classNameId = ? and classPK = ? from the database. 6436 * 6437 * @param groupId the group ID 6438 * @param classNameId the class name ID 6439 * @param classPK the class p k 6440 * @throws SystemException if a system exception occurred 6441 */ 6442 public static void removeByG_C_C(long groupId, long classNameId, 6443 long classPK) 6444 throws com.liferay.portal.kernel.exception.SystemException { 6445 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 6446 } 6447 6448 /** 6449 * Returns the number of journal articles where groupId = ? and classNameId = ? and classPK = ?. 6450 * 6451 * @param groupId the group ID 6452 * @param classNameId the class name ID 6453 * @param classPK the class p k 6454 * @return the number of matching journal articles 6455 * @throws SystemException if a system exception occurred 6456 */ 6457 public static int countByG_C_C(long groupId, long classNameId, long classPK) 6458 throws com.liferay.portal.kernel.exception.SystemException { 6459 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 6460 } 6461 6462 /** 6463 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6464 * 6465 * @param groupId the group ID 6466 * @param classNameId the class name ID 6467 * @param classPK the class p k 6468 * @return the number of matching journal articles that the user has permission to view 6469 * @throws SystemException if a system exception occurred 6470 */ 6471 public static int filterCountByG_C_C(long groupId, long classNameId, 6472 long classPK) 6473 throws com.liferay.portal.kernel.exception.SystemException { 6474 return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK); 6475 } 6476 6477 /** 6478 * 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. 6479 * 6480 * @param groupId the group ID 6481 * @param classNameId the class name ID 6482 * @param structureId the structure ID 6483 * @return the matching journal article 6484 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6485 * @throws SystemException if a system exception occurred 6486 */ 6487 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S( 6488 long groupId, long classNameId, java.lang.String structureId) 6489 throws com.liferay.portal.kernel.exception.SystemException, 6490 com.liferay.portlet.journal.NoSuchArticleException { 6491 return getPersistence().findByG_C_S(groupId, classNameId, structureId); 6492 } 6493 6494 /** 6495 * 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. 6496 * 6497 * @param groupId the group ID 6498 * @param classNameId the class name ID 6499 * @param structureId the structure ID 6500 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6501 * @throws SystemException if a system exception occurred 6502 */ 6503 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 6504 long groupId, long classNameId, java.lang.String structureId) 6505 throws com.liferay.portal.kernel.exception.SystemException { 6506 return getPersistence().fetchByG_C_S(groupId, classNameId, structureId); 6507 } 6508 6509 /** 6510 * 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. 6511 * 6512 * @param groupId the group ID 6513 * @param classNameId the class name ID 6514 * @param structureId the structure ID 6515 * @param retrieveFromCache whether to use the finder cache 6516 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6517 * @throws SystemException if a system exception occurred 6518 */ 6519 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 6520 long groupId, long classNameId, java.lang.String structureId, 6521 boolean retrieveFromCache) 6522 throws com.liferay.portal.kernel.exception.SystemException { 6523 return getPersistence() 6524 .fetchByG_C_S(groupId, classNameId, structureId, 6525 retrieveFromCache); 6526 } 6527 6528 /** 6529 * Removes the journal article where groupId = ? and classNameId = ? and structureId = ? from the database. 6530 * 6531 * @param groupId the group ID 6532 * @param classNameId the class name ID 6533 * @param structureId the structure ID 6534 * @return the journal article that was removed 6535 * @throws SystemException if a system exception occurred 6536 */ 6537 public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S( 6538 long groupId, long classNameId, java.lang.String structureId) 6539 throws com.liferay.portal.kernel.exception.SystemException, 6540 com.liferay.portlet.journal.NoSuchArticleException { 6541 return getPersistence().removeByG_C_S(groupId, classNameId, structureId); 6542 } 6543 6544 /** 6545 * Returns the number of journal articles where groupId = ? and classNameId = ? and structureId = ?. 6546 * 6547 * @param groupId the group ID 6548 * @param classNameId the class name ID 6549 * @param structureId the structure ID 6550 * @return the number of matching journal articles 6551 * @throws SystemException if a system exception occurred 6552 */ 6553 public static int countByG_C_S(long groupId, long classNameId, 6554 java.lang.String structureId) 6555 throws com.liferay.portal.kernel.exception.SystemException { 6556 return getPersistence().countByG_C_S(groupId, classNameId, structureId); 6557 } 6558 6559 /** 6560 * Returns all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6561 * 6562 * @param groupId the group ID 6563 * @param classNameId the class name ID 6564 * @param templateId the template ID 6565 * @return the matching journal articles 6566 * @throws SystemException if a system exception occurred 6567 */ 6568 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6569 long groupId, long classNameId, java.lang.String templateId) 6570 throws com.liferay.portal.kernel.exception.SystemException { 6571 return getPersistence().findByG_C_T(groupId, classNameId, templateId); 6572 } 6573 6574 /** 6575 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6576 * 6577 * <p> 6578 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6579 * </p> 6580 * 6581 * @param groupId the group ID 6582 * @param classNameId the class name ID 6583 * @param templateId the template ID 6584 * @param start the lower bound of the range of journal articles 6585 * @param end the upper bound of the range of journal articles (not inclusive) 6586 * @return the range of matching journal articles 6587 * @throws SystemException if a system exception occurred 6588 */ 6589 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6590 long groupId, long classNameId, java.lang.String templateId, int start, 6591 int end) throws com.liferay.portal.kernel.exception.SystemException { 6592 return getPersistence() 6593 .findByG_C_T(groupId, classNameId, templateId, start, end); 6594 } 6595 6596 /** 6597 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6598 * 6599 * <p> 6600 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6601 * </p> 6602 * 6603 * @param groupId the group ID 6604 * @param classNameId the class name ID 6605 * @param templateId the template ID 6606 * @param start the lower bound of the range of journal articles 6607 * @param end the upper bound of the range of journal articles (not inclusive) 6608 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6609 * @return the ordered range of matching journal articles 6610 * @throws SystemException if a system exception occurred 6611 */ 6612 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6613 long groupId, long classNameId, java.lang.String templateId, int start, 6614 int end, 6615 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6616 throws com.liferay.portal.kernel.exception.SystemException { 6617 return getPersistence() 6618 .findByG_C_T(groupId, classNameId, templateId, start, end, 6619 orderByComparator); 6620 } 6621 6622 /** 6623 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6624 * 6625 * @param groupId the group ID 6626 * @param classNameId the class name ID 6627 * @param templateId the template ID 6628 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6629 * @return the first matching journal article 6630 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6631 * @throws SystemException if a system exception occurred 6632 */ 6633 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First( 6634 long groupId, long classNameId, java.lang.String templateId, 6635 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6636 throws com.liferay.portal.kernel.exception.SystemException, 6637 com.liferay.portlet.journal.NoSuchArticleException { 6638 return getPersistence() 6639 .findByG_C_T_First(groupId, classNameId, templateId, 6640 orderByComparator); 6641 } 6642 6643 /** 6644 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6645 * 6646 * @param groupId the group ID 6647 * @param classNameId the class name ID 6648 * @param templateId the template ID 6649 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6650 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6651 * @throws SystemException if a system exception occurred 6652 */ 6653 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First( 6654 long groupId, long classNameId, java.lang.String templateId, 6655 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6656 throws com.liferay.portal.kernel.exception.SystemException { 6657 return getPersistence() 6658 .fetchByG_C_T_First(groupId, classNameId, templateId, 6659 orderByComparator); 6660 } 6661 6662 /** 6663 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6664 * 6665 * @param groupId the group ID 6666 * @param classNameId the class name ID 6667 * @param templateId the template ID 6668 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6669 * @return the last matching journal article 6670 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6671 * @throws SystemException if a system exception occurred 6672 */ 6673 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last( 6674 long groupId, long classNameId, java.lang.String templateId, 6675 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6676 throws com.liferay.portal.kernel.exception.SystemException, 6677 com.liferay.portlet.journal.NoSuchArticleException { 6678 return getPersistence() 6679 .findByG_C_T_Last(groupId, classNameId, templateId, 6680 orderByComparator); 6681 } 6682 6683 /** 6684 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6685 * 6686 * @param groupId the group ID 6687 * @param classNameId the class name ID 6688 * @param templateId the template ID 6689 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6690 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6691 * @throws SystemException if a system exception occurred 6692 */ 6693 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last( 6694 long groupId, long classNameId, java.lang.String templateId, 6695 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6696 throws com.liferay.portal.kernel.exception.SystemException { 6697 return getPersistence() 6698 .fetchByG_C_T_Last(groupId, classNameId, templateId, 6699 orderByComparator); 6700 } 6701 6702 /** 6703 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6704 * 6705 * @param id the primary key of the current journal article 6706 * @param groupId the group ID 6707 * @param classNameId the class name ID 6708 * @param templateId the template ID 6709 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6710 * @return the previous, current, and next journal article 6711 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6712 * @throws SystemException if a system exception occurred 6713 */ 6714 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext( 6715 long id, long groupId, long classNameId, java.lang.String templateId, 6716 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6717 throws com.liferay.portal.kernel.exception.SystemException, 6718 com.liferay.portlet.journal.NoSuchArticleException { 6719 return getPersistence() 6720 .findByG_C_T_PrevAndNext(id, groupId, classNameId, 6721 templateId, orderByComparator); 6722 } 6723 6724 /** 6725 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6726 * 6727 * @param groupId the group ID 6728 * @param classNameId the class name ID 6729 * @param templateId the template ID 6730 * @return the matching journal articles that the user has permission to view 6731 * @throws SystemException if a system exception occurred 6732 */ 6733 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6734 long groupId, long classNameId, java.lang.String templateId) 6735 throws com.liferay.portal.kernel.exception.SystemException { 6736 return getPersistence() 6737 .filterFindByG_C_T(groupId, classNameId, templateId); 6738 } 6739 6740 /** 6741 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6742 * 6743 * <p> 6744 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6745 * </p> 6746 * 6747 * @param groupId the group ID 6748 * @param classNameId the class name ID 6749 * @param templateId the template ID 6750 * @param start the lower bound of the range of journal articles 6751 * @param end the upper bound of the range of journal articles (not inclusive) 6752 * @return the range of matching journal articles that the user has permission to view 6753 * @throws SystemException if a system exception occurred 6754 */ 6755 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6756 long groupId, long classNameId, java.lang.String templateId, int start, 6757 int end) throws com.liferay.portal.kernel.exception.SystemException { 6758 return getPersistence() 6759 .filterFindByG_C_T(groupId, classNameId, templateId, start, 6760 end); 6761 } 6762 6763 /** 6764 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and templateId = ?. 6765 * 6766 * <p> 6767 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6768 * </p> 6769 * 6770 * @param groupId the group ID 6771 * @param classNameId the class name ID 6772 * @param templateId the template ID 6773 * @param start the lower bound of the range of journal articles 6774 * @param end the upper bound of the range of journal articles (not inclusive) 6775 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6776 * @return the ordered range of matching journal articles that the user has permission to view 6777 * @throws SystemException if a system exception occurred 6778 */ 6779 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6780 long groupId, long classNameId, java.lang.String templateId, int start, 6781 int end, 6782 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6783 throws com.liferay.portal.kernel.exception.SystemException { 6784 return getPersistence() 6785 .filterFindByG_C_T(groupId, classNameId, templateId, start, 6786 end, orderByComparator); 6787 } 6788 6789 /** 6790 * 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 = ?. 6791 * 6792 * @param id the primary key of the current journal article 6793 * @param groupId the group ID 6794 * @param classNameId the class name ID 6795 * @param templateId the template ID 6796 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6797 * @return the previous, current, and next journal article 6798 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6799 * @throws SystemException if a system exception occurred 6800 */ 6801 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext( 6802 long id, long groupId, long classNameId, java.lang.String templateId, 6803 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6804 throws com.liferay.portal.kernel.exception.SystemException, 6805 com.liferay.portlet.journal.NoSuchArticleException { 6806 return getPersistence() 6807 .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId, 6808 templateId, orderByComparator); 6809 } 6810 6811 /** 6812 * Removes all the journal articles where groupId = ? and classNameId = ? and templateId = ? from the database. 6813 * 6814 * @param groupId the group ID 6815 * @param classNameId the class name ID 6816 * @param templateId the template ID 6817 * @throws SystemException if a system exception occurred 6818 */ 6819 public static void removeByG_C_T(long groupId, long classNameId, 6820 java.lang.String templateId) 6821 throws com.liferay.portal.kernel.exception.SystemException { 6822 getPersistence().removeByG_C_T(groupId, classNameId, templateId); 6823 } 6824 6825 /** 6826 * Returns the number of journal articles where groupId = ? and classNameId = ? and templateId = ?. 6827 * 6828 * @param groupId the group ID 6829 * @param classNameId the class name ID 6830 * @param templateId the template ID 6831 * @return the number of matching journal articles 6832 * @throws SystemException if a system exception occurred 6833 */ 6834 public static int countByG_C_T(long groupId, long classNameId, 6835 java.lang.String templateId) 6836 throws com.liferay.portal.kernel.exception.SystemException { 6837 return getPersistence().countByG_C_T(groupId, classNameId, templateId); 6838 } 6839 6840 /** 6841 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6842 * 6843 * @param groupId the group ID 6844 * @param classNameId the class name ID 6845 * @param templateId the template ID 6846 * @return the number of matching journal articles that the user has permission to view 6847 * @throws SystemException if a system exception occurred 6848 */ 6849 public static int filterCountByG_C_T(long groupId, long classNameId, 6850 java.lang.String templateId) 6851 throws com.liferay.portal.kernel.exception.SystemException { 6852 return getPersistence() 6853 .filterCountByG_C_T(groupId, classNameId, templateId); 6854 } 6855 6856 /** 6857 * Returns all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6858 * 6859 * @param groupId the group ID 6860 * @param classNameId the class name ID 6861 * @param layoutUuid the layout uuid 6862 * @return the matching journal articles 6863 * @throws SystemException if a system exception occurred 6864 */ 6865 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6866 long groupId, long classNameId, java.lang.String layoutUuid) 6867 throws com.liferay.portal.kernel.exception.SystemException { 6868 return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid); 6869 } 6870 6871 /** 6872 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6873 * 6874 * <p> 6875 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6876 * </p> 6877 * 6878 * @param groupId the group ID 6879 * @param classNameId the class name ID 6880 * @param layoutUuid the layout uuid 6881 * @param start the lower bound of the range of journal articles 6882 * @param end the upper bound of the range of journal articles (not inclusive) 6883 * @return the range of matching journal articles 6884 * @throws SystemException if a system exception occurred 6885 */ 6886 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6887 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6888 int end) throws com.liferay.portal.kernel.exception.SystemException { 6889 return getPersistence() 6890 .findByG_C_L(groupId, classNameId, layoutUuid, start, end); 6891 } 6892 6893 /** 6894 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6895 * 6896 * <p> 6897 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 6898 * </p> 6899 * 6900 * @param groupId the group ID 6901 * @param classNameId the class name ID 6902 * @param layoutUuid the layout uuid 6903 * @param start the lower bound of the range of journal articles 6904 * @param end the upper bound of the range of journal articles (not inclusive) 6905 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6906 * @return the ordered range of matching journal articles 6907 * @throws SystemException if a system exception occurred 6908 */ 6909 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6910 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6911 int end, 6912 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6913 throws com.liferay.portal.kernel.exception.SystemException { 6914 return getPersistence() 6915 .findByG_C_L(groupId, classNameId, layoutUuid, start, end, 6916 orderByComparator); 6917 } 6918 6919 /** 6920 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6921 * 6922 * @param groupId the group ID 6923 * @param classNameId the class name ID 6924 * @param layoutUuid the layout uuid 6925 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6926 * @return the first matching journal article 6927 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6928 * @throws SystemException if a system exception occurred 6929 */ 6930 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First( 6931 long groupId, long classNameId, java.lang.String layoutUuid, 6932 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6933 throws com.liferay.portal.kernel.exception.SystemException, 6934 com.liferay.portlet.journal.NoSuchArticleException { 6935 return getPersistence() 6936 .findByG_C_L_First(groupId, classNameId, layoutUuid, 6937 orderByComparator); 6938 } 6939 6940 /** 6941 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6942 * 6943 * @param groupId the group ID 6944 * @param classNameId the class name ID 6945 * @param layoutUuid the layout uuid 6946 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6947 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6948 * @throws SystemException if a system exception occurred 6949 */ 6950 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First( 6951 long groupId, long classNameId, java.lang.String layoutUuid, 6952 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6953 throws com.liferay.portal.kernel.exception.SystemException { 6954 return getPersistence() 6955 .fetchByG_C_L_First(groupId, classNameId, layoutUuid, 6956 orderByComparator); 6957 } 6958 6959 /** 6960 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6961 * 6962 * @param groupId the group ID 6963 * @param classNameId the class name ID 6964 * @param layoutUuid the layout uuid 6965 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6966 * @return the last matching journal article 6967 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6968 * @throws SystemException if a system exception occurred 6969 */ 6970 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last( 6971 long groupId, long classNameId, java.lang.String layoutUuid, 6972 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6973 throws com.liferay.portal.kernel.exception.SystemException, 6974 com.liferay.portlet.journal.NoSuchArticleException { 6975 return getPersistence() 6976 .findByG_C_L_Last(groupId, classNameId, layoutUuid, 6977 orderByComparator); 6978 } 6979 6980 /** 6981 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6982 * 6983 * @param groupId the group ID 6984 * @param classNameId the class name ID 6985 * @param layoutUuid the layout uuid 6986 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6987 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6988 * @throws SystemException if a system exception occurred 6989 */ 6990 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last( 6991 long groupId, long classNameId, java.lang.String layoutUuid, 6992 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6993 throws com.liferay.portal.kernel.exception.SystemException { 6994 return getPersistence() 6995 .fetchByG_C_L_Last(groupId, classNameId, layoutUuid, 6996 orderByComparator); 6997 } 6998 6999 /** 7000 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7001 * 7002 * @param id the primary key of the current journal article 7003 * @param groupId the group ID 7004 * @param classNameId the class name ID 7005 * @param layoutUuid the layout uuid 7006 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7007 * @return the previous, current, and next journal article 7008 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7009 * @throws SystemException if a system exception occurred 7010 */ 7011 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext( 7012 long id, long groupId, long classNameId, java.lang.String layoutUuid, 7013 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7014 throws com.liferay.portal.kernel.exception.SystemException, 7015 com.liferay.portlet.journal.NoSuchArticleException { 7016 return getPersistence() 7017 .findByG_C_L_PrevAndNext(id, groupId, classNameId, 7018 layoutUuid, orderByComparator); 7019 } 7020 7021 /** 7022 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7023 * 7024 * @param groupId the group ID 7025 * @param classNameId the class name ID 7026 * @param layoutUuid the layout uuid 7027 * @return the matching journal articles that the user has permission to view 7028 * @throws SystemException if a system exception occurred 7029 */ 7030 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7031 long groupId, long classNameId, java.lang.String layoutUuid) 7032 throws com.liferay.portal.kernel.exception.SystemException { 7033 return getPersistence() 7034 .filterFindByG_C_L(groupId, classNameId, layoutUuid); 7035 } 7036 7037 /** 7038 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7039 * 7040 * <p> 7041 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7042 * </p> 7043 * 7044 * @param groupId the group ID 7045 * @param classNameId the class name ID 7046 * @param layoutUuid the layout uuid 7047 * @param start the lower bound of the range of journal articles 7048 * @param end the upper bound of the range of journal articles (not inclusive) 7049 * @return the range of matching journal articles that the user has permission to view 7050 * @throws SystemException if a system exception occurred 7051 */ 7052 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7053 long groupId, long classNameId, java.lang.String layoutUuid, int start, 7054 int end) throws com.liferay.portal.kernel.exception.SystemException { 7055 return getPersistence() 7056 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 7057 end); 7058 } 7059 7060 /** 7061 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7062 * 7063 * <p> 7064 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7065 * </p> 7066 * 7067 * @param groupId the group ID 7068 * @param classNameId the class name ID 7069 * @param layoutUuid the layout uuid 7070 * @param start the lower bound of the range of journal articles 7071 * @param end the upper bound of the range of journal articles (not inclusive) 7072 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7073 * @return the ordered range of matching journal articles that the user has permission to view 7074 * @throws SystemException if a system exception occurred 7075 */ 7076 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7077 long groupId, long classNameId, java.lang.String layoutUuid, int start, 7078 int end, 7079 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7080 throws com.liferay.portal.kernel.exception.SystemException { 7081 return getPersistence() 7082 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 7083 end, orderByComparator); 7084 } 7085 7086 /** 7087 * 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 = ?. 7088 * 7089 * @param id the primary key of the current journal article 7090 * @param groupId the group ID 7091 * @param classNameId the class name ID 7092 * @param layoutUuid the layout uuid 7093 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7094 * @return the previous, current, and next journal article 7095 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7096 * @throws SystemException if a system exception occurred 7097 */ 7098 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext( 7099 long id, long groupId, long classNameId, java.lang.String layoutUuid, 7100 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7101 throws com.liferay.portal.kernel.exception.SystemException, 7102 com.liferay.portlet.journal.NoSuchArticleException { 7103 return getPersistence() 7104 .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId, 7105 layoutUuid, orderByComparator); 7106 } 7107 7108 /** 7109 * Removes all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ? from the database. 7110 * 7111 * @param groupId the group ID 7112 * @param classNameId the class name ID 7113 * @param layoutUuid the layout uuid 7114 * @throws SystemException if a system exception occurred 7115 */ 7116 public static void removeByG_C_L(long groupId, long classNameId, 7117 java.lang.String layoutUuid) 7118 throws com.liferay.portal.kernel.exception.SystemException { 7119 getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid); 7120 } 7121 7122 /** 7123 * Returns the number of journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 7124 * 7125 * @param groupId the group ID 7126 * @param classNameId the class name ID 7127 * @param layoutUuid the layout uuid 7128 * @return the number of matching journal articles 7129 * @throws SystemException if a system exception occurred 7130 */ 7131 public static int countByG_C_L(long groupId, long classNameId, 7132 java.lang.String layoutUuid) 7133 throws com.liferay.portal.kernel.exception.SystemException { 7134 return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid); 7135 } 7136 7137 /** 7138 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7139 * 7140 * @param groupId the group ID 7141 * @param classNameId the class name ID 7142 * @param layoutUuid the layout uuid 7143 * @return the number of matching journal articles that the user has permission to view 7144 * @throws SystemException if a system exception occurred 7145 */ 7146 public static int filterCountByG_C_L(long groupId, long classNameId, 7147 java.lang.String layoutUuid) 7148 throws com.liferay.portal.kernel.exception.SystemException { 7149 return getPersistence() 7150 .filterCountByG_C_L(groupId, classNameId, layoutUuid); 7151 } 7152 7153 /** 7154 * 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. 7155 * 7156 * @param groupId the group ID 7157 * @param articleId the article ID 7158 * @param version the version 7159 * @return the matching journal article 7160 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7161 * @throws SystemException if a system exception occurred 7162 */ 7163 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V( 7164 long groupId, java.lang.String articleId, double version) 7165 throws com.liferay.portal.kernel.exception.SystemException, 7166 com.liferay.portlet.journal.NoSuchArticleException { 7167 return getPersistence().findByG_A_V(groupId, articleId, version); 7168 } 7169 7170 /** 7171 * 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. 7172 * 7173 * @param groupId the group ID 7174 * @param articleId the article ID 7175 * @param version the version 7176 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7177 * @throws SystemException if a system exception occurred 7178 */ 7179 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 7180 long groupId, java.lang.String articleId, double version) 7181 throws com.liferay.portal.kernel.exception.SystemException { 7182 return getPersistence().fetchByG_A_V(groupId, articleId, version); 7183 } 7184 7185 /** 7186 * 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. 7187 * 7188 * @param groupId the group ID 7189 * @param articleId the article ID 7190 * @param version the version 7191 * @param retrieveFromCache whether to use the finder cache 7192 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7193 * @throws SystemException if a system exception occurred 7194 */ 7195 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 7196 long groupId, java.lang.String articleId, double version, 7197 boolean retrieveFromCache) 7198 throws com.liferay.portal.kernel.exception.SystemException { 7199 return getPersistence() 7200 .fetchByG_A_V(groupId, articleId, version, retrieveFromCache); 7201 } 7202 7203 /** 7204 * Removes the journal article where groupId = ? and articleId = ? and version = ? from the database. 7205 * 7206 * @param groupId the group ID 7207 * @param articleId the article ID 7208 * @param version the version 7209 * @return the journal article that was removed 7210 * @throws SystemException if a system exception occurred 7211 */ 7212 public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V( 7213 long groupId, java.lang.String articleId, double version) 7214 throws com.liferay.portal.kernel.exception.SystemException, 7215 com.liferay.portlet.journal.NoSuchArticleException { 7216 return getPersistence().removeByG_A_V(groupId, articleId, version); 7217 } 7218 7219 /** 7220 * Returns the number of journal articles where groupId = ? and articleId = ? and version = ?. 7221 * 7222 * @param groupId the group ID 7223 * @param articleId the article ID 7224 * @param version the version 7225 * @return the number of matching journal articles 7226 * @throws SystemException if a system exception occurred 7227 */ 7228 public static int countByG_A_V(long groupId, java.lang.String articleId, 7229 double version) 7230 throws com.liferay.portal.kernel.exception.SystemException { 7231 return getPersistence().countByG_A_V(groupId, articleId, version); 7232 } 7233 7234 /** 7235 * Returns all the journal articles where groupId = ? and articleId = ? and status = ?. 7236 * 7237 * @param groupId the group ID 7238 * @param articleId the article ID 7239 * @param status the status 7240 * @return the matching journal articles 7241 * @throws SystemException if a system exception occurred 7242 */ 7243 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7244 long groupId, java.lang.String articleId, int status) 7245 throws com.liferay.portal.kernel.exception.SystemException { 7246 return getPersistence().findByG_A_ST(groupId, articleId, status); 7247 } 7248 7249 /** 7250 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = ?. 7251 * 7252 * <p> 7253 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7254 * </p> 7255 * 7256 * @param groupId the group ID 7257 * @param articleId the article ID 7258 * @param status the status 7259 * @param start the lower bound of the range of journal articles 7260 * @param end the upper bound of the range of journal articles (not inclusive) 7261 * @return the range of matching journal articles 7262 * @throws SystemException if a system exception occurred 7263 */ 7264 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7265 long groupId, java.lang.String articleId, int status, int start, int end) 7266 throws com.liferay.portal.kernel.exception.SystemException { 7267 return getPersistence() 7268 .findByG_A_ST(groupId, articleId, status, start, end); 7269 } 7270 7271 /** 7272 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = ?. 7273 * 7274 * <p> 7275 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7276 * </p> 7277 * 7278 * @param groupId the group ID 7279 * @param articleId the article ID 7280 * @param status the status 7281 * @param start the lower bound of the range of journal articles 7282 * @param end the upper bound of the range of journal articles (not inclusive) 7283 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7284 * @return the ordered range of matching journal articles 7285 * @throws SystemException if a system exception occurred 7286 */ 7287 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7288 long groupId, java.lang.String articleId, int status, int start, 7289 int end, 7290 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7291 throws com.liferay.portal.kernel.exception.SystemException { 7292 return getPersistence() 7293 .findByG_A_ST(groupId, articleId, status, start, end, 7294 orderByComparator); 7295 } 7296 7297 /** 7298 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7299 * 7300 * @param groupId the group ID 7301 * @param articleId the article ID 7302 * @param status the status 7303 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7304 * @return the first matching journal article 7305 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7306 * @throws SystemException if a system exception occurred 7307 */ 7308 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First( 7309 long groupId, java.lang.String articleId, int status, 7310 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7311 throws com.liferay.portal.kernel.exception.SystemException, 7312 com.liferay.portlet.journal.NoSuchArticleException { 7313 return getPersistence() 7314 .findByG_A_ST_First(groupId, articleId, status, 7315 orderByComparator); 7316 } 7317 7318 /** 7319 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7320 * 7321 * @param groupId the group ID 7322 * @param articleId the article ID 7323 * @param status the status 7324 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7325 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7326 * @throws SystemException if a system exception occurred 7327 */ 7328 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First( 7329 long groupId, java.lang.String articleId, int status, 7330 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7331 throws com.liferay.portal.kernel.exception.SystemException { 7332 return getPersistence() 7333 .fetchByG_A_ST_First(groupId, articleId, status, 7334 orderByComparator); 7335 } 7336 7337 /** 7338 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7339 * 7340 * @param groupId the group ID 7341 * @param articleId the article ID 7342 * @param status the status 7343 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7344 * @return the last matching journal article 7345 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7346 * @throws SystemException if a system exception occurred 7347 */ 7348 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last( 7349 long groupId, java.lang.String articleId, int status, 7350 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7351 throws com.liferay.portal.kernel.exception.SystemException, 7352 com.liferay.portlet.journal.NoSuchArticleException { 7353 return getPersistence() 7354 .findByG_A_ST_Last(groupId, articleId, status, 7355 orderByComparator); 7356 } 7357 7358 /** 7359 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7360 * 7361 * @param groupId the group ID 7362 * @param articleId the article ID 7363 * @param status the status 7364 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7365 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7366 * @throws SystemException if a system exception occurred 7367 */ 7368 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last( 7369 long groupId, java.lang.String articleId, int status, 7370 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7371 throws com.liferay.portal.kernel.exception.SystemException { 7372 return getPersistence() 7373 .fetchByG_A_ST_Last(groupId, articleId, status, 7374 orderByComparator); 7375 } 7376 7377 /** 7378 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7379 * 7380 * @param id the primary key of the current journal article 7381 * @param groupId the group ID 7382 * @param articleId the article ID 7383 * @param status the status 7384 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7385 * @return the previous, current, and next journal article 7386 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7387 * @throws SystemException if a system exception occurred 7388 */ 7389 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext( 7390 long id, long groupId, java.lang.String articleId, int status, 7391 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7392 throws com.liferay.portal.kernel.exception.SystemException, 7393 com.liferay.portlet.journal.NoSuchArticleException { 7394 return getPersistence() 7395 .findByG_A_ST_PrevAndNext(id, groupId, articleId, status, 7396 orderByComparator); 7397 } 7398 7399 /** 7400 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7401 * 7402 * @param groupId the group ID 7403 * @param articleId the article ID 7404 * @param status the status 7405 * @return the matching journal articles that the user has permission to view 7406 * @throws SystemException if a system exception occurred 7407 */ 7408 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7409 long groupId, java.lang.String articleId, int status) 7410 throws com.liferay.portal.kernel.exception.SystemException { 7411 return getPersistence().filterFindByG_A_ST(groupId, articleId, status); 7412 } 7413 7414 /** 7415 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7416 * 7417 * <p> 7418 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7419 * </p> 7420 * 7421 * @param groupId the group ID 7422 * @param articleId the article ID 7423 * @param status the status 7424 * @param start the lower bound of the range of journal articles 7425 * @param end the upper bound of the range of journal articles (not inclusive) 7426 * @return the range of matching journal articles that the user has permission to view 7427 * @throws SystemException if a system exception occurred 7428 */ 7429 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7430 long groupId, java.lang.String articleId, int status, int start, int end) 7431 throws com.liferay.portal.kernel.exception.SystemException { 7432 return getPersistence() 7433 .filterFindByG_A_ST(groupId, articleId, status, start, end); 7434 } 7435 7436 /** 7437 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status = ?. 7438 * 7439 * <p> 7440 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7441 * </p> 7442 * 7443 * @param groupId the group ID 7444 * @param articleId the article ID 7445 * @param status the status 7446 * @param start the lower bound of the range of journal articles 7447 * @param end the upper bound of the range of journal articles (not inclusive) 7448 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7449 * @return the ordered range of matching journal articles that the user has permission to view 7450 * @throws SystemException if a system exception occurred 7451 */ 7452 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7453 long groupId, java.lang.String articleId, int status, int start, 7454 int end, 7455 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7456 throws com.liferay.portal.kernel.exception.SystemException { 7457 return getPersistence() 7458 .filterFindByG_A_ST(groupId, articleId, status, start, end, 7459 orderByComparator); 7460 } 7461 7462 /** 7463 * 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 = ?. 7464 * 7465 * @param id the primary key of the current journal article 7466 * @param groupId the group ID 7467 * @param articleId the article ID 7468 * @param status the status 7469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7470 * @return the previous, current, and next journal article 7471 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7472 * @throws SystemException if a system exception occurred 7473 */ 7474 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext( 7475 long id, long groupId, java.lang.String articleId, int status, 7476 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7477 throws com.liferay.portal.kernel.exception.SystemException, 7478 com.liferay.portlet.journal.NoSuchArticleException { 7479 return getPersistence() 7480 .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId, 7481 status, orderByComparator); 7482 } 7483 7484 /** 7485 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7486 * 7487 * @param groupId the group ID 7488 * @param articleId the article ID 7489 * @param statuses the statuses 7490 * @return the matching journal articles that the user has permission to view 7491 * @throws SystemException if a system exception occurred 7492 */ 7493 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7494 long groupId, java.lang.String articleId, int[] statuses) 7495 throws com.liferay.portal.kernel.exception.SystemException { 7496 return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses); 7497 } 7498 7499 /** 7500 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7501 * 7502 * <p> 7503 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7504 * </p> 7505 * 7506 * @param groupId the group ID 7507 * @param articleId the article ID 7508 * @param statuses the statuses 7509 * @param start the lower bound of the range of journal articles 7510 * @param end the upper bound of the range of journal articles (not inclusive) 7511 * @return the range of matching journal articles that the user has permission to view 7512 * @throws SystemException if a system exception occurred 7513 */ 7514 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7515 long groupId, java.lang.String articleId, int[] statuses, int start, 7516 int end) throws com.liferay.portal.kernel.exception.SystemException { 7517 return getPersistence() 7518 .filterFindByG_A_ST(groupId, articleId, statuses, start, end); 7519 } 7520 7521 /** 7522 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7523 * 7524 * <p> 7525 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7526 * </p> 7527 * 7528 * @param groupId the group ID 7529 * @param articleId the article ID 7530 * @param statuses the statuses 7531 * @param start the lower bound of the range of journal articles 7532 * @param end the upper bound of the range of journal articles (not inclusive) 7533 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7534 * @return the ordered range of matching journal articles that the user has permission to view 7535 * @throws SystemException if a system exception occurred 7536 */ 7537 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7538 long groupId, java.lang.String articleId, int[] statuses, int start, 7539 int end, 7540 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7541 throws com.liferay.portal.kernel.exception.SystemException { 7542 return getPersistence() 7543 .filterFindByG_A_ST(groupId, articleId, statuses, start, 7544 end, orderByComparator); 7545 } 7546 7547 /** 7548 * Returns all the journal articles where groupId = ? and articleId = ? and status = any ?. 7549 * 7550 * <p> 7551 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7552 * </p> 7553 * 7554 * @param groupId the group ID 7555 * @param articleId the article ID 7556 * @param statuses the statuses 7557 * @return the matching journal articles 7558 * @throws SystemException if a system exception occurred 7559 */ 7560 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7561 long groupId, java.lang.String articleId, int[] statuses) 7562 throws com.liferay.portal.kernel.exception.SystemException { 7563 return getPersistence().findByG_A_ST(groupId, articleId, statuses); 7564 } 7565 7566 /** 7567 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 7568 * 7569 * <p> 7570 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7571 * </p> 7572 * 7573 * @param groupId the group ID 7574 * @param articleId the article ID 7575 * @param statuses the statuses 7576 * @param start the lower bound of the range of journal articles 7577 * @param end the upper bound of the range of journal articles (not inclusive) 7578 * @return the range of matching journal articles 7579 * @throws SystemException if a system exception occurred 7580 */ 7581 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7582 long groupId, java.lang.String articleId, int[] statuses, int start, 7583 int end) throws com.liferay.portal.kernel.exception.SystemException { 7584 return getPersistence() 7585 .findByG_A_ST(groupId, articleId, statuses, start, end); 7586 } 7587 7588 /** 7589 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 7590 * 7591 * <p> 7592 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7593 * </p> 7594 * 7595 * @param groupId the group ID 7596 * @param articleId the article ID 7597 * @param statuses the statuses 7598 * @param start the lower bound of the range of journal articles 7599 * @param end the upper bound of the range of journal articles (not inclusive) 7600 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7601 * @return the ordered range of matching journal articles 7602 * @throws SystemException if a system exception occurred 7603 */ 7604 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7605 long groupId, java.lang.String articleId, int[] statuses, int start, 7606 int end, 7607 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7608 throws com.liferay.portal.kernel.exception.SystemException { 7609 return getPersistence() 7610 .findByG_A_ST(groupId, articleId, statuses, start, end, 7611 orderByComparator); 7612 } 7613 7614 /** 7615 * Removes all the journal articles where groupId = ? and articleId = ? and status = ? from the database. 7616 * 7617 * @param groupId the group ID 7618 * @param articleId the article ID 7619 * @param status the status 7620 * @throws SystemException if a system exception occurred 7621 */ 7622 public static void removeByG_A_ST(long groupId, java.lang.String articleId, 7623 int status) throws com.liferay.portal.kernel.exception.SystemException { 7624 getPersistence().removeByG_A_ST(groupId, articleId, status); 7625 } 7626 7627 /** 7628 * Returns the number of journal articles where groupId = ? and articleId = ? and status = ?. 7629 * 7630 * @param groupId the group ID 7631 * @param articleId the article ID 7632 * @param status the status 7633 * @return the number of matching journal articles 7634 * @throws SystemException if a system exception occurred 7635 */ 7636 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7637 int status) throws com.liferay.portal.kernel.exception.SystemException { 7638 return getPersistence().countByG_A_ST(groupId, articleId, status); 7639 } 7640 7641 /** 7642 * Returns the number of journal articles where groupId = ? and articleId = ? and status = any ?. 7643 * 7644 * @param groupId the group ID 7645 * @param articleId the article ID 7646 * @param statuses the statuses 7647 * @return the number of matching journal articles 7648 * @throws SystemException if a system exception occurred 7649 */ 7650 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7651 int[] statuses) 7652 throws com.liferay.portal.kernel.exception.SystemException { 7653 return getPersistence().countByG_A_ST(groupId, articleId, statuses); 7654 } 7655 7656 /** 7657 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7658 * 7659 * @param groupId the group ID 7660 * @param articleId the article ID 7661 * @param status the status 7662 * @return the number of matching journal articles that the user has permission to view 7663 * @throws SystemException if a system exception occurred 7664 */ 7665 public static int filterCountByG_A_ST(long groupId, 7666 java.lang.String articleId, int status) 7667 throws com.liferay.portal.kernel.exception.SystemException { 7668 return getPersistence().filterCountByG_A_ST(groupId, articleId, status); 7669 } 7670 7671 /** 7672 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7673 * 7674 * @param groupId the group ID 7675 * @param articleId the article ID 7676 * @param statuses the statuses 7677 * @return the number of matching journal articles that the user has permission to view 7678 * @throws SystemException if a system exception occurred 7679 */ 7680 public static int filterCountByG_A_ST(long groupId, 7681 java.lang.String articleId, int[] statuses) 7682 throws com.liferay.portal.kernel.exception.SystemException { 7683 return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses); 7684 } 7685 7686 /** 7687 * Returns all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 7688 * 7689 * @param groupId the group ID 7690 * @param articleId the article ID 7691 * @param status the status 7692 * @return the matching journal articles 7693 * @throws SystemException if a system exception occurred 7694 */ 7695 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 7696 long groupId, java.lang.String articleId, int status) 7697 throws com.liferay.portal.kernel.exception.SystemException { 7698 return getPersistence().findByG_A_NotST(groupId, articleId, status); 7699 } 7700 7701 /** 7702 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 7703 * 7704 * <p> 7705 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7706 * </p> 7707 * 7708 * @param groupId the group ID 7709 * @param articleId the article ID 7710 * @param status the status 7711 * @param start the lower bound of the range of journal articles 7712 * @param end the upper bound of the range of journal articles (not inclusive) 7713 * @return the range of matching journal articles 7714 * @throws SystemException if a system exception occurred 7715 */ 7716 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 7717 long groupId, java.lang.String articleId, int status, int start, int end) 7718 throws com.liferay.portal.kernel.exception.SystemException { 7719 return getPersistence() 7720 .findByG_A_NotST(groupId, articleId, status, start, end); 7721 } 7722 7723 /** 7724 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 7725 * 7726 * <p> 7727 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7728 * </p> 7729 * 7730 * @param groupId the group ID 7731 * @param articleId the article ID 7732 * @param status the status 7733 * @param start the lower bound of the range of journal articles 7734 * @param end the upper bound of the range of journal articles (not inclusive) 7735 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7736 * @return the ordered range of matching journal articles 7737 * @throws SystemException if a system exception occurred 7738 */ 7739 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 7740 long groupId, java.lang.String articleId, int status, int start, 7741 int end, 7742 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7743 throws com.liferay.portal.kernel.exception.SystemException { 7744 return getPersistence() 7745 .findByG_A_NotST(groupId, articleId, status, start, end, 7746 orderByComparator); 7747 } 7748 7749 /** 7750 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7751 * 7752 * @param groupId the group ID 7753 * @param articleId the article ID 7754 * @param status the status 7755 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7756 * @return the first matching journal article 7757 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7758 * @throws SystemException if a system exception occurred 7759 */ 7760 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_First( 7761 long groupId, java.lang.String articleId, int status, 7762 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7763 throws com.liferay.portal.kernel.exception.SystemException, 7764 com.liferay.portlet.journal.NoSuchArticleException { 7765 return getPersistence() 7766 .findByG_A_NotST_First(groupId, articleId, status, 7767 orderByComparator); 7768 } 7769 7770 /** 7771 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7772 * 7773 * @param groupId the group ID 7774 * @param articleId the article ID 7775 * @param status the status 7776 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7777 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7778 * @throws SystemException if a system exception occurred 7779 */ 7780 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_First( 7781 long groupId, java.lang.String articleId, int status, 7782 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7783 throws com.liferay.portal.kernel.exception.SystemException { 7784 return getPersistence() 7785 .fetchByG_A_NotST_First(groupId, articleId, status, 7786 orderByComparator); 7787 } 7788 7789 /** 7790 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7791 * 7792 * @param groupId the group ID 7793 * @param articleId the article ID 7794 * @param status the status 7795 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7796 * @return the last matching journal article 7797 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7798 * @throws SystemException if a system exception occurred 7799 */ 7800 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_Last( 7801 long groupId, java.lang.String articleId, int status, 7802 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7803 throws com.liferay.portal.kernel.exception.SystemException, 7804 com.liferay.portlet.journal.NoSuchArticleException { 7805 return getPersistence() 7806 .findByG_A_NotST_Last(groupId, articleId, status, 7807 orderByComparator); 7808 } 7809 7810 /** 7811 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7812 * 7813 * @param groupId the group ID 7814 * @param articleId the article ID 7815 * @param status the status 7816 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7817 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7818 * @throws SystemException if a system exception occurred 7819 */ 7820 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_Last( 7821 long groupId, java.lang.String articleId, int status, 7822 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7823 throws com.liferay.portal.kernel.exception.SystemException { 7824 return getPersistence() 7825 .fetchByG_A_NotST_Last(groupId, articleId, status, 7826 orderByComparator); 7827 } 7828 7829 /** 7830 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 7831 * 7832 * @param id the primary key of the current journal article 7833 * @param groupId the group ID 7834 * @param articleId the article ID 7835 * @param status the status 7836 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7837 * @return the previous, current, and next journal article 7838 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7839 * @throws SystemException if a system exception occurred 7840 */ 7841 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_NotST_PrevAndNext( 7842 long id, long groupId, java.lang.String articleId, int status, 7843 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7844 throws com.liferay.portal.kernel.exception.SystemException, 7845 com.liferay.portlet.journal.NoSuchArticleException { 7846 return getPersistence() 7847 .findByG_A_NotST_PrevAndNext(id, groupId, articleId, status, 7848 orderByComparator); 7849 } 7850 7851 /** 7852 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 7853 * 7854 * @param groupId the group ID 7855 * @param articleId the article ID 7856 * @param status the status 7857 * @return the matching journal articles that the user has permission to view 7858 * @throws SystemException if a system exception occurred 7859 */ 7860 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 7861 long groupId, java.lang.String articleId, int status) 7862 throws com.liferay.portal.kernel.exception.SystemException { 7863 return getPersistence().filterFindByG_A_NotST(groupId, articleId, status); 7864 } 7865 7866 /** 7867 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 7868 * 7869 * <p> 7870 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7871 * </p> 7872 * 7873 * @param groupId the group ID 7874 * @param articleId the article ID 7875 * @param status the status 7876 * @param start the lower bound of the range of journal articles 7877 * @param end the upper bound of the range of journal articles (not inclusive) 7878 * @return the range of matching journal articles that the user has permission to view 7879 * @throws SystemException if a system exception occurred 7880 */ 7881 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 7882 long groupId, java.lang.String articleId, int status, int start, int end) 7883 throws com.liferay.portal.kernel.exception.SystemException { 7884 return getPersistence() 7885 .filterFindByG_A_NotST(groupId, articleId, status, start, end); 7886 } 7887 7888 /** 7889 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status ≠ ?. 7890 * 7891 * <p> 7892 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 7893 * </p> 7894 * 7895 * @param groupId the group ID 7896 * @param articleId the article ID 7897 * @param status the status 7898 * @param start the lower bound of the range of journal articles 7899 * @param end the upper bound of the range of journal articles (not inclusive) 7900 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7901 * @return the ordered range of matching journal articles that the user has permission to view 7902 * @throws SystemException if a system exception occurred 7903 */ 7904 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 7905 long groupId, java.lang.String articleId, int status, int start, 7906 int end, 7907 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7908 throws com.liferay.portal.kernel.exception.SystemException { 7909 return getPersistence() 7910 .filterFindByG_A_NotST(groupId, articleId, status, start, 7911 end, orderByComparator); 7912 } 7913 7914 /** 7915 * 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 ≠ ?. 7916 * 7917 * @param id the primary key of the current journal article 7918 * @param groupId the group ID 7919 * @param articleId the article ID 7920 * @param status the status 7921 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7922 * @return the previous, current, and next journal article 7923 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7924 * @throws SystemException if a system exception occurred 7925 */ 7926 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_NotST_PrevAndNext( 7927 long id, long groupId, java.lang.String articleId, int status, 7928 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7929 throws com.liferay.portal.kernel.exception.SystemException, 7930 com.liferay.portlet.journal.NoSuchArticleException { 7931 return getPersistence() 7932 .filterFindByG_A_NotST_PrevAndNext(id, groupId, articleId, 7933 status, orderByComparator); 7934 } 7935 7936 /** 7937 * Removes all the journal articles where groupId = ? and articleId = ? and status ≠ ? from the database. 7938 * 7939 * @param groupId the group ID 7940 * @param articleId the article ID 7941 * @param status the status 7942 * @throws SystemException if a system exception occurred 7943 */ 7944 public static void removeByG_A_NotST(long groupId, 7945 java.lang.String articleId, int status) 7946 throws com.liferay.portal.kernel.exception.SystemException { 7947 getPersistence().removeByG_A_NotST(groupId, articleId, status); 7948 } 7949 7950 /** 7951 * Returns the number of journal articles where groupId = ? and articleId = ? and status ≠ ?. 7952 * 7953 * @param groupId the group ID 7954 * @param articleId the article ID 7955 * @param status the status 7956 * @return the number of matching journal articles 7957 * @throws SystemException if a system exception occurred 7958 */ 7959 public static int countByG_A_NotST(long groupId, 7960 java.lang.String articleId, int status) 7961 throws com.liferay.portal.kernel.exception.SystemException { 7962 return getPersistence().countByG_A_NotST(groupId, articleId, status); 7963 } 7964 7965 /** 7966 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 7967 * 7968 * @param groupId the group ID 7969 * @param articleId the article ID 7970 * @param status the status 7971 * @return the number of matching journal articles that the user has permission to view 7972 * @throws SystemException if a system exception occurred 7973 */ 7974 public static int filterCountByG_A_NotST(long groupId, 7975 java.lang.String articleId, int status) 7976 throws com.liferay.portal.kernel.exception.SystemException { 7977 return getPersistence() 7978 .filterCountByG_A_NotST(groupId, articleId, status); 7979 } 7980 7981 /** 7982 * Returns all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7983 * 7984 * @param groupId the group ID 7985 * @param urlTitle the url title 7986 * @param status the status 7987 * @return the matching journal articles 7988 * @throws SystemException if a system exception occurred 7989 */ 7990 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7991 long groupId, java.lang.String urlTitle, int status) 7992 throws com.liferay.portal.kernel.exception.SystemException { 7993 return getPersistence().findByG_UT_ST(groupId, urlTitle, status); 7994 } 7995 7996 /** 7997 * Returns a range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7998 * 7999 * <p> 8000 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8001 * </p> 8002 * 8003 * @param groupId the group ID 8004 * @param urlTitle the url title 8005 * @param status the status 8006 * @param start the lower bound of the range of journal articles 8007 * @param end the upper bound of the range of journal articles (not inclusive) 8008 * @return the range of matching journal articles 8009 * @throws SystemException if a system exception occurred 8010 */ 8011 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 8012 long groupId, java.lang.String urlTitle, int status, int start, int end) 8013 throws com.liferay.portal.kernel.exception.SystemException { 8014 return getPersistence() 8015 .findByG_UT_ST(groupId, urlTitle, status, start, end); 8016 } 8017 8018 /** 8019 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 8020 * 8021 * <p> 8022 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8023 * </p> 8024 * 8025 * @param groupId the group ID 8026 * @param urlTitle the url title 8027 * @param status the status 8028 * @param start the lower bound of the range of journal articles 8029 * @param end the upper bound of the range of journal articles (not inclusive) 8030 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8031 * @return the ordered range of matching journal articles 8032 * @throws SystemException if a system exception occurred 8033 */ 8034 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 8035 long groupId, java.lang.String urlTitle, int status, int start, 8036 int end, 8037 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8038 throws com.liferay.portal.kernel.exception.SystemException { 8039 return getPersistence() 8040 .findByG_UT_ST(groupId, urlTitle, status, start, end, 8041 orderByComparator); 8042 } 8043 8044 /** 8045 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8046 * 8047 * @param groupId the group ID 8048 * @param urlTitle the url title 8049 * @param status the status 8050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8051 * @return the first matching journal article 8052 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8053 * @throws SystemException if a system exception occurred 8054 */ 8055 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First( 8056 long groupId, java.lang.String urlTitle, int status, 8057 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8058 throws com.liferay.portal.kernel.exception.SystemException, 8059 com.liferay.portlet.journal.NoSuchArticleException { 8060 return getPersistence() 8061 .findByG_UT_ST_First(groupId, urlTitle, status, 8062 orderByComparator); 8063 } 8064 8065 /** 8066 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8067 * 8068 * @param groupId the group ID 8069 * @param urlTitle the url title 8070 * @param status the status 8071 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8072 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 8073 * @throws SystemException if a system exception occurred 8074 */ 8075 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First( 8076 long groupId, java.lang.String urlTitle, int status, 8077 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8078 throws com.liferay.portal.kernel.exception.SystemException { 8079 return getPersistence() 8080 .fetchByG_UT_ST_First(groupId, urlTitle, status, 8081 orderByComparator); 8082 } 8083 8084 /** 8085 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8086 * 8087 * @param groupId the group ID 8088 * @param urlTitle the url title 8089 * @param status the status 8090 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8091 * @return the last matching journal article 8092 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8093 * @throws SystemException if a system exception occurred 8094 */ 8095 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last( 8096 long groupId, java.lang.String urlTitle, int status, 8097 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8098 throws com.liferay.portal.kernel.exception.SystemException, 8099 com.liferay.portlet.journal.NoSuchArticleException { 8100 return getPersistence() 8101 .findByG_UT_ST_Last(groupId, urlTitle, status, 8102 orderByComparator); 8103 } 8104 8105 /** 8106 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8107 * 8108 * @param groupId the group ID 8109 * @param urlTitle the url title 8110 * @param status the status 8111 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8112 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 8113 * @throws SystemException if a system exception occurred 8114 */ 8115 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last( 8116 long groupId, java.lang.String urlTitle, int status, 8117 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8118 throws com.liferay.portal.kernel.exception.SystemException { 8119 return getPersistence() 8120 .fetchByG_UT_ST_Last(groupId, urlTitle, status, 8121 orderByComparator); 8122 } 8123 8124 /** 8125 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8126 * 8127 * @param id the primary key of the current journal article 8128 * @param groupId the group ID 8129 * @param urlTitle the url title 8130 * @param status the status 8131 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8132 * @return the previous, current, and next journal article 8133 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8134 * @throws SystemException if a system exception occurred 8135 */ 8136 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext( 8137 long id, long groupId, java.lang.String urlTitle, int status, 8138 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8139 throws com.liferay.portal.kernel.exception.SystemException, 8140 com.liferay.portlet.journal.NoSuchArticleException { 8141 return getPersistence() 8142 .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status, 8143 orderByComparator); 8144 } 8145 8146 /** 8147 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8148 * 8149 * @param groupId the group ID 8150 * @param urlTitle the url title 8151 * @param status the status 8152 * @return the matching journal articles that the user has permission to view 8153 * @throws SystemException if a system exception occurred 8154 */ 8155 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8156 long groupId, java.lang.String urlTitle, int status) 8157 throws com.liferay.portal.kernel.exception.SystemException { 8158 return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status); 8159 } 8160 8161 /** 8162 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8163 * 8164 * <p> 8165 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8166 * </p> 8167 * 8168 * @param groupId the group ID 8169 * @param urlTitle the url title 8170 * @param status the status 8171 * @param start the lower bound of the range of journal articles 8172 * @param end the upper bound of the range of journal articles (not inclusive) 8173 * @return the range of matching journal articles that the user has permission to view 8174 * @throws SystemException if a system exception occurred 8175 */ 8176 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8177 long groupId, java.lang.String urlTitle, int status, int start, int end) 8178 throws com.liferay.portal.kernel.exception.SystemException { 8179 return getPersistence() 8180 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end); 8181 } 8182 8183 /** 8184 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ? and status = ?. 8185 * 8186 * <p> 8187 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8188 * </p> 8189 * 8190 * @param groupId the group ID 8191 * @param urlTitle the url title 8192 * @param status the status 8193 * @param start the lower bound of the range of journal articles 8194 * @param end the upper bound of the range of journal articles (not inclusive) 8195 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8196 * @return the ordered range of matching journal articles that the user has permission to view 8197 * @throws SystemException if a system exception occurred 8198 */ 8199 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8200 long groupId, java.lang.String urlTitle, int status, int start, 8201 int end, 8202 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8203 throws com.liferay.portal.kernel.exception.SystemException { 8204 return getPersistence() 8205 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end, 8206 orderByComparator); 8207 } 8208 8209 /** 8210 * 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 = ?. 8211 * 8212 * @param id the primary key of the current journal article 8213 * @param groupId the group ID 8214 * @param urlTitle the url title 8215 * @param status the status 8216 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8217 * @return the previous, current, and next journal article 8218 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8219 * @throws SystemException if a system exception occurred 8220 */ 8221 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext( 8222 long id, long groupId, java.lang.String urlTitle, int status, 8223 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8224 throws com.liferay.portal.kernel.exception.SystemException, 8225 com.liferay.portlet.journal.NoSuchArticleException { 8226 return getPersistence() 8227 .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle, 8228 status, orderByComparator); 8229 } 8230 8231 /** 8232 * Removes all the journal articles where groupId = ? and urlTitle = ? and status = ? from the database. 8233 * 8234 * @param groupId the group ID 8235 * @param urlTitle the url title 8236 * @param status the status 8237 * @throws SystemException if a system exception occurred 8238 */ 8239 public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle, 8240 int status) throws com.liferay.portal.kernel.exception.SystemException { 8241 getPersistence().removeByG_UT_ST(groupId, urlTitle, status); 8242 } 8243 8244 /** 8245 * Returns the number of journal articles where groupId = ? and urlTitle = ? and status = ?. 8246 * 8247 * @param groupId the group ID 8248 * @param urlTitle the url title 8249 * @param status the status 8250 * @return the number of matching journal articles 8251 * @throws SystemException if a system exception occurred 8252 */ 8253 public static int countByG_UT_ST(long groupId, java.lang.String urlTitle, 8254 int status) throws com.liferay.portal.kernel.exception.SystemException { 8255 return getPersistence().countByG_UT_ST(groupId, urlTitle, status); 8256 } 8257 8258 /** 8259 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8260 * 8261 * @param groupId the group ID 8262 * @param urlTitle the url title 8263 * @param status the status 8264 * @return the number of matching journal articles that the user has permission to view 8265 * @throws SystemException if a system exception occurred 8266 */ 8267 public static int filterCountByG_UT_ST(long groupId, 8268 java.lang.String urlTitle, int status) 8269 throws com.liferay.portal.kernel.exception.SystemException { 8270 return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status); 8271 } 8272 8273 /** 8274 * Returns all the journal articles where companyId = ? and version = ? and status = ?. 8275 * 8276 * @param companyId the company ID 8277 * @param version the version 8278 * @param status the status 8279 * @return the matching journal articles 8280 * @throws SystemException if a system exception occurred 8281 */ 8282 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8283 long companyId, double version, int status) 8284 throws com.liferay.portal.kernel.exception.SystemException { 8285 return getPersistence().findByC_V_ST(companyId, version, status); 8286 } 8287 8288 /** 8289 * Returns a range of all the journal articles where companyId = ? and version = ? and status = ?. 8290 * 8291 * <p> 8292 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8293 * </p> 8294 * 8295 * @param companyId the company ID 8296 * @param version the version 8297 * @param status the status 8298 * @param start the lower bound of the range of journal articles 8299 * @param end the upper bound of the range of journal articles (not inclusive) 8300 * @return the range of matching journal articles 8301 * @throws SystemException if a system exception occurred 8302 */ 8303 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8304 long companyId, double version, int status, int start, int end) 8305 throws com.liferay.portal.kernel.exception.SystemException { 8306 return getPersistence() 8307 .findByC_V_ST(companyId, version, status, start, end); 8308 } 8309 8310 /** 8311 * Returns an ordered range of all the journal articles where companyId = ? and version = ? and status = ?. 8312 * 8313 * <p> 8314 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8315 * </p> 8316 * 8317 * @param companyId the company ID 8318 * @param version the version 8319 * @param status the status 8320 * @param start the lower bound of the range of journal articles 8321 * @param end the upper bound of the range of journal articles (not inclusive) 8322 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8323 * @return the ordered range of matching journal articles 8324 * @throws SystemException if a system exception occurred 8325 */ 8326 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8327 long companyId, double version, int status, int start, int end, 8328 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8329 throws com.liferay.portal.kernel.exception.SystemException { 8330 return getPersistence() 8331 .findByC_V_ST(companyId, version, status, start, end, 8332 orderByComparator); 8333 } 8334 8335 /** 8336 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 8337 * 8338 * @param companyId the company ID 8339 * @param version the version 8340 * @param status the status 8341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8342 * @return the first matching journal article 8343 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8344 * @throws SystemException if a system exception occurred 8345 */ 8346 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First( 8347 long companyId, double version, int status, 8348 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8349 throws com.liferay.portal.kernel.exception.SystemException, 8350 com.liferay.portlet.journal.NoSuchArticleException { 8351 return getPersistence() 8352 .findByC_V_ST_First(companyId, version, status, 8353 orderByComparator); 8354 } 8355 8356 /** 8357 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 8358 * 8359 * @param companyId the company ID 8360 * @param version the version 8361 * @param status the status 8362 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8363 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 8364 * @throws SystemException if a system exception occurred 8365 */ 8366 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First( 8367 long companyId, double version, int status, 8368 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8369 throws com.liferay.portal.kernel.exception.SystemException { 8370 return getPersistence() 8371 .fetchByC_V_ST_First(companyId, version, status, 8372 orderByComparator); 8373 } 8374 8375 /** 8376 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 8377 * 8378 * @param companyId the company ID 8379 * @param version the version 8380 * @param status the status 8381 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8382 * @return the last matching journal article 8383 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8384 * @throws SystemException if a system exception occurred 8385 */ 8386 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last( 8387 long companyId, double version, int status, 8388 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8389 throws com.liferay.portal.kernel.exception.SystemException, 8390 com.liferay.portlet.journal.NoSuchArticleException { 8391 return getPersistence() 8392 .findByC_V_ST_Last(companyId, version, status, 8393 orderByComparator); 8394 } 8395 8396 /** 8397 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 8398 * 8399 * @param companyId the company ID 8400 * @param version the version 8401 * @param status the status 8402 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8403 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 8404 * @throws SystemException if a system exception occurred 8405 */ 8406 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last( 8407 long companyId, double version, int status, 8408 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8409 throws com.liferay.portal.kernel.exception.SystemException { 8410 return getPersistence() 8411 .fetchByC_V_ST_Last(companyId, version, status, 8412 orderByComparator); 8413 } 8414 8415 /** 8416 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ? and status = ?. 8417 * 8418 * @param id the primary key of the current journal article 8419 * @param companyId the company ID 8420 * @param version the version 8421 * @param status the status 8422 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8423 * @return the previous, current, and next journal article 8424 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8425 * @throws SystemException if a system exception occurred 8426 */ 8427 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext( 8428 long id, long companyId, double version, int status, 8429 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8430 throws com.liferay.portal.kernel.exception.SystemException, 8431 com.liferay.portlet.journal.NoSuchArticleException { 8432 return getPersistence() 8433 .findByC_V_ST_PrevAndNext(id, companyId, version, status, 8434 orderByComparator); 8435 } 8436 8437 /** 8438 * Removes all the journal articles where companyId = ? and version = ? and status = ? from the database. 8439 * 8440 * @param companyId the company ID 8441 * @param version the version 8442 * @param status the status 8443 * @throws SystemException if a system exception occurred 8444 */ 8445 public static void removeByC_V_ST(long companyId, double version, int status) 8446 throws com.liferay.portal.kernel.exception.SystemException { 8447 getPersistence().removeByC_V_ST(companyId, version, status); 8448 } 8449 8450 /** 8451 * Returns the number of journal articles where companyId = ? and version = ? and status = ?. 8452 * 8453 * @param companyId the company ID 8454 * @param version the version 8455 * @param status the status 8456 * @return the number of matching journal articles 8457 * @throws SystemException if a system exception occurred 8458 */ 8459 public static int countByC_V_ST(long companyId, double version, int status) 8460 throws com.liferay.portal.kernel.exception.SystemException { 8461 return getPersistence().countByC_V_ST(companyId, version, status); 8462 } 8463 8464 /** 8465 * Caches the journal article in the entity cache if it is enabled. 8466 * 8467 * @param journalArticle the journal article 8468 */ 8469 public static void cacheResult( 8470 com.liferay.portlet.journal.model.JournalArticle journalArticle) { 8471 getPersistence().cacheResult(journalArticle); 8472 } 8473 8474 /** 8475 * Caches the journal articles in the entity cache if it is enabled. 8476 * 8477 * @param journalArticles the journal articles 8478 */ 8479 public static void cacheResult( 8480 java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) { 8481 getPersistence().cacheResult(journalArticles); 8482 } 8483 8484 /** 8485 * Creates a new journal article with the primary key. Does not add the journal article to the database. 8486 * 8487 * @param id the primary key for the new journal article 8488 * @return the new journal article 8489 */ 8490 public static com.liferay.portlet.journal.model.JournalArticle create( 8491 long id) { 8492 return getPersistence().create(id); 8493 } 8494 8495 /** 8496 * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners. 8497 * 8498 * @param id the primary key of the journal article 8499 * @return the journal article that was removed 8500 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8501 * @throws SystemException if a system exception occurred 8502 */ 8503 public static com.liferay.portlet.journal.model.JournalArticle remove( 8504 long id) 8505 throws com.liferay.portal.kernel.exception.SystemException, 8506 com.liferay.portlet.journal.NoSuchArticleException { 8507 return getPersistence().remove(id); 8508 } 8509 8510 public static com.liferay.portlet.journal.model.JournalArticle updateImpl( 8511 com.liferay.portlet.journal.model.JournalArticle journalArticle) 8512 throws com.liferay.portal.kernel.exception.SystemException { 8513 return getPersistence().updateImpl(journalArticle); 8514 } 8515 8516 /** 8517 * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 8518 * 8519 * @param id the primary key of the journal article 8520 * @return the journal article 8521 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8522 * @throws SystemException if a system exception occurred 8523 */ 8524 public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey( 8525 long id) 8526 throws com.liferay.portal.kernel.exception.SystemException, 8527 com.liferay.portlet.journal.NoSuchArticleException { 8528 return getPersistence().findByPrimaryKey(id); 8529 } 8530 8531 /** 8532 * Returns the journal article with the primary key or returns <code>null</code> if it could not be found. 8533 * 8534 * @param id the primary key of the journal article 8535 * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found 8536 * @throws SystemException if a system exception occurred 8537 */ 8538 public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey( 8539 long id) throws com.liferay.portal.kernel.exception.SystemException { 8540 return getPersistence().fetchByPrimaryKey(id); 8541 } 8542 8543 /** 8544 * Returns all the journal articles. 8545 * 8546 * @return the journal articles 8547 * @throws SystemException if a system exception occurred 8548 */ 8549 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll() 8550 throws com.liferay.portal.kernel.exception.SystemException { 8551 return getPersistence().findAll(); 8552 } 8553 8554 /** 8555 * Returns a range of all the journal articles. 8556 * 8557 * <p> 8558 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8559 * </p> 8560 * 8561 * @param start the lower bound of the range of journal articles 8562 * @param end the upper bound of the range of journal articles (not inclusive) 8563 * @return the range of journal articles 8564 * @throws SystemException if a system exception occurred 8565 */ 8566 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 8567 int start, int end) 8568 throws com.liferay.portal.kernel.exception.SystemException { 8569 return getPersistence().findAll(start, end); 8570 } 8571 8572 /** 8573 * Returns an ordered range of all the journal articles. 8574 * 8575 * <p> 8576 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <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. 8577 * </p> 8578 * 8579 * @param start the lower bound of the range of journal articles 8580 * @param end the upper bound of the range of journal articles (not inclusive) 8581 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8582 * @return the ordered range of journal articles 8583 * @throws SystemException if a system exception occurred 8584 */ 8585 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 8586 int start, int end, 8587 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8588 throws com.liferay.portal.kernel.exception.SystemException { 8589 return getPersistence().findAll(start, end, orderByComparator); 8590 } 8591 8592 /** 8593 * Removes all the journal articles from the database. 8594 * 8595 * @throws SystemException if a system exception occurred 8596 */ 8597 public static void removeAll() 8598 throws com.liferay.portal.kernel.exception.SystemException { 8599 getPersistence().removeAll(); 8600 } 8601 8602 /** 8603 * Returns the number of journal articles. 8604 * 8605 * @return the number of journal articles 8606 * @throws SystemException if a system exception occurred 8607 */ 8608 public static int countAll() 8609 throws com.liferay.portal.kernel.exception.SystemException { 8610 return getPersistence().countAll(); 8611 } 8612 8613 public static JournalArticlePersistence getPersistence() { 8614 if (_persistence == null) { 8615 _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName()); 8616 8617 ReferenceRegistry.registerReference(JournalArticleUtil.class, 8618 "_persistence"); 8619 } 8620 8621 return _persistence; 8622 } 8623 8624 /** 8625 * @deprecated As of 6.2.0 8626 */ 8627 public void setPersistence(JournalArticlePersistence persistence) { 8628 } 8629 8630 private static JournalArticlePersistence _persistence; 8631 }