001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.journal.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.journal.model.JournalArticle; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the journal article service. This utility wraps {@link JournalArticlePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see JournalArticlePersistence 037 * @see JournalArticlePersistenceImpl 038 * @generated 039 */ 040 public class JournalArticleUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(JournalArticle journalArticle) { 058 getPersistence().clearCache(journalArticle); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<JournalArticle> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<JournalArticle> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<JournalArticle> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static JournalArticle update(JournalArticle journalArticle) 101 throws SystemException { 102 return getPersistence().update(journalArticle); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static JournalArticle update(JournalArticle journalArticle, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(journalArticle, serviceContext); 111 } 112 113 /** 114 * Returns all the journal articles where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching journal articles 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 121 java.lang.String uuid) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByUuid(uuid); 124 } 125 126 /** 127 * Returns a range of all the journal articles where uuid = ?. 128 * 129 * <p> 130 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 131 * </p> 132 * 133 * @param uuid the uuid 134 * @param start the lower bound of the range of journal articles 135 * @param end the upper bound of the range of journal articles (not inclusive) 136 * @return the range of matching journal articles 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 140 java.lang.String uuid, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByUuid(uuid, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the journal articles where uuid = ?. 147 * 148 * <p> 149 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 150 * </p> 151 * 152 * @param uuid the uuid 153 * @param start the lower bound of the range of journal articles 154 * @param end the upper bound of the range of journal articles (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching journal articles 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 160 java.lang.String uuid, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 164 } 165 166 /** 167 * Returns the first journal article in the ordered set where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 171 * @return the first matching journal article 172 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First( 176 java.lang.String uuid, 177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.journal.NoSuchArticleException { 180 return getPersistence().findByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the first journal article in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 189 * @throws SystemException if a system exception occurred 190 */ 191 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First( 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 194 throws com.liferay.portal.kernel.exception.SystemException { 195 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 196 } 197 198 /** 199 * Returns the last journal article in the ordered set where uuid = ?. 200 * 201 * @param uuid the uuid 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching journal article 204 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 205 * @throws SystemException if a system exception occurred 206 */ 207 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last( 208 java.lang.String uuid, 209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 210 throws com.liferay.portal.kernel.exception.SystemException, 211 com.liferay.portlet.journal.NoSuchArticleException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last journal article in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 221 * @throws SystemException if a system exception occurred 222 */ 223 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last( 224 java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 226 throws com.liferay.portal.kernel.exception.SystemException { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the journal articles before and after the current journal article in the ordered set where uuid = ?. 232 * 233 * @param id the primary key of the current journal article 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next journal article 237 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 238 * @throws SystemException if a system exception occurred 239 */ 240 public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext( 241 long id, java.lang.String uuid, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException, 244 com.liferay.portlet.journal.NoSuchArticleException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 247 } 248 249 /** 250 * Removes all the journal articles where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 * @throws SystemException if a system exception occurred 254 */ 255 public static void removeByUuid(java.lang.String uuid) 256 throws com.liferay.portal.kernel.exception.SystemException { 257 getPersistence().removeByUuid(uuid); 258 } 259 260 /** 261 * Returns the number of journal articles where uuid = ?. 262 * 263 * @param uuid the uuid 264 * @return the number of matching journal articles 265 * @throws SystemException if a system exception occurred 266 */ 267 public static int countByUuid(java.lang.String uuid) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 return getPersistence().countByUuid(uuid); 270 } 271 272 /** 273 * Returns the journal article where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @return the matching journal article 278 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G( 282 java.lang.String uuid, long groupId) 283 throws com.liferay.portal.kernel.exception.SystemException, 284 com.liferay.portlet.journal.NoSuchArticleException { 285 return getPersistence().findByUUID_G(uuid, groupId); 286 } 287 288 /** 289 * Returns the journal article where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 290 * 291 * @param uuid the uuid 292 * @param groupId the group ID 293 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 294 * @throws SystemException if a system exception occurred 295 */ 296 public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G( 297 java.lang.String uuid, long groupId) 298 throws com.liferay.portal.kernel.exception.SystemException { 299 return getPersistence().fetchByUUID_G(uuid, groupId); 300 } 301 302 /** 303 * Returns the journal article where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @param retrieveFromCache whether to use the finder cache 308 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 309 * @throws SystemException if a system exception occurred 310 */ 311 public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G( 312 java.lang.String uuid, long groupId, boolean retrieveFromCache) 313 throws com.liferay.portal.kernel.exception.SystemException { 314 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 315 } 316 317 /** 318 * Removes the journal article where uuid = ? and groupId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param groupId the group ID 322 * @return the journal article that was removed 323 * @throws SystemException if a system exception occurred 324 */ 325 public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.journal.NoSuchArticleException { 329 return getPersistence().removeByUUID_G(uuid, groupId); 330 } 331 332 /** 333 * Returns the number of journal articles where uuid = ? and groupId = ?. 334 * 335 * @param uuid the uuid 336 * @param groupId the group ID 337 * @return the number of matching journal articles 338 * @throws SystemException if a system exception occurred 339 */ 340 public static int countByUUID_G(java.lang.String uuid, long groupId) 341 throws com.liferay.portal.kernel.exception.SystemException { 342 return getPersistence().countByUUID_G(uuid, groupId); 343 } 344 345 /** 346 * Returns all the journal articles where uuid = ? and companyId = ?. 347 * 348 * @param uuid the uuid 349 * @param companyId the company ID 350 * @return the matching journal articles 351 * @throws SystemException if a system exception occurred 352 */ 353 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 354 java.lang.String uuid, long companyId) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().findByUuid_C(uuid, companyId); 357 } 358 359 /** 360 * Returns a range of all the journal articles where uuid = ? and companyId = ?. 361 * 362 * <p> 363 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 364 * </p> 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @param start the lower bound of the range of journal articles 369 * @param end the upper bound of the range of journal articles (not inclusive) 370 * @return the range of matching journal articles 371 * @throws SystemException if a system exception occurred 372 */ 373 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 374 java.lang.String uuid, long companyId, int start, int end) 375 throws com.liferay.portal.kernel.exception.SystemException { 376 return getPersistence().findByUuid_C(uuid, companyId, start, end); 377 } 378 379 /** 380 * Returns an ordered range of all the journal articles where uuid = ? and companyId = ?. 381 * 382 * <p> 383 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 384 * </p> 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param start the lower bound of the range of journal articles 389 * @param end the upper bound of the range of journal articles (not inclusive) 390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 391 * @return the ordered range of matching journal articles 392 * @throws SystemException if a system exception occurred 393 */ 394 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 395 java.lang.String uuid, long companyId, int start, int end, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence() 399 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 400 } 401 402 /** 403 * Returns the first journal article in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the first matching journal article 409 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First( 413 java.lang.String uuid, long companyId, 414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 415 throws com.liferay.portal.kernel.exception.SystemException, 416 com.liferay.portlet.journal.NoSuchArticleException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first journal article in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 428 * @throws SystemException if a system exception occurred 429 */ 430 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First( 431 java.lang.String uuid, long companyId, 432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 433 throws com.liferay.portal.kernel.exception.SystemException { 434 return getPersistence() 435 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 436 } 437 438 /** 439 * Returns the last journal article in the ordered set where uuid = ? and companyId = ?. 440 * 441 * @param uuid the uuid 442 * @param companyId the company ID 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the last matching journal article 445 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 446 * @throws SystemException if a system exception occurred 447 */ 448 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last( 449 java.lang.String uuid, long companyId, 450 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 451 throws com.liferay.portal.kernel.exception.SystemException, 452 com.liferay.portlet.journal.NoSuchArticleException { 453 return getPersistence() 454 .findByUuid_C_Last(uuid, companyId, orderByComparator); 455 } 456 457 /** 458 * Returns the last journal article in the ordered set where uuid = ? and companyId = ?. 459 * 460 * @param uuid the uuid 461 * @param companyId the company ID 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 463 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last( 467 java.lang.String uuid, long companyId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence() 471 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 472 } 473 474 /** 475 * Returns the journal articles before and after the current journal article in the ordered set where uuid = ? and companyId = ?. 476 * 477 * @param id the primary key of the current journal article 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the previous, current, and next journal article 482 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 483 * @throws SystemException if a system exception occurred 484 */ 485 public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext( 486 long id, java.lang.String uuid, long companyId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.journal.NoSuchArticleException { 490 return getPersistence() 491 .findByUuid_C_PrevAndNext(id, uuid, companyId, 492 orderByComparator); 493 } 494 495 /** 496 * Removes all the journal articles where uuid = ? and companyId = ? from the database. 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @throws SystemException if a system exception occurred 501 */ 502 public static void removeByUuid_C(java.lang.String uuid, long companyId) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 getPersistence().removeByUuid_C(uuid, companyId); 505 } 506 507 /** 508 * Returns the number of journal articles where uuid = ? and companyId = ?. 509 * 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @return the number of matching journal articles 513 * @throws SystemException if a system exception occurred 514 */ 515 public static int countByUuid_C(java.lang.String uuid, long companyId) 516 throws com.liferay.portal.kernel.exception.SystemException { 517 return getPersistence().countByUuid_C(uuid, companyId); 518 } 519 520 /** 521 * Returns all the journal articles where resourcePrimKey = ?. 522 * 523 * @param resourcePrimKey the resource prim key 524 * @return the matching journal articles 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 528 long resourcePrimKey) 529 throws com.liferay.portal.kernel.exception.SystemException { 530 return getPersistence().findByResourcePrimKey(resourcePrimKey); 531 } 532 533 /** 534 * Returns a range of all the journal articles where resourcePrimKey = ?. 535 * 536 * <p> 537 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 538 * </p> 539 * 540 * @param resourcePrimKey the resource prim key 541 * @param start the lower bound of the range of journal articles 542 * @param end the upper bound of the range of journal articles (not inclusive) 543 * @return the range of matching journal articles 544 * @throws SystemException if a system exception occurred 545 */ 546 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 547 long resourcePrimKey, int start, int end) 548 throws com.liferay.portal.kernel.exception.SystemException { 549 return getPersistence() 550 .findByResourcePrimKey(resourcePrimKey, start, end); 551 } 552 553 /** 554 * Returns an ordered range of all the journal articles where resourcePrimKey = ?. 555 * 556 * <p> 557 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 558 * </p> 559 * 560 * @param resourcePrimKey the resource prim key 561 * @param start the lower bound of the range of journal articles 562 * @param end the upper bound of the range of journal articles (not inclusive) 563 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 564 * @return the ordered range of matching journal articles 565 * @throws SystemException if a system exception occurred 566 */ 567 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 568 long resourcePrimKey, int start, int end, 569 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 570 throws com.liferay.portal.kernel.exception.SystemException { 571 return getPersistence() 572 .findByResourcePrimKey(resourcePrimKey, start, end, 573 orderByComparator); 574 } 575 576 /** 577 * Returns the first journal article in the ordered set where resourcePrimKey = ?. 578 * 579 * @param resourcePrimKey the resource prim key 580 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 581 * @return the first matching journal article 582 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 583 * @throws SystemException if a system exception occurred 584 */ 585 public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First( 586 long resourcePrimKey, 587 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 588 throws com.liferay.portal.kernel.exception.SystemException, 589 com.liferay.portlet.journal.NoSuchArticleException { 590 return getPersistence() 591 .findByResourcePrimKey_First(resourcePrimKey, 592 orderByComparator); 593 } 594 595 /** 596 * Returns the first journal article in the ordered set where resourcePrimKey = ?. 597 * 598 * @param resourcePrimKey the resource prim key 599 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 600 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 601 * @throws SystemException if a system exception occurred 602 */ 603 public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First( 604 long resourcePrimKey, 605 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 606 throws com.liferay.portal.kernel.exception.SystemException { 607 return getPersistence() 608 .fetchByResourcePrimKey_First(resourcePrimKey, 609 orderByComparator); 610 } 611 612 /** 613 * Returns the last journal article in the ordered set where resourcePrimKey = ?. 614 * 615 * @param resourcePrimKey the resource prim key 616 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 617 * @return the last matching journal article 618 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 619 * @throws SystemException if a system exception occurred 620 */ 621 public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last( 622 long resourcePrimKey, 623 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 624 throws com.liferay.portal.kernel.exception.SystemException, 625 com.liferay.portlet.journal.NoSuchArticleException { 626 return getPersistence() 627 .findByResourcePrimKey_Last(resourcePrimKey, 628 orderByComparator); 629 } 630 631 /** 632 * Returns the last journal article in the ordered set where resourcePrimKey = ?. 633 * 634 * @param resourcePrimKey the resource prim key 635 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 636 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 637 * @throws SystemException if a system exception occurred 638 */ 639 public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last( 640 long resourcePrimKey, 641 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 642 throws com.liferay.portal.kernel.exception.SystemException { 643 return getPersistence() 644 .fetchByResourcePrimKey_Last(resourcePrimKey, 645 orderByComparator); 646 } 647 648 /** 649 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ?. 650 * 651 * @param id the primary key of the current journal article 652 * @param resourcePrimKey the resource prim key 653 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 654 * @return the previous, current, and next journal article 655 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 656 * @throws SystemException if a system exception occurred 657 */ 658 public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext( 659 long id, long resourcePrimKey, 660 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 661 throws com.liferay.portal.kernel.exception.SystemException, 662 com.liferay.portlet.journal.NoSuchArticleException { 663 return getPersistence() 664 .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey, 665 orderByComparator); 666 } 667 668 /** 669 * Removes all the journal articles where resourcePrimKey = ? from the database. 670 * 671 * @param resourcePrimKey the resource prim key 672 * @throws SystemException if a system exception occurred 673 */ 674 public static void removeByResourcePrimKey(long resourcePrimKey) 675 throws com.liferay.portal.kernel.exception.SystemException { 676 getPersistence().removeByResourcePrimKey(resourcePrimKey); 677 } 678 679 /** 680 * Returns the number of journal articles where resourcePrimKey = ?. 681 * 682 * @param resourcePrimKey the resource prim key 683 * @return the number of matching journal articles 684 * @throws SystemException if a system exception occurred 685 */ 686 public static int countByResourcePrimKey(long resourcePrimKey) 687 throws com.liferay.portal.kernel.exception.SystemException { 688 return getPersistence().countByResourcePrimKey(resourcePrimKey); 689 } 690 691 /** 692 * Returns all the journal articles where groupId = ?. 693 * 694 * @param groupId the group ID 695 * @return the matching journal articles 696 * @throws SystemException if a system exception occurred 697 */ 698 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 699 long groupId) 700 throws com.liferay.portal.kernel.exception.SystemException { 701 return getPersistence().findByGroupId(groupId); 702 } 703 704 /** 705 * Returns a range of all the journal articles where groupId = ?. 706 * 707 * <p> 708 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 709 * </p> 710 * 711 * @param groupId the group ID 712 * @param start the lower bound of the range of journal articles 713 * @param end the upper bound of the range of journal articles (not inclusive) 714 * @return the range of matching journal articles 715 * @throws SystemException if a system exception occurred 716 */ 717 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 718 long groupId, int start, int end) 719 throws com.liferay.portal.kernel.exception.SystemException { 720 return getPersistence().findByGroupId(groupId, start, end); 721 } 722 723 /** 724 * Returns an ordered range of all the journal articles where groupId = ?. 725 * 726 * <p> 727 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 728 * </p> 729 * 730 * @param groupId the group ID 731 * @param start the lower bound of the range of journal articles 732 * @param end the upper bound of the range of journal articles (not inclusive) 733 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 734 * @return the ordered range of matching journal articles 735 * @throws SystemException if a system exception occurred 736 */ 737 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 738 long groupId, int start, int end, 739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 740 throws com.liferay.portal.kernel.exception.SystemException { 741 return getPersistence() 742 .findByGroupId(groupId, start, end, orderByComparator); 743 } 744 745 /** 746 * Returns the first journal article in the ordered set where groupId = ?. 747 * 748 * @param groupId the group ID 749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 750 * @return the first matching journal article 751 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 752 * @throws SystemException if a system exception occurred 753 */ 754 public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First( 755 long groupId, 756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 757 throws com.liferay.portal.kernel.exception.SystemException, 758 com.liferay.portlet.journal.NoSuchArticleException { 759 return getPersistence().findByGroupId_First(groupId, orderByComparator); 760 } 761 762 /** 763 * Returns the first journal article in the ordered set where groupId = ?. 764 * 765 * @param groupId the group ID 766 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 767 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 768 * @throws SystemException if a system exception occurred 769 */ 770 public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First( 771 long groupId, 772 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 775 } 776 777 /** 778 * Returns the last journal article in the ordered set where groupId = ?. 779 * 780 * @param groupId the group ID 781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 782 * @return the last matching journal article 783 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 784 * @throws SystemException if a system exception occurred 785 */ 786 public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last( 787 long groupId, 788 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 789 throws com.liferay.portal.kernel.exception.SystemException, 790 com.liferay.portlet.journal.NoSuchArticleException { 791 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 792 } 793 794 /** 795 * Returns the last journal article in the ordered set where groupId = ?. 796 * 797 * @param groupId the group ID 798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 799 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 800 * @throws SystemException if a system exception occurred 801 */ 802 public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last( 803 long groupId, 804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 805 throws com.liferay.portal.kernel.exception.SystemException { 806 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 807 } 808 809 /** 810 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ?. 811 * 812 * @param id the primary key of the current journal article 813 * @param groupId the group ID 814 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 815 * @return the previous, current, and next journal article 816 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 817 * @throws SystemException if a system exception occurred 818 */ 819 public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext( 820 long id, long groupId, 821 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 822 throws com.liferay.portal.kernel.exception.SystemException, 823 com.liferay.portlet.journal.NoSuchArticleException { 824 return getPersistence() 825 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 826 } 827 828 /** 829 * Returns all the journal articles that the user has permission to view where groupId = ?. 830 * 831 * @param groupId the group ID 832 * @return the matching journal articles that the user has permission to view 833 * @throws SystemException if a system exception occurred 834 */ 835 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 836 long groupId) 837 throws com.liferay.portal.kernel.exception.SystemException { 838 return getPersistence().filterFindByGroupId(groupId); 839 } 840 841 /** 842 * Returns a range of all the journal articles that the user has permission to view where groupId = ?. 843 * 844 * <p> 845 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 846 * </p> 847 * 848 * @param groupId the group ID 849 * @param start the lower bound of the range of journal articles 850 * @param end the upper bound of the range of journal articles (not inclusive) 851 * @return the range of matching journal articles that the user has permission to view 852 * @throws SystemException if a system exception occurred 853 */ 854 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 855 long groupId, int start, int end) 856 throws com.liferay.portal.kernel.exception.SystemException { 857 return getPersistence().filterFindByGroupId(groupId, start, end); 858 } 859 860 /** 861 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ?. 862 * 863 * <p> 864 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 865 * </p> 866 * 867 * @param groupId the group ID 868 * @param start the lower bound of the range of journal articles 869 * @param end the upper bound of the range of journal articles (not inclusive) 870 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 871 * @return the ordered range of matching journal articles that the user has permission to view 872 * @throws SystemException if a system exception occurred 873 */ 874 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 875 long groupId, int start, int end, 876 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 877 throws com.liferay.portal.kernel.exception.SystemException { 878 return getPersistence() 879 .filterFindByGroupId(groupId, start, end, orderByComparator); 880 } 881 882 /** 883 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ?. 884 * 885 * @param id the primary key of the current journal article 886 * @param groupId the group ID 887 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 888 * @return the previous, current, and next journal article 889 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 890 * @throws SystemException if a system exception occurred 891 */ 892 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext( 893 long id, long groupId, 894 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 895 throws com.liferay.portal.kernel.exception.SystemException, 896 com.liferay.portlet.journal.NoSuchArticleException { 897 return getPersistence() 898 .filterFindByGroupId_PrevAndNext(id, groupId, 899 orderByComparator); 900 } 901 902 /** 903 * Removes all the journal articles where groupId = ? from the database. 904 * 905 * @param groupId the group ID 906 * @throws SystemException if a system exception occurred 907 */ 908 public static void removeByGroupId(long groupId) 909 throws com.liferay.portal.kernel.exception.SystemException { 910 getPersistence().removeByGroupId(groupId); 911 } 912 913 /** 914 * Returns the number of journal articles where groupId = ?. 915 * 916 * @param groupId the group ID 917 * @return the number of matching journal articles 918 * @throws SystemException if a system exception occurred 919 */ 920 public static int countByGroupId(long groupId) 921 throws com.liferay.portal.kernel.exception.SystemException { 922 return getPersistence().countByGroupId(groupId); 923 } 924 925 /** 926 * Returns the number of journal articles that the user has permission to view where groupId = ?. 927 * 928 * @param groupId the group ID 929 * @return the number of matching journal articles that the user has permission to view 930 * @throws SystemException if a system exception occurred 931 */ 932 public static int filterCountByGroupId(long groupId) 933 throws com.liferay.portal.kernel.exception.SystemException { 934 return getPersistence().filterCountByGroupId(groupId); 935 } 936 937 /** 938 * Returns all the journal articles where companyId = ?. 939 * 940 * @param companyId the company ID 941 * @return the matching journal articles 942 * @throws SystemException if a system exception occurred 943 */ 944 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 945 long companyId) 946 throws com.liferay.portal.kernel.exception.SystemException { 947 return getPersistence().findByCompanyId(companyId); 948 } 949 950 /** 951 * Returns a range of all the journal articles where companyId = ?. 952 * 953 * <p> 954 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 955 * </p> 956 * 957 * @param companyId the company ID 958 * @param start the lower bound of the range of journal articles 959 * @param end the upper bound of the range of journal articles (not inclusive) 960 * @return the range of matching journal articles 961 * @throws SystemException if a system exception occurred 962 */ 963 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 964 long companyId, int start, int end) 965 throws com.liferay.portal.kernel.exception.SystemException { 966 return getPersistence().findByCompanyId(companyId, start, end); 967 } 968 969 /** 970 * Returns an ordered range of all the journal articles where companyId = ?. 971 * 972 * <p> 973 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 974 * </p> 975 * 976 * @param companyId the company ID 977 * @param start the lower bound of the range of journal articles 978 * @param end the upper bound of the range of journal articles (not inclusive) 979 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 980 * @return the ordered range of matching journal articles 981 * @throws SystemException if a system exception occurred 982 */ 983 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 984 long companyId, int start, int end, 985 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 986 throws com.liferay.portal.kernel.exception.SystemException { 987 return getPersistence() 988 .findByCompanyId(companyId, start, end, orderByComparator); 989 } 990 991 /** 992 * Returns the first journal article in the ordered set where companyId = ?. 993 * 994 * @param companyId the company ID 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the first matching journal article 997 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 998 * @throws SystemException if a system exception occurred 999 */ 1000 public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First( 1001 long companyId, 1002 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1003 throws com.liferay.portal.kernel.exception.SystemException, 1004 com.liferay.portlet.journal.NoSuchArticleException { 1005 return getPersistence() 1006 .findByCompanyId_First(companyId, orderByComparator); 1007 } 1008 1009 /** 1010 * Returns the first journal article in the ordered set where companyId = ?. 1011 * 1012 * @param companyId the company ID 1013 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1014 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1015 * @throws SystemException if a system exception occurred 1016 */ 1017 public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First( 1018 long companyId, 1019 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1020 throws com.liferay.portal.kernel.exception.SystemException { 1021 return getPersistence() 1022 .fetchByCompanyId_First(companyId, orderByComparator); 1023 } 1024 1025 /** 1026 * Returns the last journal article in the ordered set where companyId = ?. 1027 * 1028 * @param companyId the company ID 1029 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1030 * @return the last matching journal article 1031 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last( 1035 long companyId, 1036 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1037 throws com.liferay.portal.kernel.exception.SystemException, 1038 com.liferay.portlet.journal.NoSuchArticleException { 1039 return getPersistence() 1040 .findByCompanyId_Last(companyId, orderByComparator); 1041 } 1042 1043 /** 1044 * Returns the last journal article in the ordered set where companyId = ?. 1045 * 1046 * @param companyId the company ID 1047 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1048 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1049 * @throws SystemException if a system exception occurred 1050 */ 1051 public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last( 1052 long companyId, 1053 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1054 throws com.liferay.portal.kernel.exception.SystemException { 1055 return getPersistence() 1056 .fetchByCompanyId_Last(companyId, orderByComparator); 1057 } 1058 1059 /** 1060 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ?. 1061 * 1062 * @param id the primary key of the current journal article 1063 * @param companyId the company ID 1064 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1065 * @return the previous, current, and next journal article 1066 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1067 * @throws SystemException if a system exception occurred 1068 */ 1069 public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext( 1070 long id, long companyId, 1071 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1072 throws com.liferay.portal.kernel.exception.SystemException, 1073 com.liferay.portlet.journal.NoSuchArticleException { 1074 return getPersistence() 1075 .findByCompanyId_PrevAndNext(id, companyId, orderByComparator); 1076 } 1077 1078 /** 1079 * Removes all the journal articles where companyId = ? from the database. 1080 * 1081 * @param companyId the company ID 1082 * @throws SystemException if a system exception occurred 1083 */ 1084 public static void removeByCompanyId(long companyId) 1085 throws com.liferay.portal.kernel.exception.SystemException { 1086 getPersistence().removeByCompanyId(companyId); 1087 } 1088 1089 /** 1090 * Returns the number of journal articles where companyId = ?. 1091 * 1092 * @param companyId the company ID 1093 * @return the number of matching journal articles 1094 * @throws SystemException if a system exception occurred 1095 */ 1096 public static int countByCompanyId(long companyId) 1097 throws com.liferay.portal.kernel.exception.SystemException { 1098 return getPersistence().countByCompanyId(companyId); 1099 } 1100 1101 /** 1102 * Returns all the journal articles where structureId = ?. 1103 * 1104 * @param structureId the structure ID 1105 * @return the matching journal articles 1106 * @throws SystemException if a system exception occurred 1107 */ 1108 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1109 java.lang.String structureId) 1110 throws com.liferay.portal.kernel.exception.SystemException { 1111 return getPersistence().findByStructureId(structureId); 1112 } 1113 1114 /** 1115 * Returns a range of all the journal articles where structureId = ?. 1116 * 1117 * <p> 1118 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1119 * </p> 1120 * 1121 * @param structureId the structure ID 1122 * @param start the lower bound of the range of journal articles 1123 * @param end the upper bound of the range of journal articles (not inclusive) 1124 * @return the range of matching journal articles 1125 * @throws SystemException if a system exception occurred 1126 */ 1127 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1128 java.lang.String structureId, int start, int end) 1129 throws com.liferay.portal.kernel.exception.SystemException { 1130 return getPersistence().findByStructureId(structureId, start, end); 1131 } 1132 1133 /** 1134 * Returns an ordered range of all the journal articles where structureId = ?. 1135 * 1136 * <p> 1137 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1138 * </p> 1139 * 1140 * @param structureId the structure ID 1141 * @param start the lower bound of the range of journal articles 1142 * @param end the upper bound of the range of journal articles (not inclusive) 1143 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1144 * @return the ordered range of matching journal articles 1145 * @throws SystemException if a system exception occurred 1146 */ 1147 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1148 java.lang.String structureId, int start, int end, 1149 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1150 throws com.liferay.portal.kernel.exception.SystemException { 1151 return getPersistence() 1152 .findByStructureId(structureId, start, end, orderByComparator); 1153 } 1154 1155 /** 1156 * Returns the first journal article in the ordered set where structureId = ?. 1157 * 1158 * @param structureId the structure ID 1159 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1160 * @return the first matching journal article 1161 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1162 * @throws SystemException if a system exception occurred 1163 */ 1164 public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First( 1165 java.lang.String structureId, 1166 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1167 throws com.liferay.portal.kernel.exception.SystemException, 1168 com.liferay.portlet.journal.NoSuchArticleException { 1169 return getPersistence() 1170 .findByStructureId_First(structureId, orderByComparator); 1171 } 1172 1173 /** 1174 * Returns the first journal article in the ordered set where structureId = ?. 1175 * 1176 * @param structureId the structure ID 1177 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1178 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1179 * @throws SystemException if a system exception occurred 1180 */ 1181 public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First( 1182 java.lang.String structureId, 1183 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1184 throws com.liferay.portal.kernel.exception.SystemException { 1185 return getPersistence() 1186 .fetchByStructureId_First(structureId, orderByComparator); 1187 } 1188 1189 /** 1190 * Returns the last journal article in the ordered set where structureId = ?. 1191 * 1192 * @param structureId the structure ID 1193 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1194 * @return the last matching journal article 1195 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1196 * @throws SystemException if a system exception occurred 1197 */ 1198 public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last( 1199 java.lang.String structureId, 1200 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1201 throws com.liferay.portal.kernel.exception.SystemException, 1202 com.liferay.portlet.journal.NoSuchArticleException { 1203 return getPersistence() 1204 .findByStructureId_Last(structureId, orderByComparator); 1205 } 1206 1207 /** 1208 * Returns the last journal article in the ordered set where structureId = ?. 1209 * 1210 * @param structureId the structure ID 1211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1212 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1213 * @throws SystemException if a system exception occurred 1214 */ 1215 public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last( 1216 java.lang.String structureId, 1217 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1218 throws com.liferay.portal.kernel.exception.SystemException { 1219 return getPersistence() 1220 .fetchByStructureId_Last(structureId, orderByComparator); 1221 } 1222 1223 /** 1224 * Returns the journal articles before and after the current journal article in the ordered set where structureId = ?. 1225 * 1226 * @param id the primary key of the current journal article 1227 * @param structureId the structure ID 1228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1229 * @return the previous, current, and next journal article 1230 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1231 * @throws SystemException if a system exception occurred 1232 */ 1233 public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext( 1234 long id, java.lang.String structureId, 1235 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1236 throws com.liferay.portal.kernel.exception.SystemException, 1237 com.liferay.portlet.journal.NoSuchArticleException { 1238 return getPersistence() 1239 .findByStructureId_PrevAndNext(id, structureId, 1240 orderByComparator); 1241 } 1242 1243 /** 1244 * Returns all the journal articles where structureId = any ?. 1245 * 1246 * <p> 1247 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1248 * </p> 1249 * 1250 * @param structureIds the structure IDs 1251 * @return the matching journal articles 1252 * @throws SystemException if a system exception occurred 1253 */ 1254 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1255 java.lang.String[] structureIds) 1256 throws com.liferay.portal.kernel.exception.SystemException { 1257 return getPersistence().findByStructureId(structureIds); 1258 } 1259 1260 /** 1261 * Returns a range of all the journal articles where structureId = any ?. 1262 * 1263 * <p> 1264 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1265 * </p> 1266 * 1267 * @param structureIds the structure IDs 1268 * @param start the lower bound of the range of journal articles 1269 * @param end the upper bound of the range of journal articles (not inclusive) 1270 * @return the range of matching journal articles 1271 * @throws SystemException if a system exception occurred 1272 */ 1273 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1274 java.lang.String[] structureIds, int start, int end) 1275 throws com.liferay.portal.kernel.exception.SystemException { 1276 return getPersistence().findByStructureId(structureIds, start, end); 1277 } 1278 1279 /** 1280 * Returns an ordered range of all the journal articles where structureId = any ?. 1281 * 1282 * <p> 1283 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1284 * </p> 1285 * 1286 * @param structureIds the structure IDs 1287 * @param start the lower bound of the range of journal articles 1288 * @param end the upper bound of the range of journal articles (not inclusive) 1289 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1290 * @return the ordered range of matching journal articles 1291 * @throws SystemException if a system exception occurred 1292 */ 1293 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1294 java.lang.String[] structureIds, int start, int end, 1295 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1296 throws com.liferay.portal.kernel.exception.SystemException { 1297 return getPersistence() 1298 .findByStructureId(structureIds, start, end, 1299 orderByComparator); 1300 } 1301 1302 /** 1303 * Removes all the journal articles where structureId = ? from the database. 1304 * 1305 * @param structureId the structure ID 1306 * @throws SystemException if a system exception occurred 1307 */ 1308 public static void removeByStructureId(java.lang.String structureId) 1309 throws com.liferay.portal.kernel.exception.SystemException { 1310 getPersistence().removeByStructureId(structureId); 1311 } 1312 1313 /** 1314 * Returns the number of journal articles where structureId = ?. 1315 * 1316 * @param structureId the structure ID 1317 * @return the number of matching journal articles 1318 * @throws SystemException if a system exception occurred 1319 */ 1320 public static int countByStructureId(java.lang.String structureId) 1321 throws com.liferay.portal.kernel.exception.SystemException { 1322 return getPersistence().countByStructureId(structureId); 1323 } 1324 1325 /** 1326 * Returns the number of journal articles where structureId = any ?. 1327 * 1328 * @param structureIds the structure IDs 1329 * @return the number of matching journal articles 1330 * @throws SystemException if a system exception occurred 1331 */ 1332 public static int countByStructureId(java.lang.String[] structureIds) 1333 throws com.liferay.portal.kernel.exception.SystemException { 1334 return getPersistence().countByStructureId(structureIds); 1335 } 1336 1337 /** 1338 * Returns all the journal articles where templateId = ?. 1339 * 1340 * @param templateId the template ID 1341 * @return the matching journal articles 1342 * @throws SystemException if a system exception occurred 1343 */ 1344 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1345 java.lang.String templateId) 1346 throws com.liferay.portal.kernel.exception.SystemException { 1347 return getPersistence().findByTemplateId(templateId); 1348 } 1349 1350 /** 1351 * Returns a range of all the journal articles where templateId = ?. 1352 * 1353 * <p> 1354 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1355 * </p> 1356 * 1357 * @param templateId the template ID 1358 * @param start the lower bound of the range of journal articles 1359 * @param end the upper bound of the range of journal articles (not inclusive) 1360 * @return the range of matching journal articles 1361 * @throws SystemException if a system exception occurred 1362 */ 1363 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1364 java.lang.String templateId, int start, int end) 1365 throws com.liferay.portal.kernel.exception.SystemException { 1366 return getPersistence().findByTemplateId(templateId, start, end); 1367 } 1368 1369 /** 1370 * Returns an ordered range of all the journal articles where templateId = ?. 1371 * 1372 * <p> 1373 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1374 * </p> 1375 * 1376 * @param templateId the template ID 1377 * @param start the lower bound of the range of journal articles 1378 * @param end the upper bound of the range of journal articles (not inclusive) 1379 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1380 * @return the ordered range of matching journal articles 1381 * @throws SystemException if a system exception occurred 1382 */ 1383 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1384 java.lang.String templateId, int start, int end, 1385 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1386 throws com.liferay.portal.kernel.exception.SystemException { 1387 return getPersistence() 1388 .findByTemplateId(templateId, start, end, orderByComparator); 1389 } 1390 1391 /** 1392 * Returns the first journal article in the ordered set where templateId = ?. 1393 * 1394 * @param templateId the template ID 1395 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1396 * @return the first matching journal article 1397 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1398 * @throws SystemException if a system exception occurred 1399 */ 1400 public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First( 1401 java.lang.String templateId, 1402 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1403 throws com.liferay.portal.kernel.exception.SystemException, 1404 com.liferay.portlet.journal.NoSuchArticleException { 1405 return getPersistence() 1406 .findByTemplateId_First(templateId, orderByComparator); 1407 } 1408 1409 /** 1410 * Returns the first journal article in the ordered set where templateId = ?. 1411 * 1412 * @param templateId the template ID 1413 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1414 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1415 * @throws SystemException if a system exception occurred 1416 */ 1417 public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First( 1418 java.lang.String templateId, 1419 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1420 throws com.liferay.portal.kernel.exception.SystemException { 1421 return getPersistence() 1422 .fetchByTemplateId_First(templateId, orderByComparator); 1423 } 1424 1425 /** 1426 * Returns the last journal article in the ordered set where templateId = ?. 1427 * 1428 * @param templateId the template ID 1429 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1430 * @return the last matching journal article 1431 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1432 * @throws SystemException if a system exception occurred 1433 */ 1434 public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last( 1435 java.lang.String templateId, 1436 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1437 throws com.liferay.portal.kernel.exception.SystemException, 1438 com.liferay.portlet.journal.NoSuchArticleException { 1439 return getPersistence() 1440 .findByTemplateId_Last(templateId, orderByComparator); 1441 } 1442 1443 /** 1444 * Returns the last journal article in the ordered set where templateId = ?. 1445 * 1446 * @param templateId the template ID 1447 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1448 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1449 * @throws SystemException if a system exception occurred 1450 */ 1451 public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last( 1452 java.lang.String templateId, 1453 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1454 throws com.liferay.portal.kernel.exception.SystemException { 1455 return getPersistence() 1456 .fetchByTemplateId_Last(templateId, orderByComparator); 1457 } 1458 1459 /** 1460 * Returns the journal articles before and after the current journal article in the ordered set where templateId = ?. 1461 * 1462 * @param id the primary key of the current journal article 1463 * @param templateId the template ID 1464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1465 * @return the previous, current, and next journal article 1466 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1467 * @throws SystemException if a system exception occurred 1468 */ 1469 public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext( 1470 long id, java.lang.String templateId, 1471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1472 throws com.liferay.portal.kernel.exception.SystemException, 1473 com.liferay.portlet.journal.NoSuchArticleException { 1474 return getPersistence() 1475 .findByTemplateId_PrevAndNext(id, templateId, 1476 orderByComparator); 1477 } 1478 1479 /** 1480 * Removes all the journal articles where templateId = ? from the database. 1481 * 1482 * @param templateId the template ID 1483 * @throws SystemException if a system exception occurred 1484 */ 1485 public static void removeByTemplateId(java.lang.String templateId) 1486 throws com.liferay.portal.kernel.exception.SystemException { 1487 getPersistence().removeByTemplateId(templateId); 1488 } 1489 1490 /** 1491 * Returns the number of journal articles where templateId = ?. 1492 * 1493 * @param templateId the template ID 1494 * @return the number of matching journal articles 1495 * @throws SystemException if a system exception occurred 1496 */ 1497 public static int countByTemplateId(java.lang.String templateId) 1498 throws com.liferay.portal.kernel.exception.SystemException { 1499 return getPersistence().countByTemplateId(templateId); 1500 } 1501 1502 /** 1503 * Returns all the journal articles where layoutUuid = ?. 1504 * 1505 * @param layoutUuid the layout uuid 1506 * @return the matching journal articles 1507 * @throws SystemException if a system exception occurred 1508 */ 1509 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1510 java.lang.String layoutUuid) 1511 throws com.liferay.portal.kernel.exception.SystemException { 1512 return getPersistence().findByLayoutUuid(layoutUuid); 1513 } 1514 1515 /** 1516 * Returns a range of all the journal articles where layoutUuid = ?. 1517 * 1518 * <p> 1519 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1520 * </p> 1521 * 1522 * @param layoutUuid the layout uuid 1523 * @param start the lower bound of the range of journal articles 1524 * @param end the upper bound of the range of journal articles (not inclusive) 1525 * @return the range of matching journal articles 1526 * @throws SystemException if a system exception occurred 1527 */ 1528 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1529 java.lang.String layoutUuid, int start, int end) 1530 throws com.liferay.portal.kernel.exception.SystemException { 1531 return getPersistence().findByLayoutUuid(layoutUuid, start, end); 1532 } 1533 1534 /** 1535 * Returns an ordered range of all the journal articles where layoutUuid = ?. 1536 * 1537 * <p> 1538 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1539 * </p> 1540 * 1541 * @param layoutUuid the layout uuid 1542 * @param start the lower bound of the range of journal articles 1543 * @param end the upper bound of the range of journal articles (not inclusive) 1544 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1545 * @return the ordered range of matching journal articles 1546 * @throws SystemException if a system exception occurred 1547 */ 1548 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1549 java.lang.String layoutUuid, int start, int end, 1550 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1551 throws com.liferay.portal.kernel.exception.SystemException { 1552 return getPersistence() 1553 .findByLayoutUuid(layoutUuid, start, end, orderByComparator); 1554 } 1555 1556 /** 1557 * Returns the first journal article in the ordered set where layoutUuid = ?. 1558 * 1559 * @param layoutUuid the layout uuid 1560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1561 * @return the first matching journal article 1562 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1563 * @throws SystemException if a system exception occurred 1564 */ 1565 public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First( 1566 java.lang.String layoutUuid, 1567 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1568 throws com.liferay.portal.kernel.exception.SystemException, 1569 com.liferay.portlet.journal.NoSuchArticleException { 1570 return getPersistence() 1571 .findByLayoutUuid_First(layoutUuid, orderByComparator); 1572 } 1573 1574 /** 1575 * Returns the first journal article in the ordered set where layoutUuid = ?. 1576 * 1577 * @param layoutUuid the layout uuid 1578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1579 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1580 * @throws SystemException if a system exception occurred 1581 */ 1582 public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First( 1583 java.lang.String layoutUuid, 1584 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1585 throws com.liferay.portal.kernel.exception.SystemException { 1586 return getPersistence() 1587 .fetchByLayoutUuid_First(layoutUuid, orderByComparator); 1588 } 1589 1590 /** 1591 * Returns the last journal article in the ordered set where layoutUuid = ?. 1592 * 1593 * @param layoutUuid the layout uuid 1594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1595 * @return the last matching journal article 1596 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1597 * @throws SystemException if a system exception occurred 1598 */ 1599 public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last( 1600 java.lang.String layoutUuid, 1601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1602 throws com.liferay.portal.kernel.exception.SystemException, 1603 com.liferay.portlet.journal.NoSuchArticleException { 1604 return getPersistence() 1605 .findByLayoutUuid_Last(layoutUuid, orderByComparator); 1606 } 1607 1608 /** 1609 * Returns the last journal article in the ordered set where layoutUuid = ?. 1610 * 1611 * @param layoutUuid the layout uuid 1612 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1613 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1614 * @throws SystemException if a system exception occurred 1615 */ 1616 public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last( 1617 java.lang.String layoutUuid, 1618 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1619 throws com.liferay.portal.kernel.exception.SystemException { 1620 return getPersistence() 1621 .fetchByLayoutUuid_Last(layoutUuid, orderByComparator); 1622 } 1623 1624 /** 1625 * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = ?. 1626 * 1627 * @param id the primary key of the current journal article 1628 * @param layoutUuid the layout uuid 1629 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1630 * @return the previous, current, and next journal article 1631 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1632 * @throws SystemException if a system exception occurred 1633 */ 1634 public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext( 1635 long id, java.lang.String layoutUuid, 1636 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1637 throws com.liferay.portal.kernel.exception.SystemException, 1638 com.liferay.portlet.journal.NoSuchArticleException { 1639 return getPersistence() 1640 .findByLayoutUuid_PrevAndNext(id, layoutUuid, 1641 orderByComparator); 1642 } 1643 1644 /** 1645 * Removes all the journal articles where layoutUuid = ? from the database. 1646 * 1647 * @param layoutUuid the layout uuid 1648 * @throws SystemException if a system exception occurred 1649 */ 1650 public static void removeByLayoutUuid(java.lang.String layoutUuid) 1651 throws com.liferay.portal.kernel.exception.SystemException { 1652 getPersistence().removeByLayoutUuid(layoutUuid); 1653 } 1654 1655 /** 1656 * Returns the number of journal articles where layoutUuid = ?. 1657 * 1658 * @param layoutUuid the layout uuid 1659 * @return the number of matching journal articles 1660 * @throws SystemException if a system exception occurred 1661 */ 1662 public static int countByLayoutUuid(java.lang.String layoutUuid) 1663 throws com.liferay.portal.kernel.exception.SystemException { 1664 return getPersistence().countByLayoutUuid(layoutUuid); 1665 } 1666 1667 /** 1668 * Returns all the journal articles where smallImageId = ?. 1669 * 1670 * @param smallImageId the small image ID 1671 * @return the matching journal articles 1672 * @throws SystemException if a system exception occurred 1673 */ 1674 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1675 long smallImageId) 1676 throws com.liferay.portal.kernel.exception.SystemException { 1677 return getPersistence().findBySmallImageId(smallImageId); 1678 } 1679 1680 /** 1681 * Returns a range of all the journal articles where smallImageId = ?. 1682 * 1683 * <p> 1684 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1685 * </p> 1686 * 1687 * @param smallImageId the small image ID 1688 * @param start the lower bound of the range of journal articles 1689 * @param end the upper bound of the range of journal articles (not inclusive) 1690 * @return the range of matching journal articles 1691 * @throws SystemException if a system exception occurred 1692 */ 1693 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1694 long smallImageId, int start, int end) 1695 throws com.liferay.portal.kernel.exception.SystemException { 1696 return getPersistence().findBySmallImageId(smallImageId, start, end); 1697 } 1698 1699 /** 1700 * Returns an ordered range of all the journal articles where smallImageId = ?. 1701 * 1702 * <p> 1703 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1704 * </p> 1705 * 1706 * @param smallImageId the small image ID 1707 * @param start the lower bound of the range of journal articles 1708 * @param end the upper bound of the range of journal articles (not inclusive) 1709 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1710 * @return the ordered range of matching journal articles 1711 * @throws SystemException if a system exception occurred 1712 */ 1713 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1714 long smallImageId, int start, int end, 1715 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1716 throws com.liferay.portal.kernel.exception.SystemException { 1717 return getPersistence() 1718 .findBySmallImageId(smallImageId, start, end, 1719 orderByComparator); 1720 } 1721 1722 /** 1723 * Returns the first journal article in the ordered set where smallImageId = ?. 1724 * 1725 * @param smallImageId the small image ID 1726 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1727 * @return the first matching journal article 1728 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1729 * @throws SystemException if a system exception occurred 1730 */ 1731 public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First( 1732 long smallImageId, 1733 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1734 throws com.liferay.portal.kernel.exception.SystemException, 1735 com.liferay.portlet.journal.NoSuchArticleException { 1736 return getPersistence() 1737 .findBySmallImageId_First(smallImageId, orderByComparator); 1738 } 1739 1740 /** 1741 * Returns the first journal article in the ordered set where smallImageId = ?. 1742 * 1743 * @param smallImageId the small image ID 1744 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1745 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1746 * @throws SystemException if a system exception occurred 1747 */ 1748 public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First( 1749 long smallImageId, 1750 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1751 throws com.liferay.portal.kernel.exception.SystemException { 1752 return getPersistence() 1753 .fetchBySmallImageId_First(smallImageId, orderByComparator); 1754 } 1755 1756 /** 1757 * Returns the last journal article in the ordered set where smallImageId = ?. 1758 * 1759 * @param smallImageId the small image ID 1760 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1761 * @return the last matching journal article 1762 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1763 * @throws SystemException if a system exception occurred 1764 */ 1765 public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last( 1766 long smallImageId, 1767 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1768 throws com.liferay.portal.kernel.exception.SystemException, 1769 com.liferay.portlet.journal.NoSuchArticleException { 1770 return getPersistence() 1771 .findBySmallImageId_Last(smallImageId, orderByComparator); 1772 } 1773 1774 /** 1775 * Returns the last journal article in the ordered set where smallImageId = ?. 1776 * 1777 * @param smallImageId the small image ID 1778 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1779 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1780 * @throws SystemException if a system exception occurred 1781 */ 1782 public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last( 1783 long smallImageId, 1784 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1785 throws com.liferay.portal.kernel.exception.SystemException { 1786 return getPersistence() 1787 .fetchBySmallImageId_Last(smallImageId, orderByComparator); 1788 } 1789 1790 /** 1791 * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = ?. 1792 * 1793 * @param id the primary key of the current journal article 1794 * @param smallImageId the small image ID 1795 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1796 * @return the previous, current, and next journal article 1797 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1798 * @throws SystemException if a system exception occurred 1799 */ 1800 public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext( 1801 long id, long smallImageId, 1802 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1803 throws com.liferay.portal.kernel.exception.SystemException, 1804 com.liferay.portlet.journal.NoSuchArticleException { 1805 return getPersistence() 1806 .findBySmallImageId_PrevAndNext(id, smallImageId, 1807 orderByComparator); 1808 } 1809 1810 /** 1811 * Removes all the journal articles where smallImageId = ? from the database. 1812 * 1813 * @param smallImageId the small image ID 1814 * @throws SystemException if a system exception occurred 1815 */ 1816 public static void removeBySmallImageId(long smallImageId) 1817 throws com.liferay.portal.kernel.exception.SystemException { 1818 getPersistence().removeBySmallImageId(smallImageId); 1819 } 1820 1821 /** 1822 * Returns the number of journal articles where smallImageId = ?. 1823 * 1824 * @param smallImageId the small image ID 1825 * @return the number of matching journal articles 1826 * @throws SystemException if a system exception occurred 1827 */ 1828 public static int countBySmallImageId(long smallImageId) 1829 throws com.liferay.portal.kernel.exception.SystemException { 1830 return getPersistence().countBySmallImageId(smallImageId); 1831 } 1832 1833 /** 1834 * Returns all the journal articles where resourcePrimKey = ? and status = ?. 1835 * 1836 * @param resourcePrimKey the resource prim key 1837 * @param status the status 1838 * @return the matching journal articles 1839 * @throws SystemException if a system exception occurred 1840 */ 1841 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 1842 long resourcePrimKey, int status) 1843 throws com.liferay.portal.kernel.exception.SystemException { 1844 return getPersistence().findByR_ST(resourcePrimKey, status); 1845 } 1846 1847 /** 1848 * Returns a range of all the journal articles where resourcePrimKey = ? and status = ?. 1849 * 1850 * <p> 1851 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1852 * </p> 1853 * 1854 * @param resourcePrimKey the resource prim key 1855 * @param status the status 1856 * @param start the lower bound of the range of journal articles 1857 * @param end the upper bound of the range of journal articles (not inclusive) 1858 * @return the range of matching journal articles 1859 * @throws SystemException if a system exception occurred 1860 */ 1861 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 1862 long resourcePrimKey, int status, int start, int end) 1863 throws com.liferay.portal.kernel.exception.SystemException { 1864 return getPersistence().findByR_ST(resourcePrimKey, status, start, end); 1865 } 1866 1867 /** 1868 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and status = ?. 1869 * 1870 * <p> 1871 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1872 * </p> 1873 * 1874 * @param resourcePrimKey the resource prim key 1875 * @param status the status 1876 * @param start the lower bound of the range of journal articles 1877 * @param end the upper bound of the range of journal articles (not inclusive) 1878 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1879 * @return the ordered range of matching journal articles 1880 * @throws SystemException if a system exception occurred 1881 */ 1882 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 1883 long resourcePrimKey, int status, int start, int end, 1884 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1885 throws com.liferay.portal.kernel.exception.SystemException { 1886 return getPersistence() 1887 .findByR_ST(resourcePrimKey, status, start, end, 1888 orderByComparator); 1889 } 1890 1891 /** 1892 * Returns the first journal article in the ordered set where resourcePrimKey = ? and status = ?. 1893 * 1894 * @param resourcePrimKey the resource prim key 1895 * @param status the status 1896 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1897 * @return the first matching journal article 1898 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1899 * @throws SystemException if a system exception occurred 1900 */ 1901 public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First( 1902 long resourcePrimKey, int status, 1903 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1904 throws com.liferay.portal.kernel.exception.SystemException, 1905 com.liferay.portlet.journal.NoSuchArticleException { 1906 return getPersistence() 1907 .findByR_ST_First(resourcePrimKey, status, orderByComparator); 1908 } 1909 1910 /** 1911 * Returns the first journal article in the ordered set where resourcePrimKey = ? and status = ?. 1912 * 1913 * @param resourcePrimKey the resource prim key 1914 * @param status the status 1915 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1916 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1917 * @throws SystemException if a system exception occurred 1918 */ 1919 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First( 1920 long resourcePrimKey, int status, 1921 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1922 throws com.liferay.portal.kernel.exception.SystemException { 1923 return getPersistence() 1924 .fetchByR_ST_First(resourcePrimKey, status, orderByComparator); 1925 } 1926 1927 /** 1928 * Returns the last journal article in the ordered set where resourcePrimKey = ? and status = ?. 1929 * 1930 * @param resourcePrimKey the resource prim key 1931 * @param status the status 1932 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1933 * @return the last matching journal article 1934 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1935 * @throws SystemException if a system exception occurred 1936 */ 1937 public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last( 1938 long resourcePrimKey, int status, 1939 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1940 throws com.liferay.portal.kernel.exception.SystemException, 1941 com.liferay.portlet.journal.NoSuchArticleException { 1942 return getPersistence() 1943 .findByR_ST_Last(resourcePrimKey, status, orderByComparator); 1944 } 1945 1946 /** 1947 * Returns the last journal article in the ordered set where resourcePrimKey = ? and status = ?. 1948 * 1949 * @param resourcePrimKey the resource prim key 1950 * @param status the status 1951 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1952 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1953 * @throws SystemException if a system exception occurred 1954 */ 1955 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last( 1956 long resourcePrimKey, int status, 1957 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1958 throws com.liferay.portal.kernel.exception.SystemException { 1959 return getPersistence() 1960 .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator); 1961 } 1962 1963 /** 1964 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and status = ?. 1965 * 1966 * @param id the primary key of the current journal article 1967 * @param resourcePrimKey the resource prim key 1968 * @param status the status 1969 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1970 * @return the previous, current, and next journal article 1971 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1972 * @throws SystemException if a system exception occurred 1973 */ 1974 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext( 1975 long id, long resourcePrimKey, int status, 1976 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1977 throws com.liferay.portal.kernel.exception.SystemException, 1978 com.liferay.portlet.journal.NoSuchArticleException { 1979 return getPersistence() 1980 .findByR_ST_PrevAndNext(id, resourcePrimKey, status, 1981 orderByComparator); 1982 } 1983 1984 /** 1985 * Removes all the journal articles where resourcePrimKey = ? and status = ? from the database. 1986 * 1987 * @param resourcePrimKey the resource prim key 1988 * @param status the status 1989 * @throws SystemException if a system exception occurred 1990 */ 1991 public static void removeByR_ST(long resourcePrimKey, int status) 1992 throws com.liferay.portal.kernel.exception.SystemException { 1993 getPersistence().removeByR_ST(resourcePrimKey, status); 1994 } 1995 1996 /** 1997 * Returns the number of journal articles where resourcePrimKey = ? and status = ?. 1998 * 1999 * @param resourcePrimKey the resource prim key 2000 * @param status the status 2001 * @return the number of matching journal articles 2002 * @throws SystemException if a system exception occurred 2003 */ 2004 public static int countByR_ST(long resourcePrimKey, int status) 2005 throws com.liferay.portal.kernel.exception.SystemException { 2006 return getPersistence().countByR_ST(resourcePrimKey, status); 2007 } 2008 2009 /** 2010 * Returns all the journal articles where groupId = ? and userId = ?. 2011 * 2012 * @param groupId the group ID 2013 * @param userId the user ID 2014 * @return the matching journal articles 2015 * @throws SystemException if a system exception occurred 2016 */ 2017 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2018 long groupId, long userId) 2019 throws com.liferay.portal.kernel.exception.SystemException { 2020 return getPersistence().findByG_U(groupId, userId); 2021 } 2022 2023 /** 2024 * Returns a range of all the journal articles where groupId = ? and userId = ?. 2025 * 2026 * <p> 2027 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2028 * </p> 2029 * 2030 * @param groupId the group ID 2031 * @param userId the user ID 2032 * @param start the lower bound of the range of journal articles 2033 * @param end the upper bound of the range of journal articles (not inclusive) 2034 * @return the range of matching journal articles 2035 * @throws SystemException if a system exception occurred 2036 */ 2037 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2038 long groupId, long userId, int start, int end) 2039 throws com.liferay.portal.kernel.exception.SystemException { 2040 return getPersistence().findByG_U(groupId, userId, start, end); 2041 } 2042 2043 /** 2044 * Returns an ordered range of all the journal articles where groupId = ? and userId = ?. 2045 * 2046 * <p> 2047 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2048 * </p> 2049 * 2050 * @param groupId the group ID 2051 * @param userId the user ID 2052 * @param start the lower bound of the range of journal articles 2053 * @param end the upper bound of the range of journal articles (not inclusive) 2054 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2055 * @return the ordered range of matching journal articles 2056 * @throws SystemException if a system exception occurred 2057 */ 2058 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2059 long groupId, long userId, int start, int end, 2060 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2061 throws com.liferay.portal.kernel.exception.SystemException { 2062 return getPersistence() 2063 .findByG_U(groupId, userId, start, end, orderByComparator); 2064 } 2065 2066 /** 2067 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2068 * 2069 * @param groupId the group ID 2070 * @param userId the user ID 2071 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2072 * @return the first matching journal article 2073 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2074 * @throws SystemException if a system exception occurred 2075 */ 2076 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First( 2077 long groupId, long userId, 2078 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2079 throws com.liferay.portal.kernel.exception.SystemException, 2080 com.liferay.portlet.journal.NoSuchArticleException { 2081 return getPersistence() 2082 .findByG_U_First(groupId, userId, orderByComparator); 2083 } 2084 2085 /** 2086 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2087 * 2088 * @param groupId the group ID 2089 * @param userId the user ID 2090 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2091 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2092 * @throws SystemException if a system exception occurred 2093 */ 2094 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First( 2095 long groupId, long userId, 2096 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2097 throws com.liferay.portal.kernel.exception.SystemException { 2098 return getPersistence() 2099 .fetchByG_U_First(groupId, userId, orderByComparator); 2100 } 2101 2102 /** 2103 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2104 * 2105 * @param groupId the group ID 2106 * @param userId the user ID 2107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2108 * @return the last matching journal article 2109 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2110 * @throws SystemException if a system exception occurred 2111 */ 2112 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last( 2113 long groupId, long userId, 2114 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2115 throws com.liferay.portal.kernel.exception.SystemException, 2116 com.liferay.portlet.journal.NoSuchArticleException { 2117 return getPersistence() 2118 .findByG_U_Last(groupId, userId, orderByComparator); 2119 } 2120 2121 /** 2122 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2123 * 2124 * @param groupId the group ID 2125 * @param userId the user ID 2126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2127 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2128 * @throws SystemException if a system exception occurred 2129 */ 2130 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last( 2131 long groupId, long userId, 2132 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2133 throws com.liferay.portal.kernel.exception.SystemException { 2134 return getPersistence() 2135 .fetchByG_U_Last(groupId, userId, orderByComparator); 2136 } 2137 2138 /** 2139 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ?. 2140 * 2141 * @param id the primary key of the current journal article 2142 * @param groupId the group ID 2143 * @param userId the user ID 2144 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2145 * @return the previous, current, and next journal article 2146 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2147 * @throws SystemException if a system exception occurred 2148 */ 2149 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext( 2150 long id, long groupId, long userId, 2151 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2152 throws com.liferay.portal.kernel.exception.SystemException, 2153 com.liferay.portlet.journal.NoSuchArticleException { 2154 return getPersistence() 2155 .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator); 2156 } 2157 2158 /** 2159 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2160 * 2161 * @param groupId the group ID 2162 * @param userId the user ID 2163 * @return the matching journal articles that the user has permission to view 2164 * @throws SystemException if a system exception occurred 2165 */ 2166 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2167 long groupId, long userId) 2168 throws com.liferay.portal.kernel.exception.SystemException { 2169 return getPersistence().filterFindByG_U(groupId, userId); 2170 } 2171 2172 /** 2173 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2174 * 2175 * <p> 2176 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2177 * </p> 2178 * 2179 * @param groupId the group ID 2180 * @param userId the user ID 2181 * @param start the lower bound of the range of journal articles 2182 * @param end the upper bound of the range of journal articles (not inclusive) 2183 * @return the range of matching journal articles that the user has permission to view 2184 * @throws SystemException if a system exception occurred 2185 */ 2186 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2187 long groupId, long userId, int start, int end) 2188 throws com.liferay.portal.kernel.exception.SystemException { 2189 return getPersistence().filterFindByG_U(groupId, userId, start, end); 2190 } 2191 2192 /** 2193 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ?. 2194 * 2195 * <p> 2196 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2197 * </p> 2198 * 2199 * @param groupId the group ID 2200 * @param userId the user ID 2201 * @param start the lower bound of the range of journal articles 2202 * @param end the upper bound of the range of journal articles (not inclusive) 2203 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2204 * @return the ordered range of matching journal articles that the user has permission to view 2205 * @throws SystemException if a system exception occurred 2206 */ 2207 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2208 long groupId, long userId, int start, int end, 2209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2210 throws com.liferay.portal.kernel.exception.SystemException { 2211 return getPersistence() 2212 .filterFindByG_U(groupId, userId, start, end, 2213 orderByComparator); 2214 } 2215 2216 /** 2217 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and userId = ?. 2218 * 2219 * @param id the primary key of the current journal article 2220 * @param groupId the group ID 2221 * @param userId the user ID 2222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2223 * @return the previous, current, and next journal article 2224 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2225 * @throws SystemException if a system exception occurred 2226 */ 2227 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext( 2228 long id, long groupId, long userId, 2229 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2230 throws com.liferay.portal.kernel.exception.SystemException, 2231 com.liferay.portlet.journal.NoSuchArticleException { 2232 return getPersistence() 2233 .filterFindByG_U_PrevAndNext(id, groupId, userId, 2234 orderByComparator); 2235 } 2236 2237 /** 2238 * Removes all the journal articles where groupId = ? and userId = ? from the database. 2239 * 2240 * @param groupId the group ID 2241 * @param userId the user ID 2242 * @throws SystemException if a system exception occurred 2243 */ 2244 public static void removeByG_U(long groupId, long userId) 2245 throws com.liferay.portal.kernel.exception.SystemException { 2246 getPersistence().removeByG_U(groupId, userId); 2247 } 2248 2249 /** 2250 * Returns the number of journal articles where groupId = ? and userId = ?. 2251 * 2252 * @param groupId the group ID 2253 * @param userId the user ID 2254 * @return the number of matching journal articles 2255 * @throws SystemException if a system exception occurred 2256 */ 2257 public static int countByG_U(long groupId, long userId) 2258 throws com.liferay.portal.kernel.exception.SystemException { 2259 return getPersistence().countByG_U(groupId, userId); 2260 } 2261 2262 /** 2263 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ?. 2264 * 2265 * @param groupId the group ID 2266 * @param userId the user ID 2267 * @return the number of matching journal articles that the user has permission to view 2268 * @throws SystemException if a system exception occurred 2269 */ 2270 public static int filterCountByG_U(long groupId, long userId) 2271 throws com.liferay.portal.kernel.exception.SystemException { 2272 return getPersistence().filterCountByG_U(groupId, userId); 2273 } 2274 2275 /** 2276 * Returns all the journal articles where groupId = ? and folderId = ?. 2277 * 2278 * @param groupId the group ID 2279 * @param folderId the folder ID 2280 * @return the matching journal articles 2281 * @throws SystemException if a system exception occurred 2282 */ 2283 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2284 long groupId, long folderId) 2285 throws com.liferay.portal.kernel.exception.SystemException { 2286 return getPersistence().findByG_F(groupId, folderId); 2287 } 2288 2289 /** 2290 * Returns a range of all the journal articles where groupId = ? and folderId = ?. 2291 * 2292 * <p> 2293 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2294 * </p> 2295 * 2296 * @param groupId the group ID 2297 * @param folderId the folder ID 2298 * @param start the lower bound of the range of journal articles 2299 * @param end the upper bound of the range of journal articles (not inclusive) 2300 * @return the range of matching journal articles 2301 * @throws SystemException if a system exception occurred 2302 */ 2303 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2304 long groupId, long folderId, int start, int end) 2305 throws com.liferay.portal.kernel.exception.SystemException { 2306 return getPersistence().findByG_F(groupId, folderId, start, end); 2307 } 2308 2309 /** 2310 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ?. 2311 * 2312 * <p> 2313 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2314 * </p> 2315 * 2316 * @param groupId the group ID 2317 * @param folderId the folder ID 2318 * @param start the lower bound of the range of journal articles 2319 * @param end the upper bound of the range of journal articles (not inclusive) 2320 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2321 * @return the ordered range of matching journal articles 2322 * @throws SystemException if a system exception occurred 2323 */ 2324 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2325 long groupId, long folderId, int start, int end, 2326 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2327 throws com.liferay.portal.kernel.exception.SystemException { 2328 return getPersistence() 2329 .findByG_F(groupId, folderId, start, end, orderByComparator); 2330 } 2331 2332 /** 2333 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2334 * 2335 * @param groupId the group ID 2336 * @param folderId the folder ID 2337 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2338 * @return the first matching journal article 2339 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2340 * @throws SystemException if a system exception occurred 2341 */ 2342 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First( 2343 long groupId, long folderId, 2344 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2345 throws com.liferay.portal.kernel.exception.SystemException, 2346 com.liferay.portlet.journal.NoSuchArticleException { 2347 return getPersistence() 2348 .findByG_F_First(groupId, folderId, orderByComparator); 2349 } 2350 2351 /** 2352 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2353 * 2354 * @param groupId the group ID 2355 * @param folderId the folder ID 2356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2357 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2358 * @throws SystemException if a system exception occurred 2359 */ 2360 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First( 2361 long groupId, long folderId, 2362 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2363 throws com.liferay.portal.kernel.exception.SystemException { 2364 return getPersistence() 2365 .fetchByG_F_First(groupId, folderId, orderByComparator); 2366 } 2367 2368 /** 2369 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2370 * 2371 * @param groupId the group ID 2372 * @param folderId the folder ID 2373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2374 * @return the last matching journal article 2375 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2376 * @throws SystemException if a system exception occurred 2377 */ 2378 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last( 2379 long groupId, long folderId, 2380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2381 throws com.liferay.portal.kernel.exception.SystemException, 2382 com.liferay.portlet.journal.NoSuchArticleException { 2383 return getPersistence() 2384 .findByG_F_Last(groupId, folderId, orderByComparator); 2385 } 2386 2387 /** 2388 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2389 * 2390 * @param groupId the group ID 2391 * @param folderId the folder ID 2392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2393 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2394 * @throws SystemException if a system exception occurred 2395 */ 2396 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last( 2397 long groupId, long folderId, 2398 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2399 throws com.liferay.portal.kernel.exception.SystemException { 2400 return getPersistence() 2401 .fetchByG_F_Last(groupId, folderId, orderByComparator); 2402 } 2403 2404 /** 2405 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ?. 2406 * 2407 * @param id the primary key of the current journal article 2408 * @param groupId the group ID 2409 * @param folderId the folder ID 2410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2411 * @return the previous, current, and next journal article 2412 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2413 * @throws SystemException if a system exception occurred 2414 */ 2415 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext( 2416 long id, long groupId, long folderId, 2417 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2418 throws com.liferay.portal.kernel.exception.SystemException, 2419 com.liferay.portlet.journal.NoSuchArticleException { 2420 return getPersistence() 2421 .findByG_F_PrevAndNext(id, groupId, folderId, 2422 orderByComparator); 2423 } 2424 2425 /** 2426 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2427 * 2428 * @param groupId the group ID 2429 * @param folderId the folder ID 2430 * @return the matching journal articles that the user has permission to view 2431 * @throws SystemException if a system exception occurred 2432 */ 2433 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2434 long groupId, long folderId) 2435 throws com.liferay.portal.kernel.exception.SystemException { 2436 return getPersistence().filterFindByG_F(groupId, folderId); 2437 } 2438 2439 /** 2440 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2441 * 2442 * <p> 2443 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2444 * </p> 2445 * 2446 * @param groupId the group ID 2447 * @param folderId the folder ID 2448 * @param start the lower bound of the range of journal articles 2449 * @param end the upper bound of the range of journal articles (not inclusive) 2450 * @return the range of matching journal articles that the user has permission to view 2451 * @throws SystemException if a system exception occurred 2452 */ 2453 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2454 long groupId, long folderId, int start, int end) 2455 throws com.liferay.portal.kernel.exception.SystemException { 2456 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 2457 } 2458 2459 /** 2460 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ?. 2461 * 2462 * <p> 2463 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2464 * </p> 2465 * 2466 * @param groupId the group ID 2467 * @param folderId the folder ID 2468 * @param start the lower bound of the range of journal articles 2469 * @param end the upper bound of the range of journal articles (not inclusive) 2470 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2471 * @return the ordered range of matching journal articles that the user has permission to view 2472 * @throws SystemException if a system exception occurred 2473 */ 2474 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2475 long groupId, long folderId, int start, int end, 2476 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2477 throws com.liferay.portal.kernel.exception.SystemException { 2478 return getPersistence() 2479 .filterFindByG_F(groupId, folderId, start, end, 2480 orderByComparator); 2481 } 2482 2483 /** 2484 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and folderId = ?. 2485 * 2486 * @param id the primary key of the current journal article 2487 * @param groupId the group ID 2488 * @param folderId the folder ID 2489 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2490 * @return the previous, current, and next journal article 2491 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2492 * @throws SystemException if a system exception occurred 2493 */ 2494 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext( 2495 long id, long groupId, long folderId, 2496 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2497 throws com.liferay.portal.kernel.exception.SystemException, 2498 com.liferay.portlet.journal.NoSuchArticleException { 2499 return getPersistence() 2500 .filterFindByG_F_PrevAndNext(id, groupId, folderId, 2501 orderByComparator); 2502 } 2503 2504 /** 2505 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2506 * 2507 * @param groupId the group ID 2508 * @param folderIds the folder IDs 2509 * @return the matching journal articles that the user has permission to view 2510 * @throws SystemException if a system exception occurred 2511 */ 2512 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2513 long groupId, long[] folderIds) 2514 throws com.liferay.portal.kernel.exception.SystemException { 2515 return getPersistence().filterFindByG_F(groupId, folderIds); 2516 } 2517 2518 /** 2519 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2520 * 2521 * <p> 2522 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2523 * </p> 2524 * 2525 * @param groupId the group ID 2526 * @param folderIds the folder IDs 2527 * @param start the lower bound of the range of journal articles 2528 * @param end the upper bound of the range of journal articles (not inclusive) 2529 * @return the range of matching journal articles that the user has permission to view 2530 * @throws SystemException if a system exception occurred 2531 */ 2532 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2533 long groupId, long[] folderIds, int start, int end) 2534 throws com.liferay.portal.kernel.exception.SystemException { 2535 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 2536 } 2537 2538 /** 2539 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2540 * 2541 * <p> 2542 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2543 * </p> 2544 * 2545 * @param groupId the group ID 2546 * @param folderIds the folder IDs 2547 * @param start the lower bound of the range of journal articles 2548 * @param end the upper bound of the range of journal articles (not inclusive) 2549 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2550 * @return the ordered range of matching journal articles that the user has permission to view 2551 * @throws SystemException if a system exception occurred 2552 */ 2553 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2554 long groupId, long[] folderIds, int start, int end, 2555 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2556 throws com.liferay.portal.kernel.exception.SystemException { 2557 return getPersistence() 2558 .filterFindByG_F(groupId, folderIds, start, end, 2559 orderByComparator); 2560 } 2561 2562 /** 2563 * Returns all the journal articles where groupId = ? and folderId = any ?. 2564 * 2565 * <p> 2566 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2567 * </p> 2568 * 2569 * @param groupId the group ID 2570 * @param folderIds the folder IDs 2571 * @return the matching journal articles 2572 * @throws SystemException if a system exception occurred 2573 */ 2574 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2575 long groupId, long[] folderIds) 2576 throws com.liferay.portal.kernel.exception.SystemException { 2577 return getPersistence().findByG_F(groupId, folderIds); 2578 } 2579 2580 /** 2581 * Returns a range of all the journal articles where groupId = ? and folderId = any ?. 2582 * 2583 * <p> 2584 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2585 * </p> 2586 * 2587 * @param groupId the group ID 2588 * @param folderIds the folder IDs 2589 * @param start the lower bound of the range of journal articles 2590 * @param end the upper bound of the range of journal articles (not inclusive) 2591 * @return the range of matching journal articles 2592 * @throws SystemException if a system exception occurred 2593 */ 2594 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2595 long groupId, long[] folderIds, int start, int end) 2596 throws com.liferay.portal.kernel.exception.SystemException { 2597 return getPersistence().findByG_F(groupId, folderIds, start, end); 2598 } 2599 2600 /** 2601 * Returns an ordered range of all the journal articles where groupId = ? and folderId = any ?. 2602 * 2603 * <p> 2604 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2605 * </p> 2606 * 2607 * @param groupId the group ID 2608 * @param folderIds the folder IDs 2609 * @param start the lower bound of the range of journal articles 2610 * @param end the upper bound of the range of journal articles (not inclusive) 2611 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2612 * @return the ordered range of matching journal articles 2613 * @throws SystemException if a system exception occurred 2614 */ 2615 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2616 long groupId, long[] folderIds, int start, int end, 2617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2618 throws com.liferay.portal.kernel.exception.SystemException { 2619 return getPersistence() 2620 .findByG_F(groupId, folderIds, start, end, orderByComparator); 2621 } 2622 2623 /** 2624 * Removes all the journal articles where groupId = ? and folderId = ? from the database. 2625 * 2626 * @param groupId the group ID 2627 * @param folderId the folder ID 2628 * @throws SystemException if a system exception occurred 2629 */ 2630 public static void removeByG_F(long groupId, long folderId) 2631 throws com.liferay.portal.kernel.exception.SystemException { 2632 getPersistence().removeByG_F(groupId, folderId); 2633 } 2634 2635 /** 2636 * Returns the number of journal articles where groupId = ? and folderId = ?. 2637 * 2638 * @param groupId the group ID 2639 * @param folderId the folder ID 2640 * @return the number of matching journal articles 2641 * @throws SystemException if a system exception occurred 2642 */ 2643 public static int countByG_F(long groupId, long folderId) 2644 throws com.liferay.portal.kernel.exception.SystemException { 2645 return getPersistence().countByG_F(groupId, folderId); 2646 } 2647 2648 /** 2649 * Returns the number of journal articles where groupId = ? and folderId = any ?. 2650 * 2651 * @param groupId the group ID 2652 * @param folderIds the folder IDs 2653 * @return the number of matching journal articles 2654 * @throws SystemException if a system exception occurred 2655 */ 2656 public static int countByG_F(long groupId, long[] folderIds) 2657 throws com.liferay.portal.kernel.exception.SystemException { 2658 return getPersistence().countByG_F(groupId, folderIds); 2659 } 2660 2661 /** 2662 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ?. 2663 * 2664 * @param groupId the group ID 2665 * @param folderId the folder ID 2666 * @return the number of matching journal articles that the user has permission to view 2667 * @throws SystemException if a system exception occurred 2668 */ 2669 public static int filterCountByG_F(long groupId, long folderId) 2670 throws com.liferay.portal.kernel.exception.SystemException { 2671 return getPersistence().filterCountByG_F(groupId, folderId); 2672 } 2673 2674 /** 2675 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2676 * 2677 * @param groupId the group ID 2678 * @param folderIds the folder IDs 2679 * @return the number of matching journal articles that the user has permission to view 2680 * @throws SystemException if a system exception occurred 2681 */ 2682 public static int filterCountByG_F(long groupId, long[] folderIds) 2683 throws com.liferay.portal.kernel.exception.SystemException { 2684 return getPersistence().filterCountByG_F(groupId, folderIds); 2685 } 2686 2687 /** 2688 * Returns all the journal articles where groupId = ? and articleId = ?. 2689 * 2690 * @param groupId the group ID 2691 * @param articleId the article ID 2692 * @return the matching journal articles 2693 * @throws SystemException if a system exception occurred 2694 */ 2695 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2696 long groupId, java.lang.String articleId) 2697 throws com.liferay.portal.kernel.exception.SystemException { 2698 return getPersistence().findByG_A(groupId, articleId); 2699 } 2700 2701 /** 2702 * Returns a range of all the journal articles where groupId = ? and articleId = ?. 2703 * 2704 * <p> 2705 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2706 * </p> 2707 * 2708 * @param groupId the group ID 2709 * @param articleId the article ID 2710 * @param start the lower bound of the range of journal articles 2711 * @param end the upper bound of the range of journal articles (not inclusive) 2712 * @return the range of matching journal articles 2713 * @throws SystemException if a system exception occurred 2714 */ 2715 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2716 long groupId, java.lang.String articleId, int start, int end) 2717 throws com.liferay.portal.kernel.exception.SystemException { 2718 return getPersistence().findByG_A(groupId, articleId, start, end); 2719 } 2720 2721 /** 2722 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ?. 2723 * 2724 * <p> 2725 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2726 * </p> 2727 * 2728 * @param groupId the group ID 2729 * @param articleId the article ID 2730 * @param start the lower bound of the range of journal articles 2731 * @param end the upper bound of the range of journal articles (not inclusive) 2732 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2733 * @return the ordered range of matching journal articles 2734 * @throws SystemException if a system exception occurred 2735 */ 2736 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2737 long groupId, java.lang.String articleId, int start, int end, 2738 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2739 throws com.liferay.portal.kernel.exception.SystemException { 2740 return getPersistence() 2741 .findByG_A(groupId, articleId, start, end, orderByComparator); 2742 } 2743 2744 /** 2745 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 2746 * 2747 * @param groupId the group ID 2748 * @param articleId the article ID 2749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2750 * @return the first matching journal article 2751 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2752 * @throws SystemException if a system exception occurred 2753 */ 2754 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First( 2755 long groupId, java.lang.String articleId, 2756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2757 throws com.liferay.portal.kernel.exception.SystemException, 2758 com.liferay.portlet.journal.NoSuchArticleException { 2759 return getPersistence() 2760 .findByG_A_First(groupId, articleId, orderByComparator); 2761 } 2762 2763 /** 2764 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 2765 * 2766 * @param groupId the group ID 2767 * @param articleId the article ID 2768 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2769 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2770 * @throws SystemException if a system exception occurred 2771 */ 2772 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First( 2773 long groupId, java.lang.String articleId, 2774 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2775 throws com.liferay.portal.kernel.exception.SystemException { 2776 return getPersistence() 2777 .fetchByG_A_First(groupId, articleId, orderByComparator); 2778 } 2779 2780 /** 2781 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 2782 * 2783 * @param groupId the group ID 2784 * @param articleId the article ID 2785 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2786 * @return the last matching journal article 2787 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2788 * @throws SystemException if a system exception occurred 2789 */ 2790 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last( 2791 long groupId, java.lang.String articleId, 2792 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2793 throws com.liferay.portal.kernel.exception.SystemException, 2794 com.liferay.portlet.journal.NoSuchArticleException { 2795 return getPersistence() 2796 .findByG_A_Last(groupId, articleId, orderByComparator); 2797 } 2798 2799 /** 2800 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 2801 * 2802 * @param groupId the group ID 2803 * @param articleId the article ID 2804 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2805 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2806 * @throws SystemException if a system exception occurred 2807 */ 2808 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last( 2809 long groupId, java.lang.String articleId, 2810 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2811 throws com.liferay.portal.kernel.exception.SystemException { 2812 return getPersistence() 2813 .fetchByG_A_Last(groupId, articleId, orderByComparator); 2814 } 2815 2816 /** 2817 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ?. 2818 * 2819 * @param id the primary key of the current journal article 2820 * @param groupId the group ID 2821 * @param articleId the article ID 2822 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2823 * @return the previous, current, and next journal article 2824 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2825 * @throws SystemException if a system exception occurred 2826 */ 2827 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext( 2828 long id, long groupId, java.lang.String articleId, 2829 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2830 throws com.liferay.portal.kernel.exception.SystemException, 2831 com.liferay.portlet.journal.NoSuchArticleException { 2832 return getPersistence() 2833 .findByG_A_PrevAndNext(id, groupId, articleId, 2834 orderByComparator); 2835 } 2836 2837 /** 2838 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 2839 * 2840 * @param groupId the group ID 2841 * @param articleId the article ID 2842 * @return the matching journal articles that the user has permission to view 2843 * @throws SystemException if a system exception occurred 2844 */ 2845 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 2846 long groupId, java.lang.String articleId) 2847 throws com.liferay.portal.kernel.exception.SystemException { 2848 return getPersistence().filterFindByG_A(groupId, articleId); 2849 } 2850 2851 /** 2852 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 2853 * 2854 * <p> 2855 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2856 * </p> 2857 * 2858 * @param groupId the group ID 2859 * @param articleId the article ID 2860 * @param start the lower bound of the range of journal articles 2861 * @param end the upper bound of the range of journal articles (not inclusive) 2862 * @return the range of matching journal articles that the user has permission to view 2863 * @throws SystemException if a system exception occurred 2864 */ 2865 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 2866 long groupId, java.lang.String articleId, int start, int end) 2867 throws com.liferay.portal.kernel.exception.SystemException { 2868 return getPersistence().filterFindByG_A(groupId, articleId, start, end); 2869 } 2870 2871 /** 2872 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ?. 2873 * 2874 * <p> 2875 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2876 * </p> 2877 * 2878 * @param groupId the group ID 2879 * @param articleId the article ID 2880 * @param start the lower bound of the range of journal articles 2881 * @param end the upper bound of the range of journal articles (not inclusive) 2882 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2883 * @return the ordered range of matching journal articles that the user has permission to view 2884 * @throws SystemException if a system exception occurred 2885 */ 2886 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 2887 long groupId, java.lang.String articleId, int start, int end, 2888 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2889 throws com.liferay.portal.kernel.exception.SystemException { 2890 return getPersistence() 2891 .filterFindByG_A(groupId, articleId, start, end, 2892 orderByComparator); 2893 } 2894 2895 /** 2896 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and articleId = ?. 2897 * 2898 * @param id the primary key of the current journal article 2899 * @param groupId the group ID 2900 * @param articleId the article ID 2901 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2902 * @return the previous, current, and next journal article 2903 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2904 * @throws SystemException if a system exception occurred 2905 */ 2906 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext( 2907 long id, long groupId, java.lang.String articleId, 2908 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2909 throws com.liferay.portal.kernel.exception.SystemException, 2910 com.liferay.portlet.journal.NoSuchArticleException { 2911 return getPersistence() 2912 .filterFindByG_A_PrevAndNext(id, groupId, articleId, 2913 orderByComparator); 2914 } 2915 2916 /** 2917 * Removes all the journal articles where groupId = ? and articleId = ? from the database. 2918 * 2919 * @param groupId the group ID 2920 * @param articleId the article ID 2921 * @throws SystemException if a system exception occurred 2922 */ 2923 public static void removeByG_A(long groupId, java.lang.String articleId) 2924 throws com.liferay.portal.kernel.exception.SystemException { 2925 getPersistence().removeByG_A(groupId, articleId); 2926 } 2927 2928 /** 2929 * Returns the number of journal articles where groupId = ? and articleId = ?. 2930 * 2931 * @param groupId the group ID 2932 * @param articleId the article ID 2933 * @return the number of matching journal articles 2934 * @throws SystemException if a system exception occurred 2935 */ 2936 public static int countByG_A(long groupId, java.lang.String articleId) 2937 throws com.liferay.portal.kernel.exception.SystemException { 2938 return getPersistence().countByG_A(groupId, articleId); 2939 } 2940 2941 /** 2942 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ?. 2943 * 2944 * @param groupId the group ID 2945 * @param articleId the article ID 2946 * @return the number of matching journal articles that the user has permission to view 2947 * @throws SystemException if a system exception occurred 2948 */ 2949 public static int filterCountByG_A(long groupId, java.lang.String articleId) 2950 throws com.liferay.portal.kernel.exception.SystemException { 2951 return getPersistence().filterCountByG_A(groupId, articleId); 2952 } 2953 2954 /** 2955 * Returns all the journal articles where groupId = ? and urlTitle = ?. 2956 * 2957 * @param groupId the group ID 2958 * @param urlTitle the url title 2959 * @return the matching journal articles 2960 * @throws SystemException if a system exception occurred 2961 */ 2962 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 2963 long groupId, java.lang.String urlTitle) 2964 throws com.liferay.portal.kernel.exception.SystemException { 2965 return getPersistence().findByG_UT(groupId, urlTitle); 2966 } 2967 2968 /** 2969 * Returns a range of all the journal articles where groupId = ? and urlTitle = ?. 2970 * 2971 * <p> 2972 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2973 * </p> 2974 * 2975 * @param groupId the group ID 2976 * @param urlTitle the url title 2977 * @param start the lower bound of the range of journal articles 2978 * @param end the upper bound of the range of journal articles (not inclusive) 2979 * @return the range of matching journal articles 2980 * @throws SystemException if a system exception occurred 2981 */ 2982 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 2983 long groupId, java.lang.String urlTitle, int start, int end) 2984 throws com.liferay.portal.kernel.exception.SystemException { 2985 return getPersistence().findByG_UT(groupId, urlTitle, start, end); 2986 } 2987 2988 /** 2989 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ?. 2990 * 2991 * <p> 2992 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2993 * </p> 2994 * 2995 * @param groupId the group ID 2996 * @param urlTitle the url title 2997 * @param start the lower bound of the range of journal articles 2998 * @param end the upper bound of the range of journal articles (not inclusive) 2999 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3000 * @return the ordered range of matching journal articles 3001 * @throws SystemException if a system exception occurred 3002 */ 3003 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3004 long groupId, java.lang.String urlTitle, int start, int end, 3005 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3006 throws com.liferay.portal.kernel.exception.SystemException { 3007 return getPersistence() 3008 .findByG_UT(groupId, urlTitle, start, end, orderByComparator); 3009 } 3010 3011 /** 3012 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3013 * 3014 * @param groupId the group ID 3015 * @param urlTitle the url title 3016 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3017 * @return the first matching journal article 3018 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3019 * @throws SystemException if a system exception occurred 3020 */ 3021 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First( 3022 long groupId, java.lang.String urlTitle, 3023 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3024 throws com.liferay.portal.kernel.exception.SystemException, 3025 com.liferay.portlet.journal.NoSuchArticleException { 3026 return getPersistence() 3027 .findByG_UT_First(groupId, urlTitle, orderByComparator); 3028 } 3029 3030 /** 3031 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3032 * 3033 * @param groupId the group ID 3034 * @param urlTitle the url title 3035 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3036 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3037 * @throws SystemException if a system exception occurred 3038 */ 3039 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First( 3040 long groupId, java.lang.String urlTitle, 3041 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3042 throws com.liferay.portal.kernel.exception.SystemException { 3043 return getPersistence() 3044 .fetchByG_UT_First(groupId, urlTitle, orderByComparator); 3045 } 3046 3047 /** 3048 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3049 * 3050 * @param groupId the group ID 3051 * @param urlTitle the url title 3052 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3053 * @return the last matching journal article 3054 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3055 * @throws SystemException if a system exception occurred 3056 */ 3057 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last( 3058 long groupId, java.lang.String urlTitle, 3059 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3060 throws com.liferay.portal.kernel.exception.SystemException, 3061 com.liferay.portlet.journal.NoSuchArticleException { 3062 return getPersistence() 3063 .findByG_UT_Last(groupId, urlTitle, orderByComparator); 3064 } 3065 3066 /** 3067 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3068 * 3069 * @param groupId the group ID 3070 * @param urlTitle the url title 3071 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3072 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3073 * @throws SystemException if a system exception occurred 3074 */ 3075 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last( 3076 long groupId, java.lang.String urlTitle, 3077 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3078 throws com.liferay.portal.kernel.exception.SystemException { 3079 return getPersistence() 3080 .fetchByG_UT_Last(groupId, urlTitle, orderByComparator); 3081 } 3082 3083 /** 3084 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ?. 3085 * 3086 * @param id the primary key of the current journal article 3087 * @param groupId the group ID 3088 * @param urlTitle the url title 3089 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3090 * @return the previous, current, and next journal article 3091 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3092 * @throws SystemException if a system exception occurred 3093 */ 3094 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext( 3095 long id, long groupId, java.lang.String urlTitle, 3096 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3097 throws com.liferay.portal.kernel.exception.SystemException, 3098 com.liferay.portlet.journal.NoSuchArticleException { 3099 return getPersistence() 3100 .findByG_UT_PrevAndNext(id, groupId, urlTitle, 3101 orderByComparator); 3102 } 3103 3104 /** 3105 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3106 * 3107 * @param groupId the group ID 3108 * @param urlTitle the url title 3109 * @return the matching journal articles that the user has permission to view 3110 * @throws SystemException if a system exception occurred 3111 */ 3112 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3113 long groupId, java.lang.String urlTitle) 3114 throws com.liferay.portal.kernel.exception.SystemException { 3115 return getPersistence().filterFindByG_UT(groupId, urlTitle); 3116 } 3117 3118 /** 3119 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3120 * 3121 * <p> 3122 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3123 * </p> 3124 * 3125 * @param groupId the group ID 3126 * @param urlTitle the url title 3127 * @param start the lower bound of the range of journal articles 3128 * @param end the upper bound of the range of journal articles (not inclusive) 3129 * @return the range of matching journal articles that the user has permission to view 3130 * @throws SystemException if a system exception occurred 3131 */ 3132 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3133 long groupId, java.lang.String urlTitle, int start, int end) 3134 throws com.liferay.portal.kernel.exception.SystemException { 3135 return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end); 3136 } 3137 3138 /** 3139 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ?. 3140 * 3141 * <p> 3142 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3143 * </p> 3144 * 3145 * @param groupId the group ID 3146 * @param urlTitle the url title 3147 * @param start the lower bound of the range of journal articles 3148 * @param end the upper bound of the range of journal articles (not inclusive) 3149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3150 * @return the ordered range of matching journal articles that the user has permission to view 3151 * @throws SystemException if a system exception occurred 3152 */ 3153 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3154 long groupId, java.lang.String urlTitle, int start, int end, 3155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3156 throws com.liferay.portal.kernel.exception.SystemException { 3157 return getPersistence() 3158 .filterFindByG_UT(groupId, urlTitle, start, end, 3159 orderByComparator); 3160 } 3161 3162 /** 3163 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3164 * 3165 * @param id the primary key of the current journal article 3166 * @param groupId the group ID 3167 * @param urlTitle the url title 3168 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3169 * @return the previous, current, and next journal article 3170 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3171 * @throws SystemException if a system exception occurred 3172 */ 3173 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext( 3174 long id, long groupId, java.lang.String urlTitle, 3175 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3176 throws com.liferay.portal.kernel.exception.SystemException, 3177 com.liferay.portlet.journal.NoSuchArticleException { 3178 return getPersistence() 3179 .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle, 3180 orderByComparator); 3181 } 3182 3183 /** 3184 * Removes all the journal articles where groupId = ? and urlTitle = ? from the database. 3185 * 3186 * @param groupId the group ID 3187 * @param urlTitle the url title 3188 * @throws SystemException if a system exception occurred 3189 */ 3190 public static void removeByG_UT(long groupId, java.lang.String urlTitle) 3191 throws com.liferay.portal.kernel.exception.SystemException { 3192 getPersistence().removeByG_UT(groupId, urlTitle); 3193 } 3194 3195 /** 3196 * Returns the number of journal articles where groupId = ? and urlTitle = ?. 3197 * 3198 * @param groupId the group ID 3199 * @param urlTitle the url title 3200 * @return the number of matching journal articles 3201 * @throws SystemException if a system exception occurred 3202 */ 3203 public static int countByG_UT(long groupId, java.lang.String urlTitle) 3204 throws com.liferay.portal.kernel.exception.SystemException { 3205 return getPersistence().countByG_UT(groupId, urlTitle); 3206 } 3207 3208 /** 3209 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3210 * 3211 * @param groupId the group ID 3212 * @param urlTitle the url title 3213 * @return the number of matching journal articles that the user has permission to view 3214 * @throws SystemException if a system exception occurred 3215 */ 3216 public static int filterCountByG_UT(long groupId, java.lang.String urlTitle) 3217 throws com.liferay.portal.kernel.exception.SystemException { 3218 return getPersistence().filterCountByG_UT(groupId, urlTitle); 3219 } 3220 3221 /** 3222 * Returns all the journal articles where groupId = ? and structureId = ?. 3223 * 3224 * @param groupId the group ID 3225 * @param structureId the structure ID 3226 * @return the matching journal articles 3227 * @throws SystemException if a system exception occurred 3228 */ 3229 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3230 long groupId, java.lang.String structureId) 3231 throws com.liferay.portal.kernel.exception.SystemException { 3232 return getPersistence().findByG_S(groupId, structureId); 3233 } 3234 3235 /** 3236 * Returns a range of all the journal articles where groupId = ? and structureId = ?. 3237 * 3238 * <p> 3239 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3240 * </p> 3241 * 3242 * @param groupId the group ID 3243 * @param structureId the structure ID 3244 * @param start the lower bound of the range of journal articles 3245 * @param end the upper bound of the range of journal articles (not inclusive) 3246 * @return the range of matching journal articles 3247 * @throws SystemException if a system exception occurred 3248 */ 3249 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3250 long groupId, java.lang.String structureId, int start, int end) 3251 throws com.liferay.portal.kernel.exception.SystemException { 3252 return getPersistence().findByG_S(groupId, structureId, start, end); 3253 } 3254 3255 /** 3256 * Returns an ordered range of all the journal articles where groupId = ? and structureId = ?. 3257 * 3258 * <p> 3259 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3260 * </p> 3261 * 3262 * @param groupId the group ID 3263 * @param structureId the structure ID 3264 * @param start the lower bound of the range of journal articles 3265 * @param end the upper bound of the range of journal articles (not inclusive) 3266 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3267 * @return the ordered range of matching journal articles 3268 * @throws SystemException if a system exception occurred 3269 */ 3270 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3271 long groupId, java.lang.String structureId, int start, int end, 3272 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3273 throws com.liferay.portal.kernel.exception.SystemException { 3274 return getPersistence() 3275 .findByG_S(groupId, structureId, start, end, 3276 orderByComparator); 3277 } 3278 3279 /** 3280 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3281 * 3282 * @param groupId the group ID 3283 * @param structureId the structure ID 3284 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3285 * @return the first matching journal article 3286 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3287 * @throws SystemException if a system exception occurred 3288 */ 3289 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First( 3290 long groupId, java.lang.String structureId, 3291 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3292 throws com.liferay.portal.kernel.exception.SystemException, 3293 com.liferay.portlet.journal.NoSuchArticleException { 3294 return getPersistence() 3295 .findByG_S_First(groupId, structureId, orderByComparator); 3296 } 3297 3298 /** 3299 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3300 * 3301 * @param groupId the group ID 3302 * @param structureId the structure ID 3303 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3304 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3305 * @throws SystemException if a system exception occurred 3306 */ 3307 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First( 3308 long groupId, java.lang.String structureId, 3309 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3310 throws com.liferay.portal.kernel.exception.SystemException { 3311 return getPersistence() 3312 .fetchByG_S_First(groupId, structureId, orderByComparator); 3313 } 3314 3315 /** 3316 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3317 * 3318 * @param groupId the group ID 3319 * @param structureId the structure ID 3320 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3321 * @return the last matching journal article 3322 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3323 * @throws SystemException if a system exception occurred 3324 */ 3325 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last( 3326 long groupId, java.lang.String structureId, 3327 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3328 throws com.liferay.portal.kernel.exception.SystemException, 3329 com.liferay.portlet.journal.NoSuchArticleException { 3330 return getPersistence() 3331 .findByG_S_Last(groupId, structureId, orderByComparator); 3332 } 3333 3334 /** 3335 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3336 * 3337 * @param groupId the group ID 3338 * @param structureId the structure ID 3339 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3340 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3341 * @throws SystemException if a system exception occurred 3342 */ 3343 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last( 3344 long groupId, java.lang.String structureId, 3345 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3346 throws com.liferay.portal.kernel.exception.SystemException { 3347 return getPersistence() 3348 .fetchByG_S_Last(groupId, structureId, orderByComparator); 3349 } 3350 3351 /** 3352 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and structureId = ?. 3353 * 3354 * @param id the primary key of the current journal article 3355 * @param groupId the group ID 3356 * @param structureId the structure ID 3357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3358 * @return the previous, current, and next journal article 3359 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3360 * @throws SystemException if a system exception occurred 3361 */ 3362 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext( 3363 long id, long groupId, java.lang.String structureId, 3364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3365 throws com.liferay.portal.kernel.exception.SystemException, 3366 com.liferay.portlet.journal.NoSuchArticleException { 3367 return getPersistence() 3368 .findByG_S_PrevAndNext(id, groupId, structureId, 3369 orderByComparator); 3370 } 3371 3372 /** 3373 * Returns all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3374 * 3375 * @param groupId the group ID 3376 * @param structureId the structure ID 3377 * @return the matching journal articles that the user has permission to view 3378 * @throws SystemException if a system exception occurred 3379 */ 3380 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3381 long groupId, java.lang.String structureId) 3382 throws com.liferay.portal.kernel.exception.SystemException { 3383 return getPersistence().filterFindByG_S(groupId, structureId); 3384 } 3385 3386 /** 3387 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3388 * 3389 * <p> 3390 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3391 * </p> 3392 * 3393 * @param groupId the group ID 3394 * @param structureId the structure ID 3395 * @param start the lower bound of the range of journal articles 3396 * @param end the upper bound of the range of journal articles (not inclusive) 3397 * @return the range of matching journal articles that the user has permission to view 3398 * @throws SystemException if a system exception occurred 3399 */ 3400 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3401 long groupId, java.lang.String structureId, int start, int end) 3402 throws com.liferay.portal.kernel.exception.SystemException { 3403 return getPersistence().filterFindByG_S(groupId, structureId, start, end); 3404 } 3405 3406 /** 3407 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and structureId = ?. 3408 * 3409 * <p> 3410 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3411 * </p> 3412 * 3413 * @param groupId the group ID 3414 * @param structureId the structure ID 3415 * @param start the lower bound of the range of journal articles 3416 * @param end the upper bound of the range of journal articles (not inclusive) 3417 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3418 * @return the ordered range of matching journal articles that the user has permission to view 3419 * @throws SystemException if a system exception occurred 3420 */ 3421 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3422 long groupId, java.lang.String structureId, int start, int end, 3423 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3424 throws com.liferay.portal.kernel.exception.SystemException { 3425 return getPersistence() 3426 .filterFindByG_S(groupId, structureId, start, end, 3427 orderByComparator); 3428 } 3429 3430 /** 3431 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and structureId = ?. 3432 * 3433 * @param id the primary key of the current journal article 3434 * @param groupId the group ID 3435 * @param structureId the structure ID 3436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3437 * @return the previous, current, and next journal article 3438 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3439 * @throws SystemException if a system exception occurred 3440 */ 3441 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext( 3442 long id, long groupId, java.lang.String structureId, 3443 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3444 throws com.liferay.portal.kernel.exception.SystemException, 3445 com.liferay.portlet.journal.NoSuchArticleException { 3446 return getPersistence() 3447 .filterFindByG_S_PrevAndNext(id, groupId, structureId, 3448 orderByComparator); 3449 } 3450 3451 /** 3452 * Removes all the journal articles where groupId = ? and structureId = ? from the database. 3453 * 3454 * @param groupId the group ID 3455 * @param structureId the structure ID 3456 * @throws SystemException if a system exception occurred 3457 */ 3458 public static void removeByG_S(long groupId, java.lang.String structureId) 3459 throws com.liferay.portal.kernel.exception.SystemException { 3460 getPersistence().removeByG_S(groupId, structureId); 3461 } 3462 3463 /** 3464 * Returns the number of journal articles where groupId = ? and structureId = ?. 3465 * 3466 * @param groupId the group ID 3467 * @param structureId the structure ID 3468 * @return the number of matching journal articles 3469 * @throws SystemException if a system exception occurred 3470 */ 3471 public static int countByG_S(long groupId, java.lang.String structureId) 3472 throws com.liferay.portal.kernel.exception.SystemException { 3473 return getPersistence().countByG_S(groupId, structureId); 3474 } 3475 3476 /** 3477 * Returns the number of journal articles that the user has permission to view where groupId = ? and structureId = ?. 3478 * 3479 * @param groupId the group ID 3480 * @param structureId the structure ID 3481 * @return the number of matching journal articles that the user has permission to view 3482 * @throws SystemException if a system exception occurred 3483 */ 3484 public static int filterCountByG_S(long groupId, 3485 java.lang.String structureId) 3486 throws com.liferay.portal.kernel.exception.SystemException { 3487 return getPersistence().filterCountByG_S(groupId, structureId); 3488 } 3489 3490 /** 3491 * Returns all the journal articles where groupId = ? and templateId = ?. 3492 * 3493 * @param groupId the group ID 3494 * @param templateId the template ID 3495 * @return the matching journal articles 3496 * @throws SystemException if a system exception occurred 3497 */ 3498 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3499 long groupId, java.lang.String templateId) 3500 throws com.liferay.portal.kernel.exception.SystemException { 3501 return getPersistence().findByG_T(groupId, templateId); 3502 } 3503 3504 /** 3505 * Returns a range of all the journal articles where groupId = ? and templateId = ?. 3506 * 3507 * <p> 3508 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3509 * </p> 3510 * 3511 * @param groupId the group ID 3512 * @param templateId the template ID 3513 * @param start the lower bound of the range of journal articles 3514 * @param end the upper bound of the range of journal articles (not inclusive) 3515 * @return the range of matching journal articles 3516 * @throws SystemException if a system exception occurred 3517 */ 3518 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3519 long groupId, java.lang.String templateId, int start, int end) 3520 throws com.liferay.portal.kernel.exception.SystemException { 3521 return getPersistence().findByG_T(groupId, templateId, start, end); 3522 } 3523 3524 /** 3525 * Returns an ordered range of all the journal articles where groupId = ? and templateId = ?. 3526 * 3527 * <p> 3528 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3529 * </p> 3530 * 3531 * @param groupId the group ID 3532 * @param templateId the template ID 3533 * @param start the lower bound of the range of journal articles 3534 * @param end the upper bound of the range of journal articles (not inclusive) 3535 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3536 * @return the ordered range of matching journal articles 3537 * @throws SystemException if a system exception occurred 3538 */ 3539 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3540 long groupId, java.lang.String templateId, int start, int end, 3541 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3542 throws com.liferay.portal.kernel.exception.SystemException { 3543 return getPersistence() 3544 .findByG_T(groupId, templateId, start, end, orderByComparator); 3545 } 3546 3547 /** 3548 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3549 * 3550 * @param groupId the group ID 3551 * @param templateId the template ID 3552 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3553 * @return the first matching journal article 3554 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3555 * @throws SystemException if a system exception occurred 3556 */ 3557 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First( 3558 long groupId, java.lang.String templateId, 3559 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3560 throws com.liferay.portal.kernel.exception.SystemException, 3561 com.liferay.portlet.journal.NoSuchArticleException { 3562 return getPersistence() 3563 .findByG_T_First(groupId, templateId, orderByComparator); 3564 } 3565 3566 /** 3567 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3568 * 3569 * @param groupId the group ID 3570 * @param templateId the template ID 3571 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3572 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3573 * @throws SystemException if a system exception occurred 3574 */ 3575 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First( 3576 long groupId, java.lang.String templateId, 3577 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3578 throws com.liferay.portal.kernel.exception.SystemException { 3579 return getPersistence() 3580 .fetchByG_T_First(groupId, templateId, orderByComparator); 3581 } 3582 3583 /** 3584 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3585 * 3586 * @param groupId the group ID 3587 * @param templateId the template ID 3588 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3589 * @return the last matching journal article 3590 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3591 * @throws SystemException if a system exception occurred 3592 */ 3593 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last( 3594 long groupId, java.lang.String templateId, 3595 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3596 throws com.liferay.portal.kernel.exception.SystemException, 3597 com.liferay.portlet.journal.NoSuchArticleException { 3598 return getPersistence() 3599 .findByG_T_Last(groupId, templateId, orderByComparator); 3600 } 3601 3602 /** 3603 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3604 * 3605 * @param groupId the group ID 3606 * @param templateId the template ID 3607 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3608 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3609 * @throws SystemException if a system exception occurred 3610 */ 3611 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last( 3612 long groupId, java.lang.String templateId, 3613 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3614 throws com.liferay.portal.kernel.exception.SystemException { 3615 return getPersistence() 3616 .fetchByG_T_Last(groupId, templateId, orderByComparator); 3617 } 3618 3619 /** 3620 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and templateId = ?. 3621 * 3622 * @param id the primary key of the current journal article 3623 * @param groupId the group ID 3624 * @param templateId the template ID 3625 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3626 * @return the previous, current, and next journal article 3627 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3628 * @throws SystemException if a system exception occurred 3629 */ 3630 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext( 3631 long id, long groupId, java.lang.String templateId, 3632 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3633 throws com.liferay.portal.kernel.exception.SystemException, 3634 com.liferay.portlet.journal.NoSuchArticleException { 3635 return getPersistence() 3636 .findByG_T_PrevAndNext(id, groupId, templateId, 3637 orderByComparator); 3638 } 3639 3640 /** 3641 * Returns all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3642 * 3643 * @param groupId the group ID 3644 * @param templateId the template ID 3645 * @return the matching journal articles that the user has permission to view 3646 * @throws SystemException if a system exception occurred 3647 */ 3648 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3649 long groupId, java.lang.String templateId) 3650 throws com.liferay.portal.kernel.exception.SystemException { 3651 return getPersistence().filterFindByG_T(groupId, templateId); 3652 } 3653 3654 /** 3655 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3656 * 3657 * <p> 3658 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3659 * </p> 3660 * 3661 * @param groupId the group ID 3662 * @param templateId the template ID 3663 * @param start the lower bound of the range of journal articles 3664 * @param end the upper bound of the range of journal articles (not inclusive) 3665 * @return the range of matching journal articles that the user has permission to view 3666 * @throws SystemException if a system exception occurred 3667 */ 3668 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3669 long groupId, java.lang.String templateId, int start, int end) 3670 throws com.liferay.portal.kernel.exception.SystemException { 3671 return getPersistence().filterFindByG_T(groupId, templateId, start, end); 3672 } 3673 3674 /** 3675 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and templateId = ?. 3676 * 3677 * <p> 3678 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3679 * </p> 3680 * 3681 * @param groupId the group ID 3682 * @param templateId the template ID 3683 * @param start the lower bound of the range of journal articles 3684 * @param end the upper bound of the range of journal articles (not inclusive) 3685 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3686 * @return the ordered range of matching journal articles that the user has permission to view 3687 * @throws SystemException if a system exception occurred 3688 */ 3689 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3690 long groupId, java.lang.String templateId, int start, int end, 3691 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3692 throws com.liferay.portal.kernel.exception.SystemException { 3693 return getPersistence() 3694 .filterFindByG_T(groupId, templateId, start, end, 3695 orderByComparator); 3696 } 3697 3698 /** 3699 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and templateId = ?. 3700 * 3701 * @param id the primary key of the current journal article 3702 * @param groupId the group ID 3703 * @param templateId the template ID 3704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3705 * @return the previous, current, and next journal article 3706 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3707 * @throws SystemException if a system exception occurred 3708 */ 3709 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext( 3710 long id, long groupId, java.lang.String templateId, 3711 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3712 throws com.liferay.portal.kernel.exception.SystemException, 3713 com.liferay.portlet.journal.NoSuchArticleException { 3714 return getPersistence() 3715 .filterFindByG_T_PrevAndNext(id, groupId, templateId, 3716 orderByComparator); 3717 } 3718 3719 /** 3720 * Removes all the journal articles where groupId = ? and templateId = ? from the database. 3721 * 3722 * @param groupId the group ID 3723 * @param templateId the template ID 3724 * @throws SystemException if a system exception occurred 3725 */ 3726 public static void removeByG_T(long groupId, java.lang.String templateId) 3727 throws com.liferay.portal.kernel.exception.SystemException { 3728 getPersistence().removeByG_T(groupId, templateId); 3729 } 3730 3731 /** 3732 * Returns the number of journal articles where groupId = ? and templateId = ?. 3733 * 3734 * @param groupId the group ID 3735 * @param templateId the template ID 3736 * @return the number of matching journal articles 3737 * @throws SystemException if a system exception occurred 3738 */ 3739 public static int countByG_T(long groupId, java.lang.String templateId) 3740 throws com.liferay.portal.kernel.exception.SystemException { 3741 return getPersistence().countByG_T(groupId, templateId); 3742 } 3743 3744 /** 3745 * Returns the number of journal articles that the user has permission to view where groupId = ? and templateId = ?. 3746 * 3747 * @param groupId the group ID 3748 * @param templateId the template ID 3749 * @return the number of matching journal articles that the user has permission to view 3750 * @throws SystemException if a system exception occurred 3751 */ 3752 public static int filterCountByG_T(long groupId, java.lang.String templateId) 3753 throws com.liferay.portal.kernel.exception.SystemException { 3754 return getPersistence().filterCountByG_T(groupId, templateId); 3755 } 3756 3757 /** 3758 * Returns all the journal articles where groupId = ? and layoutUuid = ?. 3759 * 3760 * @param groupId the group ID 3761 * @param layoutUuid the layout uuid 3762 * @return the matching journal articles 3763 * @throws SystemException if a system exception occurred 3764 */ 3765 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3766 long groupId, java.lang.String layoutUuid) 3767 throws com.liferay.portal.kernel.exception.SystemException { 3768 return getPersistence().findByG_L(groupId, layoutUuid); 3769 } 3770 3771 /** 3772 * Returns a range of all the journal articles where groupId = ? and layoutUuid = ?. 3773 * 3774 * <p> 3775 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3776 * </p> 3777 * 3778 * @param groupId the group ID 3779 * @param layoutUuid the layout uuid 3780 * @param start the lower bound of the range of journal articles 3781 * @param end the upper bound of the range of journal articles (not inclusive) 3782 * @return the range of matching journal articles 3783 * @throws SystemException if a system exception occurred 3784 */ 3785 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3786 long groupId, java.lang.String layoutUuid, int start, int end) 3787 throws com.liferay.portal.kernel.exception.SystemException { 3788 return getPersistence().findByG_L(groupId, layoutUuid, start, end); 3789 } 3790 3791 /** 3792 * Returns an ordered range of all the journal articles where groupId = ? and layoutUuid = ?. 3793 * 3794 * <p> 3795 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3796 * </p> 3797 * 3798 * @param groupId the group ID 3799 * @param layoutUuid the layout uuid 3800 * @param start the lower bound of the range of journal articles 3801 * @param end the upper bound of the range of journal articles (not inclusive) 3802 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3803 * @return the ordered range of matching journal articles 3804 * @throws SystemException if a system exception occurred 3805 */ 3806 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 3807 long groupId, java.lang.String layoutUuid, int start, int end, 3808 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3809 throws com.liferay.portal.kernel.exception.SystemException { 3810 return getPersistence() 3811 .findByG_L(groupId, layoutUuid, start, end, orderByComparator); 3812 } 3813 3814 /** 3815 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 3816 * 3817 * @param groupId the group ID 3818 * @param layoutUuid the layout uuid 3819 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3820 * @return the first matching journal article 3821 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3822 * @throws SystemException if a system exception occurred 3823 */ 3824 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First( 3825 long groupId, java.lang.String layoutUuid, 3826 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3827 throws com.liferay.portal.kernel.exception.SystemException, 3828 com.liferay.portlet.journal.NoSuchArticleException { 3829 return getPersistence() 3830 .findByG_L_First(groupId, layoutUuid, orderByComparator); 3831 } 3832 3833 /** 3834 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 3835 * 3836 * @param groupId the group ID 3837 * @param layoutUuid the layout uuid 3838 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3839 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3840 * @throws SystemException if a system exception occurred 3841 */ 3842 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First( 3843 long groupId, java.lang.String layoutUuid, 3844 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3845 throws com.liferay.portal.kernel.exception.SystemException { 3846 return getPersistence() 3847 .fetchByG_L_First(groupId, layoutUuid, orderByComparator); 3848 } 3849 3850 /** 3851 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 3852 * 3853 * @param groupId the group ID 3854 * @param layoutUuid the layout uuid 3855 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3856 * @return the last matching journal article 3857 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3858 * @throws SystemException if a system exception occurred 3859 */ 3860 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last( 3861 long groupId, java.lang.String layoutUuid, 3862 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3863 throws com.liferay.portal.kernel.exception.SystemException, 3864 com.liferay.portlet.journal.NoSuchArticleException { 3865 return getPersistence() 3866 .findByG_L_Last(groupId, layoutUuid, orderByComparator); 3867 } 3868 3869 /** 3870 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 3871 * 3872 * @param groupId the group ID 3873 * @param layoutUuid the layout uuid 3874 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3875 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3876 * @throws SystemException if a system exception occurred 3877 */ 3878 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last( 3879 long groupId, java.lang.String layoutUuid, 3880 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3881 throws com.liferay.portal.kernel.exception.SystemException { 3882 return getPersistence() 3883 .fetchByG_L_Last(groupId, layoutUuid, orderByComparator); 3884 } 3885 3886 /** 3887 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and layoutUuid = ?. 3888 * 3889 * @param id the primary key of the current journal article 3890 * @param groupId the group ID 3891 * @param layoutUuid the layout uuid 3892 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3893 * @return the previous, current, and next journal article 3894 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3895 * @throws SystemException if a system exception occurred 3896 */ 3897 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext( 3898 long id, long groupId, java.lang.String layoutUuid, 3899 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3900 throws com.liferay.portal.kernel.exception.SystemException, 3901 com.liferay.portlet.journal.NoSuchArticleException { 3902 return getPersistence() 3903 .findByG_L_PrevAndNext(id, groupId, layoutUuid, 3904 orderByComparator); 3905 } 3906 3907 /** 3908 * Returns all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 3909 * 3910 * @param groupId the group ID 3911 * @param layoutUuid the layout uuid 3912 * @return the matching journal articles that the user has permission to view 3913 * @throws SystemException if a system exception occurred 3914 */ 3915 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 3916 long groupId, java.lang.String layoutUuid) 3917 throws com.liferay.portal.kernel.exception.SystemException { 3918 return getPersistence().filterFindByG_L(groupId, layoutUuid); 3919 } 3920 3921 /** 3922 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 3923 * 3924 * <p> 3925 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3926 * </p> 3927 * 3928 * @param groupId the group ID 3929 * @param layoutUuid the layout uuid 3930 * @param start the lower bound of the range of journal articles 3931 * @param end the upper bound of the range of journal articles (not inclusive) 3932 * @return the range of matching journal articles that the user has permission to view 3933 * @throws SystemException if a system exception occurred 3934 */ 3935 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 3936 long groupId, java.lang.String layoutUuid, int start, int end) 3937 throws com.liferay.portal.kernel.exception.SystemException { 3938 return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end); 3939 } 3940 3941 /** 3942 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and layoutUuid = ?. 3943 * 3944 * <p> 3945 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3946 * </p> 3947 * 3948 * @param groupId the group ID 3949 * @param layoutUuid the layout uuid 3950 * @param start the lower bound of the range of journal articles 3951 * @param end the upper bound of the range of journal articles (not inclusive) 3952 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3953 * @return the ordered range of matching journal articles that the user has permission to view 3954 * @throws SystemException if a system exception occurred 3955 */ 3956 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 3957 long groupId, java.lang.String layoutUuid, int start, int end, 3958 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3959 throws com.liferay.portal.kernel.exception.SystemException { 3960 return getPersistence() 3961 .filterFindByG_L(groupId, layoutUuid, start, end, 3962 orderByComparator); 3963 } 3964 3965 /** 3966 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 3967 * 3968 * @param id the primary key of the current journal article 3969 * @param groupId the group ID 3970 * @param layoutUuid the layout uuid 3971 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3972 * @return the previous, current, and next journal article 3973 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3974 * @throws SystemException if a system exception occurred 3975 */ 3976 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext( 3977 long id, long groupId, java.lang.String layoutUuid, 3978 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3979 throws com.liferay.portal.kernel.exception.SystemException, 3980 com.liferay.portlet.journal.NoSuchArticleException { 3981 return getPersistence() 3982 .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid, 3983 orderByComparator); 3984 } 3985 3986 /** 3987 * Removes all the journal articles where groupId = ? and layoutUuid = ? from the database. 3988 * 3989 * @param groupId the group ID 3990 * @param layoutUuid the layout uuid 3991 * @throws SystemException if a system exception occurred 3992 */ 3993 public static void removeByG_L(long groupId, java.lang.String layoutUuid) 3994 throws com.liferay.portal.kernel.exception.SystemException { 3995 getPersistence().removeByG_L(groupId, layoutUuid); 3996 } 3997 3998 /** 3999 * Returns the number of journal articles where groupId = ? and layoutUuid = ?. 4000 * 4001 * @param groupId the group ID 4002 * @param layoutUuid the layout uuid 4003 * @return the number of matching journal articles 4004 * @throws SystemException if a system exception occurred 4005 */ 4006 public static int countByG_L(long groupId, java.lang.String layoutUuid) 4007 throws com.liferay.portal.kernel.exception.SystemException { 4008 return getPersistence().countByG_L(groupId, layoutUuid); 4009 } 4010 4011 /** 4012 * Returns the number of journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4013 * 4014 * @param groupId the group ID 4015 * @param layoutUuid the layout uuid 4016 * @return the number of matching journal articles that the user has permission to view 4017 * @throws SystemException if a system exception occurred 4018 */ 4019 public static int filterCountByG_L(long groupId, java.lang.String layoutUuid) 4020 throws com.liferay.portal.kernel.exception.SystemException { 4021 return getPersistence().filterCountByG_L(groupId, layoutUuid); 4022 } 4023 4024 /** 4025 * Returns all the journal articles where groupId = ? and status = ?. 4026 * 4027 * @param groupId the group ID 4028 * @param status the status 4029 * @return the matching journal articles 4030 * @throws SystemException if a system exception occurred 4031 */ 4032 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4033 long groupId, int status) 4034 throws com.liferay.portal.kernel.exception.SystemException { 4035 return getPersistence().findByG_ST(groupId, status); 4036 } 4037 4038 /** 4039 * Returns a range of all the journal articles where groupId = ? and status = ?. 4040 * 4041 * <p> 4042 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4043 * </p> 4044 * 4045 * @param groupId the group ID 4046 * @param status the status 4047 * @param start the lower bound of the range of journal articles 4048 * @param end the upper bound of the range of journal articles (not inclusive) 4049 * @return the range of matching journal articles 4050 * @throws SystemException if a system exception occurred 4051 */ 4052 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4053 long groupId, int status, int start, int end) 4054 throws com.liferay.portal.kernel.exception.SystemException { 4055 return getPersistence().findByG_ST(groupId, status, start, end); 4056 } 4057 4058 /** 4059 * Returns an ordered range of all the journal articles where groupId = ? and status = ?. 4060 * 4061 * <p> 4062 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4063 * </p> 4064 * 4065 * @param groupId the group ID 4066 * @param status the status 4067 * @param start the lower bound of the range of journal articles 4068 * @param end the upper bound of the range of journal articles (not inclusive) 4069 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4070 * @return the ordered range of matching journal articles 4071 * @throws SystemException if a system exception occurred 4072 */ 4073 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4074 long groupId, int status, int start, int end, 4075 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4076 throws com.liferay.portal.kernel.exception.SystemException { 4077 return getPersistence() 4078 .findByG_ST(groupId, status, start, end, orderByComparator); 4079 } 4080 4081 /** 4082 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4083 * 4084 * @param groupId the group ID 4085 * @param status the status 4086 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4087 * @return the first matching journal article 4088 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4089 * @throws SystemException if a system exception occurred 4090 */ 4091 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First( 4092 long groupId, int status, 4093 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4094 throws com.liferay.portal.kernel.exception.SystemException, 4095 com.liferay.portlet.journal.NoSuchArticleException { 4096 return getPersistence() 4097 .findByG_ST_First(groupId, status, orderByComparator); 4098 } 4099 4100 /** 4101 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4102 * 4103 * @param groupId the group ID 4104 * @param status the status 4105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4106 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4107 * @throws SystemException if a system exception occurred 4108 */ 4109 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First( 4110 long groupId, int status, 4111 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4112 throws com.liferay.portal.kernel.exception.SystemException { 4113 return getPersistence() 4114 .fetchByG_ST_First(groupId, status, orderByComparator); 4115 } 4116 4117 /** 4118 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4119 * 4120 * @param groupId the group ID 4121 * @param status the status 4122 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4123 * @return the last matching journal article 4124 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4125 * @throws SystemException if a system exception occurred 4126 */ 4127 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last( 4128 long groupId, int status, 4129 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4130 throws com.liferay.portal.kernel.exception.SystemException, 4131 com.liferay.portlet.journal.NoSuchArticleException { 4132 return getPersistence() 4133 .findByG_ST_Last(groupId, status, orderByComparator); 4134 } 4135 4136 /** 4137 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4138 * 4139 * @param groupId the group ID 4140 * @param status the status 4141 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4142 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4143 * @throws SystemException if a system exception occurred 4144 */ 4145 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last( 4146 long groupId, int status, 4147 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4148 throws com.liferay.portal.kernel.exception.SystemException { 4149 return getPersistence() 4150 .fetchByG_ST_Last(groupId, status, orderByComparator); 4151 } 4152 4153 /** 4154 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and status = ?. 4155 * 4156 * @param id the primary key of the current journal article 4157 * @param groupId the group ID 4158 * @param status the status 4159 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4160 * @return the previous, current, and next journal article 4161 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4162 * @throws SystemException if a system exception occurred 4163 */ 4164 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext( 4165 long id, long groupId, int status, 4166 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4167 throws com.liferay.portal.kernel.exception.SystemException, 4168 com.liferay.portlet.journal.NoSuchArticleException { 4169 return getPersistence() 4170 .findByG_ST_PrevAndNext(id, groupId, status, 4171 orderByComparator); 4172 } 4173 4174 /** 4175 * Returns all the journal articles that the user has permission to view where groupId = ? and status = ?. 4176 * 4177 * @param groupId the group ID 4178 * @param status the status 4179 * @return the matching journal articles that the user has permission to view 4180 * @throws SystemException if a system exception occurred 4181 */ 4182 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4183 long groupId, int status) 4184 throws com.liferay.portal.kernel.exception.SystemException { 4185 return getPersistence().filterFindByG_ST(groupId, status); 4186 } 4187 4188 /** 4189 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and status = ?. 4190 * 4191 * <p> 4192 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4193 * </p> 4194 * 4195 * @param groupId the group ID 4196 * @param status the status 4197 * @param start the lower bound of the range of journal articles 4198 * @param end the upper bound of the range of journal articles (not inclusive) 4199 * @return the range of matching journal articles that the user has permission to view 4200 * @throws SystemException if a system exception occurred 4201 */ 4202 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4203 long groupId, int status, int start, int end) 4204 throws com.liferay.portal.kernel.exception.SystemException { 4205 return getPersistence().filterFindByG_ST(groupId, status, start, end); 4206 } 4207 4208 /** 4209 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and status = ?. 4210 * 4211 * <p> 4212 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4213 * </p> 4214 * 4215 * @param groupId the group ID 4216 * @param status the status 4217 * @param start the lower bound of the range of journal articles 4218 * @param end the upper bound of the range of journal articles (not inclusive) 4219 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4220 * @return the ordered range of matching journal articles that the user has permission to view 4221 * @throws SystemException if a system exception occurred 4222 */ 4223 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4224 long groupId, int status, int start, int end, 4225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4226 throws com.liferay.portal.kernel.exception.SystemException { 4227 return getPersistence() 4228 .filterFindByG_ST(groupId, status, start, end, 4229 orderByComparator); 4230 } 4231 4232 /** 4233 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ? and status = ?. 4234 * 4235 * @param id the primary key of the current journal article 4236 * @param groupId the group ID 4237 * @param status the status 4238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4239 * @return the previous, current, and next journal article 4240 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4241 * @throws SystemException if a system exception occurred 4242 */ 4243 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext( 4244 long id, long groupId, int status, 4245 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4246 throws com.liferay.portal.kernel.exception.SystemException, 4247 com.liferay.portlet.journal.NoSuchArticleException { 4248 return getPersistence() 4249 .filterFindByG_ST_PrevAndNext(id, groupId, status, 4250 orderByComparator); 4251 } 4252 4253 /** 4254 * Removes all the journal articles where groupId = ? and status = ? from the database. 4255 * 4256 * @param groupId the group ID 4257 * @param status the status 4258 * @throws SystemException if a system exception occurred 4259 */ 4260 public static void removeByG_ST(long groupId, int status) 4261 throws com.liferay.portal.kernel.exception.SystemException { 4262 getPersistence().removeByG_ST(groupId, status); 4263 } 4264 4265 /** 4266 * Returns the number of journal articles where groupId = ? and status = ?. 4267 * 4268 * @param groupId the group ID 4269 * @param status the status 4270 * @return the number of matching journal articles 4271 * @throws SystemException if a system exception occurred 4272 */ 4273 public static int countByG_ST(long groupId, int status) 4274 throws com.liferay.portal.kernel.exception.SystemException { 4275 return getPersistence().countByG_ST(groupId, status); 4276 } 4277 4278 /** 4279 * Returns the number of journal articles that the user has permission to view where groupId = ? and status = ?. 4280 * 4281 * @param groupId the group ID 4282 * @param status the status 4283 * @return the number of matching journal articles that the user has permission to view 4284 * @throws SystemException if a system exception occurred 4285 */ 4286 public static int filterCountByG_ST(long groupId, int status) 4287 throws com.liferay.portal.kernel.exception.SystemException { 4288 return getPersistence().filterCountByG_ST(groupId, status); 4289 } 4290 4291 /** 4292 * Returns all the journal articles where companyId = ? and version = ?. 4293 * 4294 * @param companyId the company ID 4295 * @param version the version 4296 * @return the matching journal articles 4297 * @throws SystemException if a system exception occurred 4298 */ 4299 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4300 long companyId, double version) 4301 throws com.liferay.portal.kernel.exception.SystemException { 4302 return getPersistence().findByC_V(companyId, version); 4303 } 4304 4305 /** 4306 * Returns a range of all the journal articles where companyId = ? and version = ?. 4307 * 4308 * <p> 4309 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4310 * </p> 4311 * 4312 * @param companyId the company ID 4313 * @param version the version 4314 * @param start the lower bound of the range of journal articles 4315 * @param end the upper bound of the range of journal articles (not inclusive) 4316 * @return the range of matching journal articles 4317 * @throws SystemException if a system exception occurred 4318 */ 4319 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4320 long companyId, double version, int start, int end) 4321 throws com.liferay.portal.kernel.exception.SystemException { 4322 return getPersistence().findByC_V(companyId, version, start, end); 4323 } 4324 4325 /** 4326 * Returns an ordered range of all the journal articles where companyId = ? and version = ?. 4327 * 4328 * <p> 4329 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4330 * </p> 4331 * 4332 * @param companyId the company ID 4333 * @param version the version 4334 * @param start the lower bound of the range of journal articles 4335 * @param end the upper bound of the range of journal articles (not inclusive) 4336 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4337 * @return the ordered range of matching journal articles 4338 * @throws SystemException if a system exception occurred 4339 */ 4340 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4341 long companyId, double version, int start, int end, 4342 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4343 throws com.liferay.portal.kernel.exception.SystemException { 4344 return getPersistence() 4345 .findByC_V(companyId, version, start, end, orderByComparator); 4346 } 4347 4348 /** 4349 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 4350 * 4351 * @param companyId the company ID 4352 * @param version the version 4353 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4354 * @return the first matching journal article 4355 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4356 * @throws SystemException if a system exception occurred 4357 */ 4358 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First( 4359 long companyId, double version, 4360 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4361 throws com.liferay.portal.kernel.exception.SystemException, 4362 com.liferay.portlet.journal.NoSuchArticleException { 4363 return getPersistence() 4364 .findByC_V_First(companyId, version, orderByComparator); 4365 } 4366 4367 /** 4368 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 4369 * 4370 * @param companyId the company ID 4371 * @param version the version 4372 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4373 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4374 * @throws SystemException if a system exception occurred 4375 */ 4376 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First( 4377 long companyId, double version, 4378 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4379 throws com.liferay.portal.kernel.exception.SystemException { 4380 return getPersistence() 4381 .fetchByC_V_First(companyId, version, orderByComparator); 4382 } 4383 4384 /** 4385 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 4386 * 4387 * @param companyId the company ID 4388 * @param version the version 4389 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4390 * @return the last matching journal article 4391 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4392 * @throws SystemException if a system exception occurred 4393 */ 4394 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last( 4395 long companyId, double version, 4396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4397 throws com.liferay.portal.kernel.exception.SystemException, 4398 com.liferay.portlet.journal.NoSuchArticleException { 4399 return getPersistence() 4400 .findByC_V_Last(companyId, version, orderByComparator); 4401 } 4402 4403 /** 4404 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 4405 * 4406 * @param companyId the company ID 4407 * @param version the version 4408 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4409 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4410 * @throws SystemException if a system exception occurred 4411 */ 4412 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last( 4413 long companyId, double version, 4414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4415 throws com.liferay.portal.kernel.exception.SystemException { 4416 return getPersistence() 4417 .fetchByC_V_Last(companyId, version, orderByComparator); 4418 } 4419 4420 /** 4421 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ?. 4422 * 4423 * @param id the primary key of the current journal article 4424 * @param companyId the company ID 4425 * @param version the version 4426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4427 * @return the previous, current, and next journal article 4428 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4429 * @throws SystemException if a system exception occurred 4430 */ 4431 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext( 4432 long id, long companyId, double version, 4433 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4434 throws com.liferay.portal.kernel.exception.SystemException, 4435 com.liferay.portlet.journal.NoSuchArticleException { 4436 return getPersistence() 4437 .findByC_V_PrevAndNext(id, companyId, version, 4438 orderByComparator); 4439 } 4440 4441 /** 4442 * Removes all the journal articles where companyId = ? and version = ? from the database. 4443 * 4444 * @param companyId the company ID 4445 * @param version the version 4446 * @throws SystemException if a system exception occurred 4447 */ 4448 public static void removeByC_V(long companyId, double version) 4449 throws com.liferay.portal.kernel.exception.SystemException { 4450 getPersistence().removeByC_V(companyId, version); 4451 } 4452 4453 /** 4454 * Returns the number of journal articles where companyId = ? and version = ?. 4455 * 4456 * @param companyId the company ID 4457 * @param version the version 4458 * @return the number of matching journal articles 4459 * @throws SystemException if a system exception occurred 4460 */ 4461 public static int countByC_V(long companyId, double version) 4462 throws com.liferay.portal.kernel.exception.SystemException { 4463 return getPersistence().countByC_V(companyId, version); 4464 } 4465 4466 /** 4467 * Returns all the journal articles where companyId = ? and status = ?. 4468 * 4469 * @param companyId the company ID 4470 * @param status the status 4471 * @return the matching journal articles 4472 * @throws SystemException if a system exception occurred 4473 */ 4474 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4475 long companyId, int status) 4476 throws com.liferay.portal.kernel.exception.SystemException { 4477 return getPersistence().findByC_ST(companyId, status); 4478 } 4479 4480 /** 4481 * Returns a range of all the journal articles where companyId = ? and status = ?. 4482 * 4483 * <p> 4484 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4485 * </p> 4486 * 4487 * @param companyId the company ID 4488 * @param status the status 4489 * @param start the lower bound of the range of journal articles 4490 * @param end the upper bound of the range of journal articles (not inclusive) 4491 * @return the range of matching journal articles 4492 * @throws SystemException if a system exception occurred 4493 */ 4494 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4495 long companyId, int status, int start, int end) 4496 throws com.liferay.portal.kernel.exception.SystemException { 4497 return getPersistence().findByC_ST(companyId, status, start, end); 4498 } 4499 4500 /** 4501 * Returns an ordered range of all the journal articles where companyId = ? and status = ?. 4502 * 4503 * <p> 4504 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4505 * </p> 4506 * 4507 * @param companyId the company ID 4508 * @param status the status 4509 * @param start the lower bound of the range of journal articles 4510 * @param end the upper bound of the range of journal articles (not inclusive) 4511 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4512 * @return the ordered range of matching journal articles 4513 * @throws SystemException if a system exception occurred 4514 */ 4515 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 4516 long companyId, int status, int start, int end, 4517 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4518 throws com.liferay.portal.kernel.exception.SystemException { 4519 return getPersistence() 4520 .findByC_ST(companyId, status, start, end, orderByComparator); 4521 } 4522 4523 /** 4524 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 4525 * 4526 * @param companyId the company ID 4527 * @param status the status 4528 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4529 * @return the first matching journal article 4530 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4531 * @throws SystemException if a system exception occurred 4532 */ 4533 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First( 4534 long companyId, int status, 4535 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4536 throws com.liferay.portal.kernel.exception.SystemException, 4537 com.liferay.portlet.journal.NoSuchArticleException { 4538 return getPersistence() 4539 .findByC_ST_First(companyId, status, orderByComparator); 4540 } 4541 4542 /** 4543 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 4544 * 4545 * @param companyId the company ID 4546 * @param status the status 4547 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4548 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4549 * @throws SystemException if a system exception occurred 4550 */ 4551 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First( 4552 long companyId, int status, 4553 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4554 throws com.liferay.portal.kernel.exception.SystemException { 4555 return getPersistence() 4556 .fetchByC_ST_First(companyId, status, orderByComparator); 4557 } 4558 4559 /** 4560 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 4561 * 4562 * @param companyId the company ID 4563 * @param status the status 4564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4565 * @return the last matching journal article 4566 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4567 * @throws SystemException if a system exception occurred 4568 */ 4569 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last( 4570 long companyId, int status, 4571 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4572 throws com.liferay.portal.kernel.exception.SystemException, 4573 com.liferay.portlet.journal.NoSuchArticleException { 4574 return getPersistence() 4575 .findByC_ST_Last(companyId, status, orderByComparator); 4576 } 4577 4578 /** 4579 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 4580 * 4581 * @param companyId the company ID 4582 * @param status the status 4583 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4584 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4585 * @throws SystemException if a system exception occurred 4586 */ 4587 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last( 4588 long companyId, int status, 4589 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4590 throws com.liferay.portal.kernel.exception.SystemException { 4591 return getPersistence() 4592 .fetchByC_ST_Last(companyId, status, orderByComparator); 4593 } 4594 4595 /** 4596 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status = ?. 4597 * 4598 * @param id the primary key of the current journal article 4599 * @param companyId the company ID 4600 * @param status the status 4601 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4602 * @return the previous, current, and next journal article 4603 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4604 * @throws SystemException if a system exception occurred 4605 */ 4606 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext( 4607 long id, long companyId, int status, 4608 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4609 throws com.liferay.portal.kernel.exception.SystemException, 4610 com.liferay.portlet.journal.NoSuchArticleException { 4611 return getPersistence() 4612 .findByC_ST_PrevAndNext(id, companyId, status, 4613 orderByComparator); 4614 } 4615 4616 /** 4617 * Removes all the journal articles where companyId = ? and status = ? from the database. 4618 * 4619 * @param companyId the company ID 4620 * @param status the status 4621 * @throws SystemException if a system exception occurred 4622 */ 4623 public static void removeByC_ST(long companyId, int status) 4624 throws com.liferay.portal.kernel.exception.SystemException { 4625 getPersistence().removeByC_ST(companyId, status); 4626 } 4627 4628 /** 4629 * Returns the number of journal articles where companyId = ? and status = ?. 4630 * 4631 * @param companyId the company ID 4632 * @param status the status 4633 * @return the number of matching journal articles 4634 * @throws SystemException if a system exception occurred 4635 */ 4636 public static int countByC_ST(long companyId, int status) 4637 throws com.liferay.portal.kernel.exception.SystemException { 4638 return getPersistence().countByC_ST(companyId, status); 4639 } 4640 4641 /** 4642 * Returns all the journal articles where groupId = ? and folderId = ? and status = ?. 4643 * 4644 * @param groupId the group ID 4645 * @param folderId the folder ID 4646 * @param status the status 4647 * @return the matching journal articles 4648 * @throws SystemException if a system exception occurred 4649 */ 4650 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 4651 long groupId, long folderId, int status) 4652 throws com.liferay.portal.kernel.exception.SystemException { 4653 return getPersistence().findByG_F_ST(groupId, folderId, status); 4654 } 4655 4656 /** 4657 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = ?. 4658 * 4659 * <p> 4660 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4661 * </p> 4662 * 4663 * @param groupId the group ID 4664 * @param folderId the folder ID 4665 * @param status the status 4666 * @param start the lower bound of the range of journal articles 4667 * @param end the upper bound of the range of journal articles (not inclusive) 4668 * @return the range of matching journal articles 4669 * @throws SystemException if a system exception occurred 4670 */ 4671 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 4672 long groupId, long folderId, int status, int start, int end) 4673 throws com.liferay.portal.kernel.exception.SystemException { 4674 return getPersistence() 4675 .findByG_F_ST(groupId, folderId, status, start, end); 4676 } 4677 4678 /** 4679 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = ?. 4680 * 4681 * <p> 4682 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4683 * </p> 4684 * 4685 * @param groupId the group ID 4686 * @param folderId the folder ID 4687 * @param status the status 4688 * @param start the lower bound of the range of journal articles 4689 * @param end the upper bound of the range of journal articles (not inclusive) 4690 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4691 * @return the ordered range of matching journal articles 4692 * @throws SystemException if a system exception occurred 4693 */ 4694 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 4695 long groupId, long folderId, int status, int start, int end, 4696 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4697 throws com.liferay.portal.kernel.exception.SystemException { 4698 return getPersistence() 4699 .findByG_F_ST(groupId, folderId, status, start, end, 4700 orderByComparator); 4701 } 4702 4703 /** 4704 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 4705 * 4706 * @param groupId the group ID 4707 * @param folderId the folder ID 4708 * @param status the status 4709 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4710 * @return the first matching journal article 4711 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4712 * @throws SystemException if a system exception occurred 4713 */ 4714 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First( 4715 long groupId, long folderId, int status, 4716 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4717 throws com.liferay.portal.kernel.exception.SystemException, 4718 com.liferay.portlet.journal.NoSuchArticleException { 4719 return getPersistence() 4720 .findByG_F_ST_First(groupId, folderId, status, 4721 orderByComparator); 4722 } 4723 4724 /** 4725 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 4726 * 4727 * @param groupId the group ID 4728 * @param folderId the folder ID 4729 * @param status the status 4730 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4731 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4732 * @throws SystemException if a system exception occurred 4733 */ 4734 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First( 4735 long groupId, long folderId, int status, 4736 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4737 throws com.liferay.portal.kernel.exception.SystemException { 4738 return getPersistence() 4739 .fetchByG_F_ST_First(groupId, folderId, status, 4740 orderByComparator); 4741 } 4742 4743 /** 4744 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 4745 * 4746 * @param groupId the group ID 4747 * @param folderId the folder ID 4748 * @param status the status 4749 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4750 * @return the last matching journal article 4751 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4752 * @throws SystemException if a system exception occurred 4753 */ 4754 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last( 4755 long groupId, long folderId, int status, 4756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4757 throws com.liferay.portal.kernel.exception.SystemException, 4758 com.liferay.portlet.journal.NoSuchArticleException { 4759 return getPersistence() 4760 .findByG_F_ST_Last(groupId, folderId, status, 4761 orderByComparator); 4762 } 4763 4764 /** 4765 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 4766 * 4767 * @param groupId the group ID 4768 * @param folderId the folder ID 4769 * @param status the status 4770 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4771 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4772 * @throws SystemException if a system exception occurred 4773 */ 4774 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last( 4775 long groupId, long folderId, int status, 4776 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4777 throws com.liferay.portal.kernel.exception.SystemException { 4778 return getPersistence() 4779 .fetchByG_F_ST_Last(groupId, folderId, status, 4780 orderByComparator); 4781 } 4782 4783 /** 4784 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 4785 * 4786 * @param id the primary key of the current journal article 4787 * @param groupId the group ID 4788 * @param folderId the folder ID 4789 * @param status the status 4790 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4791 * @return the previous, current, and next journal article 4792 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4793 * @throws SystemException if a system exception occurred 4794 */ 4795 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext( 4796 long id, long groupId, long folderId, int status, 4797 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4798 throws com.liferay.portal.kernel.exception.SystemException, 4799 com.liferay.portlet.journal.NoSuchArticleException { 4800 return getPersistence() 4801 .findByG_F_ST_PrevAndNext(id, groupId, folderId, status, 4802 orderByComparator); 4803 } 4804 4805 /** 4806 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 4807 * 4808 * @param groupId the group ID 4809 * @param folderId the folder ID 4810 * @param status the status 4811 * @return the matching journal articles that the user has permission to view 4812 * @throws SystemException if a system exception occurred 4813 */ 4814 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 4815 long groupId, long folderId, int status) 4816 throws com.liferay.portal.kernel.exception.SystemException { 4817 return getPersistence().filterFindByG_F_ST(groupId, folderId, status); 4818 } 4819 4820 /** 4821 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 4822 * 4823 * <p> 4824 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4825 * </p> 4826 * 4827 * @param groupId the group ID 4828 * @param folderId the folder ID 4829 * @param status the status 4830 * @param start the lower bound of the range of journal articles 4831 * @param end the upper bound of the range of journal articles (not inclusive) 4832 * @return the range of matching journal articles that the user has permission to view 4833 * @throws SystemException if a system exception occurred 4834 */ 4835 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 4836 long groupId, long folderId, int status, int start, int end) 4837 throws com.liferay.portal.kernel.exception.SystemException { 4838 return getPersistence() 4839 .filterFindByG_F_ST(groupId, folderId, status, start, end); 4840 } 4841 4842 /** 4843 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 4844 * 4845 * <p> 4846 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4847 * </p> 4848 * 4849 * @param groupId the group ID 4850 * @param folderId the folder ID 4851 * @param status the status 4852 * @param start the lower bound of the range of journal articles 4853 * @param end the upper bound of the range of journal articles (not inclusive) 4854 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4855 * @return the ordered range of matching journal articles that the user has permission to view 4856 * @throws SystemException if a system exception occurred 4857 */ 4858 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 4859 long groupId, long folderId, int status, int start, int end, 4860 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4861 throws com.liferay.portal.kernel.exception.SystemException { 4862 return getPersistence() 4863 .filterFindByG_F_ST(groupId, folderId, status, start, end, 4864 orderByComparator); 4865 } 4866 4867 /** 4868 * 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 = ?. 4869 * 4870 * @param id the primary key of the current journal article 4871 * @param groupId the group ID 4872 * @param folderId the folder ID 4873 * @param status the status 4874 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4875 * @return the previous, current, and next journal article 4876 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4877 * @throws SystemException if a system exception occurred 4878 */ 4879 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext( 4880 long id, long groupId, long folderId, int status, 4881 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4882 throws com.liferay.portal.kernel.exception.SystemException, 4883 com.liferay.portlet.journal.NoSuchArticleException { 4884 return getPersistence() 4885 .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId, 4886 status, orderByComparator); 4887 } 4888 4889 /** 4890 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 4891 * 4892 * @param groupId the group ID 4893 * @param folderId the folder ID 4894 * @param statuses the statuses 4895 * @return the matching journal articles that the user has permission to view 4896 * @throws SystemException if a system exception occurred 4897 */ 4898 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 4899 long groupId, long folderId, int[] statuses) 4900 throws com.liferay.portal.kernel.exception.SystemException { 4901 return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses); 4902 } 4903 4904 /** 4905 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 4906 * 4907 * <p> 4908 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4909 * </p> 4910 * 4911 * @param groupId the group ID 4912 * @param folderId the folder ID 4913 * @param statuses the statuses 4914 * @param start the lower bound of the range of journal articles 4915 * @param end the upper bound of the range of journal articles (not inclusive) 4916 * @return the range of matching journal articles that the user has permission to view 4917 * @throws SystemException if a system exception occurred 4918 */ 4919 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 4920 long groupId, long folderId, int[] statuses, int start, int end) 4921 throws com.liferay.portal.kernel.exception.SystemException { 4922 return getPersistence() 4923 .filterFindByG_F_ST(groupId, folderId, statuses, start, end); 4924 } 4925 4926 /** 4927 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 4928 * 4929 * <p> 4930 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4931 * </p> 4932 * 4933 * @param groupId the group ID 4934 * @param folderId the folder ID 4935 * @param statuses the statuses 4936 * @param start the lower bound of the range of journal articles 4937 * @param end the upper bound of the range of journal articles (not inclusive) 4938 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4939 * @return the ordered range of matching journal articles that the user has permission to view 4940 * @throws SystemException if a system exception occurred 4941 */ 4942 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 4943 long groupId, long folderId, int[] statuses, int start, int end, 4944 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4945 throws com.liferay.portal.kernel.exception.SystemException { 4946 return getPersistence() 4947 .filterFindByG_F_ST(groupId, folderId, statuses, start, end, 4948 orderByComparator); 4949 } 4950 4951 /** 4952 * Returns all the journal articles where groupId = ? and folderId = ? and status = any ?. 4953 * 4954 * <p> 4955 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4956 * </p> 4957 * 4958 * @param groupId the group ID 4959 * @param folderId the folder ID 4960 * @param statuses the statuses 4961 * @return the matching journal articles 4962 * @throws SystemException if a system exception occurred 4963 */ 4964 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 4965 long groupId, long folderId, int[] statuses) 4966 throws com.liferay.portal.kernel.exception.SystemException { 4967 return getPersistence().findByG_F_ST(groupId, folderId, statuses); 4968 } 4969 4970 /** 4971 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 4972 * 4973 * <p> 4974 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4975 * </p> 4976 * 4977 * @param groupId the group ID 4978 * @param folderId the folder ID 4979 * @param statuses the statuses 4980 * @param start the lower bound of the range of journal articles 4981 * @param end the upper bound of the range of journal articles (not inclusive) 4982 * @return the range of matching journal articles 4983 * @throws SystemException if a system exception occurred 4984 */ 4985 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 4986 long groupId, long folderId, int[] statuses, int start, int end) 4987 throws com.liferay.portal.kernel.exception.SystemException { 4988 return getPersistence() 4989 .findByG_F_ST(groupId, folderId, statuses, start, end); 4990 } 4991 4992 /** 4993 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 4994 * 4995 * <p> 4996 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4997 * </p> 4998 * 4999 * @param groupId the group ID 5000 * @param folderId the folder ID 5001 * @param statuses the statuses 5002 * @param start the lower bound of the range of journal articles 5003 * @param end the upper bound of the range of journal articles (not inclusive) 5004 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5005 * @return the ordered range of matching journal articles 5006 * @throws SystemException if a system exception occurred 5007 */ 5008 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5009 long groupId, long folderId, int[] statuses, int start, int end, 5010 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5011 throws com.liferay.portal.kernel.exception.SystemException { 5012 return getPersistence() 5013 .findByG_F_ST(groupId, folderId, statuses, start, end, 5014 orderByComparator); 5015 } 5016 5017 /** 5018 * Removes all the journal articles where groupId = ? and folderId = ? and status = ? from the database. 5019 * 5020 * @param groupId the group ID 5021 * @param folderId the folder ID 5022 * @param status the status 5023 * @throws SystemException if a system exception occurred 5024 */ 5025 public static void removeByG_F_ST(long groupId, long folderId, int status) 5026 throws com.liferay.portal.kernel.exception.SystemException { 5027 getPersistence().removeByG_F_ST(groupId, folderId, status); 5028 } 5029 5030 /** 5031 * Returns the number of journal articles where groupId = ? and folderId = ? and status = ?. 5032 * 5033 * @param groupId the group ID 5034 * @param folderId the folder ID 5035 * @param status the status 5036 * @return the number of matching journal articles 5037 * @throws SystemException if a system exception occurred 5038 */ 5039 public static int countByG_F_ST(long groupId, long folderId, int status) 5040 throws com.liferay.portal.kernel.exception.SystemException { 5041 return getPersistence().countByG_F_ST(groupId, folderId, status); 5042 } 5043 5044 /** 5045 * Returns the number of journal articles where groupId = ? and folderId = ? and status = any ?. 5046 * 5047 * @param groupId the group ID 5048 * @param folderId the folder ID 5049 * @param statuses the statuses 5050 * @return the number of matching journal articles 5051 * @throws SystemException if a system exception occurred 5052 */ 5053 public static int countByG_F_ST(long groupId, long folderId, int[] statuses) 5054 throws com.liferay.portal.kernel.exception.SystemException { 5055 return getPersistence().countByG_F_ST(groupId, folderId, statuses); 5056 } 5057 5058 /** 5059 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5060 * 5061 * @param groupId the group ID 5062 * @param folderId the folder ID 5063 * @param status the status 5064 * @return the number of matching journal articles that the user has permission to view 5065 * @throws SystemException if a system exception occurred 5066 */ 5067 public static int filterCountByG_F_ST(long groupId, long folderId, 5068 int status) throws com.liferay.portal.kernel.exception.SystemException { 5069 return getPersistence().filterCountByG_F_ST(groupId, folderId, status); 5070 } 5071 5072 /** 5073 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5074 * 5075 * @param groupId the group ID 5076 * @param folderId the folder ID 5077 * @param statuses the statuses 5078 * @return the number of matching journal articles that the user has permission to view 5079 * @throws SystemException if a system exception occurred 5080 */ 5081 public static int filterCountByG_F_ST(long groupId, long folderId, 5082 int[] statuses) 5083 throws com.liferay.portal.kernel.exception.SystemException { 5084 return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses); 5085 } 5086 5087 /** 5088 * Returns all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5089 * 5090 * @param groupId the group ID 5091 * @param classNameId the class name ID 5092 * @param classPK the class p k 5093 * @return the matching journal articles 5094 * @throws SystemException if a system exception occurred 5095 */ 5096 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5097 long groupId, long classNameId, long classPK) 5098 throws com.liferay.portal.kernel.exception.SystemException { 5099 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 5100 } 5101 5102 /** 5103 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5104 * 5105 * <p> 5106 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5107 * </p> 5108 * 5109 * @param groupId the group ID 5110 * @param classNameId the class name ID 5111 * @param classPK the class p k 5112 * @param start the lower bound of the range of journal articles 5113 * @param end the upper bound of the range of journal articles (not inclusive) 5114 * @return the range of matching journal articles 5115 * @throws SystemException if a system exception occurred 5116 */ 5117 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5118 long groupId, long classNameId, long classPK, int start, int end) 5119 throws com.liferay.portal.kernel.exception.SystemException { 5120 return getPersistence() 5121 .findByG_C_C(groupId, classNameId, classPK, start, end); 5122 } 5123 5124 /** 5125 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5126 * 5127 * <p> 5128 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5129 * </p> 5130 * 5131 * @param groupId the group ID 5132 * @param classNameId the class name ID 5133 * @param classPK the class p k 5134 * @param start the lower bound of the range of journal articles 5135 * @param end the upper bound of the range of journal articles (not inclusive) 5136 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5137 * @return the ordered range of matching journal articles 5138 * @throws SystemException if a system exception occurred 5139 */ 5140 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5141 long groupId, long classNameId, long classPK, int start, int end, 5142 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5143 throws com.liferay.portal.kernel.exception.SystemException { 5144 return getPersistence() 5145 .findByG_C_C(groupId, classNameId, classPK, start, end, 5146 orderByComparator); 5147 } 5148 5149 /** 5150 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5151 * 5152 * @param groupId the group ID 5153 * @param classNameId the class name ID 5154 * @param classPK the class p k 5155 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5156 * @return the first matching journal article 5157 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5158 * @throws SystemException if a system exception occurred 5159 */ 5160 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First( 5161 long groupId, long classNameId, long classPK, 5162 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5163 throws com.liferay.portal.kernel.exception.SystemException, 5164 com.liferay.portlet.journal.NoSuchArticleException { 5165 return getPersistence() 5166 .findByG_C_C_First(groupId, classNameId, classPK, 5167 orderByComparator); 5168 } 5169 5170 /** 5171 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5172 * 5173 * @param groupId the group ID 5174 * @param classNameId the class name ID 5175 * @param classPK the class p k 5176 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5177 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5178 * @throws SystemException if a system exception occurred 5179 */ 5180 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First( 5181 long groupId, long classNameId, long classPK, 5182 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5183 throws com.liferay.portal.kernel.exception.SystemException { 5184 return getPersistence() 5185 .fetchByG_C_C_First(groupId, classNameId, classPK, 5186 orderByComparator); 5187 } 5188 5189 /** 5190 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5191 * 5192 * @param groupId the group ID 5193 * @param classNameId the class name ID 5194 * @param classPK the class p k 5195 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5196 * @return the last matching journal article 5197 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5198 * @throws SystemException if a system exception occurred 5199 */ 5200 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last( 5201 long groupId, long classNameId, long classPK, 5202 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5203 throws com.liferay.portal.kernel.exception.SystemException, 5204 com.liferay.portlet.journal.NoSuchArticleException { 5205 return getPersistence() 5206 .findByG_C_C_Last(groupId, classNameId, classPK, 5207 orderByComparator); 5208 } 5209 5210 /** 5211 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5212 * 5213 * @param groupId the group ID 5214 * @param classNameId the class name ID 5215 * @param classPK the class p k 5216 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5217 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5218 * @throws SystemException if a system exception occurred 5219 */ 5220 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last( 5221 long groupId, long classNameId, long classPK, 5222 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5223 throws com.liferay.portal.kernel.exception.SystemException { 5224 return getPersistence() 5225 .fetchByG_C_C_Last(groupId, classNameId, classPK, 5226 orderByComparator); 5227 } 5228 5229 /** 5230 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5231 * 5232 * @param id the primary key of the current journal article 5233 * @param groupId the group ID 5234 * @param classNameId the class name ID 5235 * @param classPK the class p k 5236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5237 * @return the previous, current, and next journal article 5238 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5239 * @throws SystemException if a system exception occurred 5240 */ 5241 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext( 5242 long id, long groupId, long classNameId, long classPK, 5243 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5244 throws com.liferay.portal.kernel.exception.SystemException, 5245 com.liferay.portlet.journal.NoSuchArticleException { 5246 return getPersistence() 5247 .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK, 5248 orderByComparator); 5249 } 5250 5251 /** 5252 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5253 * 5254 * @param groupId the group ID 5255 * @param classNameId the class name ID 5256 * @param classPK the class p k 5257 * @return the matching journal articles that the user has permission to view 5258 * @throws SystemException if a system exception occurred 5259 */ 5260 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5261 long groupId, long classNameId, long classPK) 5262 throws com.liferay.portal.kernel.exception.SystemException { 5263 return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK); 5264 } 5265 5266 /** 5267 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5268 * 5269 * <p> 5270 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5271 * </p> 5272 * 5273 * @param groupId the group ID 5274 * @param classNameId the class name ID 5275 * @param classPK the class p k 5276 * @param start the lower bound of the range of journal articles 5277 * @param end the upper bound of the range of journal articles (not inclusive) 5278 * @return the range of matching journal articles that the user has permission to view 5279 * @throws SystemException if a system exception occurred 5280 */ 5281 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5282 long groupId, long classNameId, long classPK, int start, int end) 5283 throws com.liferay.portal.kernel.exception.SystemException { 5284 return getPersistence() 5285 .filterFindByG_C_C(groupId, classNameId, classPK, start, end); 5286 } 5287 5288 /** 5289 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and classPK = ?. 5290 * 5291 * <p> 5292 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5293 * </p> 5294 * 5295 * @param groupId the group ID 5296 * @param classNameId the class name ID 5297 * @param classPK the class p k 5298 * @param start the lower bound of the range of journal articles 5299 * @param end the upper bound of the range of journal articles (not inclusive) 5300 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5301 * @return the ordered range of matching journal articles that the user has permission to view 5302 * @throws SystemException if a system exception occurred 5303 */ 5304 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5305 long groupId, long classNameId, long classPK, int start, int end, 5306 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5307 throws com.liferay.portal.kernel.exception.SystemException { 5308 return getPersistence() 5309 .filterFindByG_C_C(groupId, classNameId, classPK, start, 5310 end, orderByComparator); 5311 } 5312 5313 /** 5314 * 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 = ?. 5315 * 5316 * @param id the primary key of the current journal article 5317 * @param groupId the group ID 5318 * @param classNameId the class name ID 5319 * @param classPK the class p k 5320 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5321 * @return the previous, current, and next journal article 5322 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5323 * @throws SystemException if a system exception occurred 5324 */ 5325 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext( 5326 long id, long groupId, long classNameId, long classPK, 5327 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5328 throws com.liferay.portal.kernel.exception.SystemException, 5329 com.liferay.portlet.journal.NoSuchArticleException { 5330 return getPersistence() 5331 .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId, 5332 classPK, orderByComparator); 5333 } 5334 5335 /** 5336 * Removes all the journal articles where groupId = ? and classNameId = ? and classPK = ? from the database. 5337 * 5338 * @param groupId the group ID 5339 * @param classNameId the class name ID 5340 * @param classPK the class p k 5341 * @throws SystemException if a system exception occurred 5342 */ 5343 public static void removeByG_C_C(long groupId, long classNameId, 5344 long classPK) 5345 throws com.liferay.portal.kernel.exception.SystemException { 5346 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 5347 } 5348 5349 /** 5350 * Returns the number of journal articles where groupId = ? and classNameId = ? and classPK = ?. 5351 * 5352 * @param groupId the group ID 5353 * @param classNameId the class name ID 5354 * @param classPK the class p k 5355 * @return the number of matching journal articles 5356 * @throws SystemException if a system exception occurred 5357 */ 5358 public static int countByG_C_C(long groupId, long classNameId, long classPK) 5359 throws com.liferay.portal.kernel.exception.SystemException { 5360 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 5361 } 5362 5363 /** 5364 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5365 * 5366 * @param groupId the group ID 5367 * @param classNameId the class name ID 5368 * @param classPK the class p k 5369 * @return the number of matching journal articles that the user has permission to view 5370 * @throws SystemException if a system exception occurred 5371 */ 5372 public static int filterCountByG_C_C(long groupId, long classNameId, 5373 long classPK) 5374 throws com.liferay.portal.kernel.exception.SystemException { 5375 return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK); 5376 } 5377 5378 /** 5379 * 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. 5380 * 5381 * @param groupId the group ID 5382 * @param classNameId the class name ID 5383 * @param structureId the structure ID 5384 * @return the matching journal article 5385 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5386 * @throws SystemException if a system exception occurred 5387 */ 5388 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S( 5389 long groupId, long classNameId, java.lang.String structureId) 5390 throws com.liferay.portal.kernel.exception.SystemException, 5391 com.liferay.portlet.journal.NoSuchArticleException { 5392 return getPersistence().findByG_C_S(groupId, classNameId, structureId); 5393 } 5394 5395 /** 5396 * 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. 5397 * 5398 * @param groupId the group ID 5399 * @param classNameId the class name ID 5400 * @param structureId the structure ID 5401 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 5402 * @throws SystemException if a system exception occurred 5403 */ 5404 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 5405 long groupId, long classNameId, java.lang.String structureId) 5406 throws com.liferay.portal.kernel.exception.SystemException { 5407 return getPersistence().fetchByG_C_S(groupId, classNameId, structureId); 5408 } 5409 5410 /** 5411 * 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. 5412 * 5413 * @param groupId the group ID 5414 * @param classNameId the class name ID 5415 * @param structureId the structure ID 5416 * @param retrieveFromCache whether to use the finder cache 5417 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 5418 * @throws SystemException if a system exception occurred 5419 */ 5420 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 5421 long groupId, long classNameId, java.lang.String structureId, 5422 boolean retrieveFromCache) 5423 throws com.liferay.portal.kernel.exception.SystemException { 5424 return getPersistence() 5425 .fetchByG_C_S(groupId, classNameId, structureId, 5426 retrieveFromCache); 5427 } 5428 5429 /** 5430 * Removes the journal article where groupId = ? and classNameId = ? and structureId = ? from the database. 5431 * 5432 * @param groupId the group ID 5433 * @param classNameId the class name ID 5434 * @param structureId the structure ID 5435 * @return the journal article that was removed 5436 * @throws SystemException if a system exception occurred 5437 */ 5438 public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S( 5439 long groupId, long classNameId, java.lang.String structureId) 5440 throws com.liferay.portal.kernel.exception.SystemException, 5441 com.liferay.portlet.journal.NoSuchArticleException { 5442 return getPersistence().removeByG_C_S(groupId, classNameId, structureId); 5443 } 5444 5445 /** 5446 * Returns the number of journal articles where groupId = ? and classNameId = ? and structureId = ?. 5447 * 5448 * @param groupId the group ID 5449 * @param classNameId the class name ID 5450 * @param structureId the structure ID 5451 * @return the number of matching journal articles 5452 * @throws SystemException if a system exception occurred 5453 */ 5454 public static int countByG_C_S(long groupId, long classNameId, 5455 java.lang.String structureId) 5456 throws com.liferay.portal.kernel.exception.SystemException { 5457 return getPersistence().countByG_C_S(groupId, classNameId, structureId); 5458 } 5459 5460 /** 5461 * Returns all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5462 * 5463 * @param groupId the group ID 5464 * @param classNameId the class name ID 5465 * @param templateId the template ID 5466 * @return the matching journal articles 5467 * @throws SystemException if a system exception occurred 5468 */ 5469 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5470 long groupId, long classNameId, java.lang.String templateId) 5471 throws com.liferay.portal.kernel.exception.SystemException { 5472 return getPersistence().findByG_C_T(groupId, classNameId, templateId); 5473 } 5474 5475 /** 5476 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5477 * 5478 * <p> 5479 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5480 * </p> 5481 * 5482 * @param groupId the group ID 5483 * @param classNameId the class name ID 5484 * @param templateId the template ID 5485 * @param start the lower bound of the range of journal articles 5486 * @param end the upper bound of the range of journal articles (not inclusive) 5487 * @return the range of matching journal articles 5488 * @throws SystemException if a system exception occurred 5489 */ 5490 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5491 long groupId, long classNameId, java.lang.String templateId, int start, 5492 int end) throws com.liferay.portal.kernel.exception.SystemException { 5493 return getPersistence() 5494 .findByG_C_T(groupId, classNameId, templateId, start, end); 5495 } 5496 5497 /** 5498 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5499 * 5500 * <p> 5501 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5502 * </p> 5503 * 5504 * @param groupId the group ID 5505 * @param classNameId the class name ID 5506 * @param templateId the template ID 5507 * @param start the lower bound of the range of journal articles 5508 * @param end the upper bound of the range of journal articles (not inclusive) 5509 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5510 * @return the ordered range of matching journal articles 5511 * @throws SystemException if a system exception occurred 5512 */ 5513 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5514 long groupId, long classNameId, java.lang.String templateId, int start, 5515 int end, 5516 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5517 throws com.liferay.portal.kernel.exception.SystemException { 5518 return getPersistence() 5519 .findByG_C_T(groupId, classNameId, templateId, start, end, 5520 orderByComparator); 5521 } 5522 5523 /** 5524 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5525 * 5526 * @param groupId the group ID 5527 * @param classNameId the class name ID 5528 * @param templateId the template ID 5529 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5530 * @return the first matching journal article 5531 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5532 * @throws SystemException if a system exception occurred 5533 */ 5534 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First( 5535 long groupId, long classNameId, java.lang.String templateId, 5536 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5537 throws com.liferay.portal.kernel.exception.SystemException, 5538 com.liferay.portlet.journal.NoSuchArticleException { 5539 return getPersistence() 5540 .findByG_C_T_First(groupId, classNameId, templateId, 5541 orderByComparator); 5542 } 5543 5544 /** 5545 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5546 * 5547 * @param groupId the group ID 5548 * @param classNameId the class name ID 5549 * @param templateId the template ID 5550 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5551 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5552 * @throws SystemException if a system exception occurred 5553 */ 5554 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First( 5555 long groupId, long classNameId, java.lang.String templateId, 5556 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5557 throws com.liferay.portal.kernel.exception.SystemException { 5558 return getPersistence() 5559 .fetchByG_C_T_First(groupId, classNameId, templateId, 5560 orderByComparator); 5561 } 5562 5563 /** 5564 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5565 * 5566 * @param groupId the group ID 5567 * @param classNameId the class name ID 5568 * @param templateId the template ID 5569 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5570 * @return the last matching journal article 5571 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5572 * @throws SystemException if a system exception occurred 5573 */ 5574 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last( 5575 long groupId, long classNameId, java.lang.String templateId, 5576 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5577 throws com.liferay.portal.kernel.exception.SystemException, 5578 com.liferay.portlet.journal.NoSuchArticleException { 5579 return getPersistence() 5580 .findByG_C_T_Last(groupId, classNameId, templateId, 5581 orderByComparator); 5582 } 5583 5584 /** 5585 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5586 * 5587 * @param groupId the group ID 5588 * @param classNameId the class name ID 5589 * @param templateId the template ID 5590 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5591 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5592 * @throws SystemException if a system exception occurred 5593 */ 5594 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last( 5595 long groupId, long classNameId, java.lang.String templateId, 5596 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5597 throws com.liferay.portal.kernel.exception.SystemException { 5598 return getPersistence() 5599 .fetchByG_C_T_Last(groupId, classNameId, templateId, 5600 orderByComparator); 5601 } 5602 5603 /** 5604 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5605 * 5606 * @param id the primary key of the current journal article 5607 * @param groupId the group ID 5608 * @param classNameId the class name ID 5609 * @param templateId the template ID 5610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5611 * @return the previous, current, and next journal article 5612 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5613 * @throws SystemException if a system exception occurred 5614 */ 5615 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext( 5616 long id, long groupId, long classNameId, java.lang.String templateId, 5617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5618 throws com.liferay.portal.kernel.exception.SystemException, 5619 com.liferay.portlet.journal.NoSuchArticleException { 5620 return getPersistence() 5621 .findByG_C_T_PrevAndNext(id, groupId, classNameId, 5622 templateId, orderByComparator); 5623 } 5624 5625 /** 5626 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 5627 * 5628 * @param groupId the group ID 5629 * @param classNameId the class name ID 5630 * @param templateId the template ID 5631 * @return the matching journal articles that the user has permission to view 5632 * @throws SystemException if a system exception occurred 5633 */ 5634 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 5635 long groupId, long classNameId, java.lang.String templateId) 5636 throws com.liferay.portal.kernel.exception.SystemException { 5637 return getPersistence() 5638 .filterFindByG_C_T(groupId, classNameId, templateId); 5639 } 5640 5641 /** 5642 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 5643 * 5644 * <p> 5645 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5646 * </p> 5647 * 5648 * @param groupId the group ID 5649 * @param classNameId the class name ID 5650 * @param templateId the template ID 5651 * @param start the lower bound of the range of journal articles 5652 * @param end the upper bound of the range of journal articles (not inclusive) 5653 * @return the range of matching journal articles that the user has permission to view 5654 * @throws SystemException if a system exception occurred 5655 */ 5656 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 5657 long groupId, long classNameId, java.lang.String templateId, int start, 5658 int end) throws com.liferay.portal.kernel.exception.SystemException { 5659 return getPersistence() 5660 .filterFindByG_C_T(groupId, classNameId, templateId, start, 5661 end); 5662 } 5663 5664 /** 5665 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and templateId = ?. 5666 * 5667 * <p> 5668 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5669 * </p> 5670 * 5671 * @param groupId the group ID 5672 * @param classNameId the class name ID 5673 * @param templateId the template ID 5674 * @param start the lower bound of the range of journal articles 5675 * @param end the upper bound of the range of journal articles (not inclusive) 5676 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5677 * @return the ordered range of matching journal articles that the user has permission to view 5678 * @throws SystemException if a system exception occurred 5679 */ 5680 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 5681 long groupId, long classNameId, java.lang.String templateId, int start, 5682 int end, 5683 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5684 throws com.liferay.portal.kernel.exception.SystemException { 5685 return getPersistence() 5686 .filterFindByG_C_T(groupId, classNameId, templateId, start, 5687 end, orderByComparator); 5688 } 5689 5690 /** 5691 * 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 = ?. 5692 * 5693 * @param id the primary key of the current journal article 5694 * @param groupId the group ID 5695 * @param classNameId the class name ID 5696 * @param templateId the template ID 5697 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5698 * @return the previous, current, and next journal article 5699 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5700 * @throws SystemException if a system exception occurred 5701 */ 5702 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext( 5703 long id, long groupId, long classNameId, java.lang.String templateId, 5704 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5705 throws com.liferay.portal.kernel.exception.SystemException, 5706 com.liferay.portlet.journal.NoSuchArticleException { 5707 return getPersistence() 5708 .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId, 5709 templateId, orderByComparator); 5710 } 5711 5712 /** 5713 * Removes all the journal articles where groupId = ? and classNameId = ? and templateId = ? from the database. 5714 * 5715 * @param groupId the group ID 5716 * @param classNameId the class name ID 5717 * @param templateId the template ID 5718 * @throws SystemException if a system exception occurred 5719 */ 5720 public static void removeByG_C_T(long groupId, long classNameId, 5721 java.lang.String templateId) 5722 throws com.liferay.portal.kernel.exception.SystemException { 5723 getPersistence().removeByG_C_T(groupId, classNameId, templateId); 5724 } 5725 5726 /** 5727 * Returns the number of journal articles where groupId = ? and classNameId = ? and templateId = ?. 5728 * 5729 * @param groupId the group ID 5730 * @param classNameId the class name ID 5731 * @param templateId the template ID 5732 * @return the number of matching journal articles 5733 * @throws SystemException if a system exception occurred 5734 */ 5735 public static int countByG_C_T(long groupId, long classNameId, 5736 java.lang.String templateId) 5737 throws com.liferay.portal.kernel.exception.SystemException { 5738 return getPersistence().countByG_C_T(groupId, classNameId, templateId); 5739 } 5740 5741 /** 5742 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 5743 * 5744 * @param groupId the group ID 5745 * @param classNameId the class name ID 5746 * @param templateId the template ID 5747 * @return the number of matching journal articles that the user has permission to view 5748 * @throws SystemException if a system exception occurred 5749 */ 5750 public static int filterCountByG_C_T(long groupId, long classNameId, 5751 java.lang.String templateId) 5752 throws com.liferay.portal.kernel.exception.SystemException { 5753 return getPersistence() 5754 .filterCountByG_C_T(groupId, classNameId, templateId); 5755 } 5756 5757 /** 5758 * Returns all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 5759 * 5760 * @param groupId the group ID 5761 * @param classNameId the class name ID 5762 * @param layoutUuid the layout uuid 5763 * @return the matching journal articles 5764 * @throws SystemException if a system exception occurred 5765 */ 5766 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 5767 long groupId, long classNameId, java.lang.String layoutUuid) 5768 throws com.liferay.portal.kernel.exception.SystemException { 5769 return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid); 5770 } 5771 5772 /** 5773 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 5774 * 5775 * <p> 5776 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5777 * </p> 5778 * 5779 * @param groupId the group ID 5780 * @param classNameId the class name ID 5781 * @param layoutUuid the layout uuid 5782 * @param start the lower bound of the range of journal articles 5783 * @param end the upper bound of the range of journal articles (not inclusive) 5784 * @return the range of matching journal articles 5785 * @throws SystemException if a system exception occurred 5786 */ 5787 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 5788 long groupId, long classNameId, java.lang.String layoutUuid, int start, 5789 int end) throws com.liferay.portal.kernel.exception.SystemException { 5790 return getPersistence() 5791 .findByG_C_L(groupId, classNameId, layoutUuid, start, end); 5792 } 5793 5794 /** 5795 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 5796 * 5797 * <p> 5798 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5799 * </p> 5800 * 5801 * @param groupId the group ID 5802 * @param classNameId the class name ID 5803 * @param layoutUuid the layout uuid 5804 * @param start the lower bound of the range of journal articles 5805 * @param end the upper bound of the range of journal articles (not inclusive) 5806 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5807 * @return the ordered range of matching journal articles 5808 * @throws SystemException if a system exception occurred 5809 */ 5810 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 5811 long groupId, long classNameId, java.lang.String layoutUuid, int start, 5812 int end, 5813 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5814 throws com.liferay.portal.kernel.exception.SystemException { 5815 return getPersistence() 5816 .findByG_C_L(groupId, classNameId, layoutUuid, start, end, 5817 orderByComparator); 5818 } 5819 5820 /** 5821 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 5822 * 5823 * @param groupId the group ID 5824 * @param classNameId the class name ID 5825 * @param layoutUuid the layout uuid 5826 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5827 * @return the first matching journal article 5828 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5829 * @throws SystemException if a system exception occurred 5830 */ 5831 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First( 5832 long groupId, long classNameId, java.lang.String layoutUuid, 5833 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5834 throws com.liferay.portal.kernel.exception.SystemException, 5835 com.liferay.portlet.journal.NoSuchArticleException { 5836 return getPersistence() 5837 .findByG_C_L_First(groupId, classNameId, layoutUuid, 5838 orderByComparator); 5839 } 5840 5841 /** 5842 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 5843 * 5844 * @param groupId the group ID 5845 * @param classNameId the class name ID 5846 * @param layoutUuid the layout uuid 5847 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5848 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5849 * @throws SystemException if a system exception occurred 5850 */ 5851 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First( 5852 long groupId, long classNameId, java.lang.String layoutUuid, 5853 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5854 throws com.liferay.portal.kernel.exception.SystemException { 5855 return getPersistence() 5856 .fetchByG_C_L_First(groupId, classNameId, layoutUuid, 5857 orderByComparator); 5858 } 5859 5860 /** 5861 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 5862 * 5863 * @param groupId the group ID 5864 * @param classNameId the class name ID 5865 * @param layoutUuid the layout uuid 5866 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5867 * @return the last matching journal article 5868 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5869 * @throws SystemException if a system exception occurred 5870 */ 5871 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last( 5872 long groupId, long classNameId, java.lang.String layoutUuid, 5873 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5874 throws com.liferay.portal.kernel.exception.SystemException, 5875 com.liferay.portlet.journal.NoSuchArticleException { 5876 return getPersistence() 5877 .findByG_C_L_Last(groupId, classNameId, layoutUuid, 5878 orderByComparator); 5879 } 5880 5881 /** 5882 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 5883 * 5884 * @param groupId the group ID 5885 * @param classNameId the class name ID 5886 * @param layoutUuid the layout uuid 5887 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5888 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5889 * @throws SystemException if a system exception occurred 5890 */ 5891 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last( 5892 long groupId, long classNameId, java.lang.String layoutUuid, 5893 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5894 throws com.liferay.portal.kernel.exception.SystemException { 5895 return getPersistence() 5896 .fetchByG_C_L_Last(groupId, classNameId, layoutUuid, 5897 orderByComparator); 5898 } 5899 5900 /** 5901 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 5902 * 5903 * @param id the primary key of the current journal article 5904 * @param groupId the group ID 5905 * @param classNameId the class name ID 5906 * @param layoutUuid the layout uuid 5907 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5908 * @return the previous, current, and next journal article 5909 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5910 * @throws SystemException if a system exception occurred 5911 */ 5912 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext( 5913 long id, long groupId, long classNameId, java.lang.String layoutUuid, 5914 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5915 throws com.liferay.portal.kernel.exception.SystemException, 5916 com.liferay.portlet.journal.NoSuchArticleException { 5917 return getPersistence() 5918 .findByG_C_L_PrevAndNext(id, groupId, classNameId, 5919 layoutUuid, orderByComparator); 5920 } 5921 5922 /** 5923 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 5924 * 5925 * @param groupId the group ID 5926 * @param classNameId the class name ID 5927 * @param layoutUuid the layout uuid 5928 * @return the matching journal articles that the user has permission to view 5929 * @throws SystemException if a system exception occurred 5930 */ 5931 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 5932 long groupId, long classNameId, java.lang.String layoutUuid) 5933 throws com.liferay.portal.kernel.exception.SystemException { 5934 return getPersistence() 5935 .filterFindByG_C_L(groupId, classNameId, layoutUuid); 5936 } 5937 5938 /** 5939 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 5940 * 5941 * <p> 5942 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5943 * </p> 5944 * 5945 * @param groupId the group ID 5946 * @param classNameId the class name ID 5947 * @param layoutUuid the layout uuid 5948 * @param start the lower bound of the range of journal articles 5949 * @param end the upper bound of the range of journal articles (not inclusive) 5950 * @return the range of matching journal articles that the user has permission to view 5951 * @throws SystemException if a system exception occurred 5952 */ 5953 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 5954 long groupId, long classNameId, java.lang.String layoutUuid, int start, 5955 int end) throws com.liferay.portal.kernel.exception.SystemException { 5956 return getPersistence() 5957 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 5958 end); 5959 } 5960 5961 /** 5962 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and layoutUuid = ?. 5963 * 5964 * <p> 5965 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5966 * </p> 5967 * 5968 * @param groupId the group ID 5969 * @param classNameId the class name ID 5970 * @param layoutUuid the layout uuid 5971 * @param start the lower bound of the range of journal articles 5972 * @param end the upper bound of the range of journal articles (not inclusive) 5973 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5974 * @return the ordered range of matching journal articles that the user has permission to view 5975 * @throws SystemException if a system exception occurred 5976 */ 5977 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 5978 long groupId, long classNameId, java.lang.String layoutUuid, int start, 5979 int end, 5980 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5981 throws com.liferay.portal.kernel.exception.SystemException { 5982 return getPersistence() 5983 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 5984 end, orderByComparator); 5985 } 5986 5987 /** 5988 * 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 = ?. 5989 * 5990 * @param id the primary key of the current journal article 5991 * @param groupId the group ID 5992 * @param classNameId the class name ID 5993 * @param layoutUuid the layout uuid 5994 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5995 * @return the previous, current, and next journal article 5996 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5997 * @throws SystemException if a system exception occurred 5998 */ 5999 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext( 6000 long id, long groupId, long classNameId, java.lang.String layoutUuid, 6001 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6002 throws com.liferay.portal.kernel.exception.SystemException, 6003 com.liferay.portlet.journal.NoSuchArticleException { 6004 return getPersistence() 6005 .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId, 6006 layoutUuid, orderByComparator); 6007 } 6008 6009 /** 6010 * Removes all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ? from the database. 6011 * 6012 * @param groupId the group ID 6013 * @param classNameId the class name ID 6014 * @param layoutUuid the layout uuid 6015 * @throws SystemException if a system exception occurred 6016 */ 6017 public static void removeByG_C_L(long groupId, long classNameId, 6018 java.lang.String layoutUuid) 6019 throws com.liferay.portal.kernel.exception.SystemException { 6020 getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid); 6021 } 6022 6023 /** 6024 * Returns the number of journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6025 * 6026 * @param groupId the group ID 6027 * @param classNameId the class name ID 6028 * @param layoutUuid the layout uuid 6029 * @return the number of matching journal articles 6030 * @throws SystemException if a system exception occurred 6031 */ 6032 public static int countByG_C_L(long groupId, long classNameId, 6033 java.lang.String layoutUuid) 6034 throws com.liferay.portal.kernel.exception.SystemException { 6035 return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid); 6036 } 6037 6038 /** 6039 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6040 * 6041 * @param groupId the group ID 6042 * @param classNameId the class name ID 6043 * @param layoutUuid the layout uuid 6044 * @return the number of matching journal articles that the user has permission to view 6045 * @throws SystemException if a system exception occurred 6046 */ 6047 public static int filterCountByG_C_L(long groupId, long classNameId, 6048 java.lang.String layoutUuid) 6049 throws com.liferay.portal.kernel.exception.SystemException { 6050 return getPersistence() 6051 .filterCountByG_C_L(groupId, classNameId, layoutUuid); 6052 } 6053 6054 /** 6055 * Returns all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6056 * 6057 * @param groupId the group ID 6058 * @param userId the user ID 6059 * @param classNameId the class name ID 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_U_C( 6064 long groupId, long userId, long classNameId) 6065 throws com.liferay.portal.kernel.exception.SystemException { 6066 return getPersistence().findByG_U_C(groupId, userId, classNameId); 6067 } 6068 6069 /** 6070 * Returns a range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 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 userId the user ID 6078 * @param classNameId the class name ID 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_U_C( 6085 long groupId, long userId, long classNameId, int start, int end) 6086 throws com.liferay.portal.kernel.exception.SystemException { 6087 return getPersistence() 6088 .findByG_U_C(groupId, userId, classNameId, start, end); 6089 } 6090 6091 /** 6092 * Returns an ordered range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 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 userId the user ID 6100 * @param classNameId the class name ID 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_U_C( 6108 long groupId, long userId, long classNameId, 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_U_C(groupId, userId, classNameId, start, end, 6113 orderByComparator); 6114 } 6115 6116 /** 6117 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6118 * 6119 * @param groupId the group ID 6120 * @param userId the user ID 6121 * @param classNameId the class name ID 6122 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6123 * @return the first matching journal article 6124 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6125 * @throws SystemException if a system exception occurred 6126 */ 6127 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First( 6128 long groupId, long userId, long classNameId, 6129 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6130 throws com.liferay.portal.kernel.exception.SystemException, 6131 com.liferay.portlet.journal.NoSuchArticleException { 6132 return getPersistence() 6133 .findByG_U_C_First(groupId, userId, classNameId, 6134 orderByComparator); 6135 } 6136 6137 /** 6138 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6139 * 6140 * @param groupId the group ID 6141 * @param userId the user ID 6142 * @param classNameId the class name ID 6143 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6144 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6145 * @throws SystemException if a system exception occurred 6146 */ 6147 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First( 6148 long groupId, long userId, long classNameId, 6149 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6150 throws com.liferay.portal.kernel.exception.SystemException { 6151 return getPersistence() 6152 .fetchByG_U_C_First(groupId, userId, classNameId, 6153 orderByComparator); 6154 } 6155 6156 /** 6157 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6158 * 6159 * @param groupId the group ID 6160 * @param userId the user ID 6161 * @param classNameId the class name ID 6162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6163 * @return the last matching journal article 6164 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6165 * @throws SystemException if a system exception occurred 6166 */ 6167 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last( 6168 long groupId, long userId, long classNameId, 6169 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6170 throws com.liferay.portal.kernel.exception.SystemException, 6171 com.liferay.portlet.journal.NoSuchArticleException { 6172 return getPersistence() 6173 .findByG_U_C_Last(groupId, userId, classNameId, 6174 orderByComparator); 6175 } 6176 6177 /** 6178 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6179 * 6180 * @param groupId the group ID 6181 * @param userId the user ID 6182 * @param classNameId the class name ID 6183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6184 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6185 * @throws SystemException if a system exception occurred 6186 */ 6187 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last( 6188 long groupId, long userId, long classNameId, 6189 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6190 throws com.liferay.portal.kernel.exception.SystemException { 6191 return getPersistence() 6192 .fetchByG_U_C_Last(groupId, userId, classNameId, 6193 orderByComparator); 6194 } 6195 6196 /** 6197 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6198 * 6199 * @param id the primary key of the current journal article 6200 * @param groupId the group ID 6201 * @param userId the user ID 6202 * @param classNameId the class name ID 6203 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6204 * @return the previous, current, and next journal article 6205 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6206 * @throws SystemException if a system exception occurred 6207 */ 6208 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext( 6209 long id, long groupId, long userId, long classNameId, 6210 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6211 throws com.liferay.portal.kernel.exception.SystemException, 6212 com.liferay.portlet.journal.NoSuchArticleException { 6213 return getPersistence() 6214 .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId, 6215 orderByComparator); 6216 } 6217 6218 /** 6219 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6220 * 6221 * @param groupId the group ID 6222 * @param userId the user ID 6223 * @param classNameId the class name ID 6224 * @return the matching journal articles that the user has permission to view 6225 * @throws SystemException if a system exception occurred 6226 */ 6227 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6228 long groupId, long userId, long classNameId) 6229 throws com.liferay.portal.kernel.exception.SystemException { 6230 return getPersistence().filterFindByG_U_C(groupId, userId, classNameId); 6231 } 6232 6233 /** 6234 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6235 * 6236 * <p> 6237 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6238 * </p> 6239 * 6240 * @param groupId the group ID 6241 * @param userId the user ID 6242 * @param classNameId the class name ID 6243 * @param start the lower bound of the range of journal articles 6244 * @param end the upper bound of the range of journal articles (not inclusive) 6245 * @return the range of matching journal articles that the user has permission to view 6246 * @throws SystemException if a system exception occurred 6247 */ 6248 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6249 long groupId, long userId, long classNameId, int start, int end) 6250 throws com.liferay.portal.kernel.exception.SystemException { 6251 return getPersistence() 6252 .filterFindByG_U_C(groupId, userId, classNameId, start, end); 6253 } 6254 6255 /** 6256 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ? and classNameId = ?. 6257 * 6258 * <p> 6259 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6260 * </p> 6261 * 6262 * @param groupId the group ID 6263 * @param userId the user ID 6264 * @param classNameId the class name ID 6265 * @param start the lower bound of the range of journal articles 6266 * @param end the upper bound of the range of journal articles (not inclusive) 6267 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6268 * @return the ordered range of matching journal articles that the user has permission to view 6269 * @throws SystemException if a system exception occurred 6270 */ 6271 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6272 long groupId, long userId, long classNameId, int start, int end, 6273 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6274 throws com.liferay.portal.kernel.exception.SystemException { 6275 return getPersistence() 6276 .filterFindByG_U_C(groupId, userId, classNameId, start, end, 6277 orderByComparator); 6278 } 6279 6280 /** 6281 * 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 = ?. 6282 * 6283 * @param id the primary key of the current journal article 6284 * @param groupId the group ID 6285 * @param userId the user ID 6286 * @param classNameId the class name ID 6287 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6288 * @return the previous, current, and next journal article 6289 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6290 * @throws SystemException if a system exception occurred 6291 */ 6292 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext( 6293 long id, long groupId, long userId, long classNameId, 6294 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6295 throws com.liferay.portal.kernel.exception.SystemException, 6296 com.liferay.portlet.journal.NoSuchArticleException { 6297 return getPersistence() 6298 .filterFindByG_U_C_PrevAndNext(id, groupId, userId, 6299 classNameId, orderByComparator); 6300 } 6301 6302 /** 6303 * Removes all the journal articles where groupId = ? and userId = ? and classNameId = ? from the database. 6304 * 6305 * @param groupId the group ID 6306 * @param userId the user ID 6307 * @param classNameId the class name ID 6308 * @throws SystemException if a system exception occurred 6309 */ 6310 public static void removeByG_U_C(long groupId, long userId, long classNameId) 6311 throws com.liferay.portal.kernel.exception.SystemException { 6312 getPersistence().removeByG_U_C(groupId, userId, classNameId); 6313 } 6314 6315 /** 6316 * Returns the number of journal articles where groupId = ? and userId = ? and classNameId = ?. 6317 * 6318 * @param groupId the group ID 6319 * @param userId the user ID 6320 * @param classNameId the class name ID 6321 * @return the number of matching journal articles 6322 * @throws SystemException if a system exception occurred 6323 */ 6324 public static int countByG_U_C(long groupId, long userId, long classNameId) 6325 throws com.liferay.portal.kernel.exception.SystemException { 6326 return getPersistence().countByG_U_C(groupId, userId, classNameId); 6327 } 6328 6329 /** 6330 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6331 * 6332 * @param groupId the group ID 6333 * @param userId the user ID 6334 * @param classNameId the class name ID 6335 * @return the number of matching journal articles that the user has permission to view 6336 * @throws SystemException if a system exception occurred 6337 */ 6338 public static int filterCountByG_U_C(long groupId, long userId, 6339 long classNameId) 6340 throws com.liferay.portal.kernel.exception.SystemException { 6341 return getPersistence().filterCountByG_U_C(groupId, userId, classNameId); 6342 } 6343 6344 /** 6345 * 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. 6346 * 6347 * @param groupId the group ID 6348 * @param articleId the article ID 6349 * @param version the version 6350 * @return the matching journal article 6351 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6352 * @throws SystemException if a system exception occurred 6353 */ 6354 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V( 6355 long groupId, java.lang.String articleId, double version) 6356 throws com.liferay.portal.kernel.exception.SystemException, 6357 com.liferay.portlet.journal.NoSuchArticleException { 6358 return getPersistence().findByG_A_V(groupId, articleId, version); 6359 } 6360 6361 /** 6362 * 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. 6363 * 6364 * @param groupId the group ID 6365 * @param articleId the article ID 6366 * @param version the version 6367 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6368 * @throws SystemException if a system exception occurred 6369 */ 6370 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 6371 long groupId, java.lang.String articleId, double version) 6372 throws com.liferay.portal.kernel.exception.SystemException { 6373 return getPersistence().fetchByG_A_V(groupId, articleId, version); 6374 } 6375 6376 /** 6377 * 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. 6378 * 6379 * @param groupId the group ID 6380 * @param articleId the article ID 6381 * @param version the version 6382 * @param retrieveFromCache whether to use the finder cache 6383 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6384 * @throws SystemException if a system exception occurred 6385 */ 6386 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 6387 long groupId, java.lang.String articleId, double version, 6388 boolean retrieveFromCache) 6389 throws com.liferay.portal.kernel.exception.SystemException { 6390 return getPersistence() 6391 .fetchByG_A_V(groupId, articleId, version, retrieveFromCache); 6392 } 6393 6394 /** 6395 * Removes the journal article where groupId = ? and articleId = ? and version = ? from the database. 6396 * 6397 * @param groupId the group ID 6398 * @param articleId the article ID 6399 * @param version the version 6400 * @return the journal article that was removed 6401 * @throws SystemException if a system exception occurred 6402 */ 6403 public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V( 6404 long groupId, java.lang.String articleId, double version) 6405 throws com.liferay.portal.kernel.exception.SystemException, 6406 com.liferay.portlet.journal.NoSuchArticleException { 6407 return getPersistence().removeByG_A_V(groupId, articleId, version); 6408 } 6409 6410 /** 6411 * Returns the number of journal articles where groupId = ? and articleId = ? and version = ?. 6412 * 6413 * @param groupId the group ID 6414 * @param articleId the article ID 6415 * @param version the version 6416 * @return the number of matching journal articles 6417 * @throws SystemException if a system exception occurred 6418 */ 6419 public static int countByG_A_V(long groupId, java.lang.String articleId, 6420 double version) 6421 throws com.liferay.portal.kernel.exception.SystemException { 6422 return getPersistence().countByG_A_V(groupId, articleId, version); 6423 } 6424 6425 /** 6426 * Returns all the journal articles where groupId = ? and articleId = ? and status = ?. 6427 * 6428 * @param groupId the group ID 6429 * @param articleId the article ID 6430 * @param status the status 6431 * @return the matching journal articles 6432 * @throws SystemException if a system exception occurred 6433 */ 6434 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6435 long groupId, java.lang.String articleId, int status) 6436 throws com.liferay.portal.kernel.exception.SystemException { 6437 return getPersistence().findByG_A_ST(groupId, articleId, status); 6438 } 6439 6440 /** 6441 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = ?. 6442 * 6443 * <p> 6444 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6445 * </p> 6446 * 6447 * @param groupId the group ID 6448 * @param articleId the article ID 6449 * @param status the status 6450 * @param start the lower bound of the range of journal articles 6451 * @param end the upper bound of the range of journal articles (not inclusive) 6452 * @return the range of matching journal articles 6453 * @throws SystemException if a system exception occurred 6454 */ 6455 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6456 long groupId, java.lang.String articleId, int status, int start, int end) 6457 throws com.liferay.portal.kernel.exception.SystemException { 6458 return getPersistence() 6459 .findByG_A_ST(groupId, articleId, status, start, end); 6460 } 6461 6462 /** 6463 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = ?. 6464 * 6465 * <p> 6466 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6467 * </p> 6468 * 6469 * @param groupId the group ID 6470 * @param articleId the article ID 6471 * @param status the status 6472 * @param start the lower bound of the range of journal articles 6473 * @param end the upper bound of the range of journal articles (not inclusive) 6474 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6475 * @return the ordered range of matching journal articles 6476 * @throws SystemException if a system exception occurred 6477 */ 6478 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6479 long groupId, java.lang.String articleId, int status, int start, 6480 int end, 6481 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6482 throws com.liferay.portal.kernel.exception.SystemException { 6483 return getPersistence() 6484 .findByG_A_ST(groupId, articleId, status, start, end, 6485 orderByComparator); 6486 } 6487 6488 /** 6489 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6490 * 6491 * @param groupId the group ID 6492 * @param articleId the article ID 6493 * @param status the status 6494 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6495 * @return the first matching journal article 6496 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6497 * @throws SystemException if a system exception occurred 6498 */ 6499 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First( 6500 long groupId, java.lang.String articleId, int status, 6501 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6502 throws com.liferay.portal.kernel.exception.SystemException, 6503 com.liferay.portlet.journal.NoSuchArticleException { 6504 return getPersistence() 6505 .findByG_A_ST_First(groupId, articleId, status, 6506 orderByComparator); 6507 } 6508 6509 /** 6510 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6511 * 6512 * @param groupId the group ID 6513 * @param articleId the article ID 6514 * @param status the status 6515 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6516 * @return the first 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_A_ST_First( 6520 long groupId, java.lang.String articleId, int status, 6521 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6522 throws com.liferay.portal.kernel.exception.SystemException { 6523 return getPersistence() 6524 .fetchByG_A_ST_First(groupId, articleId, status, 6525 orderByComparator); 6526 } 6527 6528 /** 6529 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6530 * 6531 * @param groupId the group ID 6532 * @param articleId the article ID 6533 * @param status the status 6534 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6535 * @return the last matching journal article 6536 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6537 * @throws SystemException if a system exception occurred 6538 */ 6539 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last( 6540 long groupId, java.lang.String articleId, int status, 6541 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6542 throws com.liferay.portal.kernel.exception.SystemException, 6543 com.liferay.portlet.journal.NoSuchArticleException { 6544 return getPersistence() 6545 .findByG_A_ST_Last(groupId, articleId, status, 6546 orderByComparator); 6547 } 6548 6549 /** 6550 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6551 * 6552 * @param groupId the group ID 6553 * @param articleId the article ID 6554 * @param status the status 6555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6556 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6557 * @throws SystemException if a system exception occurred 6558 */ 6559 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last( 6560 long groupId, java.lang.String articleId, int status, 6561 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6562 throws com.liferay.portal.kernel.exception.SystemException { 6563 return getPersistence() 6564 .fetchByG_A_ST_Last(groupId, articleId, status, 6565 orderByComparator); 6566 } 6567 6568 /** 6569 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6570 * 6571 * @param id the primary key of the current journal article 6572 * @param groupId the group ID 6573 * @param articleId the article ID 6574 * @param status the status 6575 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6576 * @return the previous, current, and next journal article 6577 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6578 * @throws SystemException if a system exception occurred 6579 */ 6580 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext( 6581 long id, long groupId, java.lang.String articleId, int status, 6582 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6583 throws com.liferay.portal.kernel.exception.SystemException, 6584 com.liferay.portlet.journal.NoSuchArticleException { 6585 return getPersistence() 6586 .findByG_A_ST_PrevAndNext(id, groupId, articleId, status, 6587 orderByComparator); 6588 } 6589 6590 /** 6591 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 6592 * 6593 * @param groupId the group ID 6594 * @param articleId the article ID 6595 * @param status the status 6596 * @return the matching journal articles that the user has permission to view 6597 * @throws SystemException if a system exception occurred 6598 */ 6599 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6600 long groupId, java.lang.String articleId, int status) 6601 throws com.liferay.portal.kernel.exception.SystemException { 6602 return getPersistence().filterFindByG_A_ST(groupId, articleId, status); 6603 } 6604 6605 /** 6606 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 6607 * 6608 * <p> 6609 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6610 * </p> 6611 * 6612 * @param groupId the group ID 6613 * @param articleId the article ID 6614 * @param status the status 6615 * @param start the lower bound of the range of journal articles 6616 * @param end the upper bound of the range of journal articles (not inclusive) 6617 * @return the range of matching journal articles that the user has permission to view 6618 * @throws SystemException if a system exception occurred 6619 */ 6620 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6621 long groupId, java.lang.String articleId, int status, int start, int end) 6622 throws com.liferay.portal.kernel.exception.SystemException { 6623 return getPersistence() 6624 .filterFindByG_A_ST(groupId, articleId, status, start, end); 6625 } 6626 6627 /** 6628 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status = ?. 6629 * 6630 * <p> 6631 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6632 * </p> 6633 * 6634 * @param groupId the group ID 6635 * @param articleId the article ID 6636 * @param status the status 6637 * @param start the lower bound of the range of journal articles 6638 * @param end the upper bound of the range of journal articles (not inclusive) 6639 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6640 * @return the ordered range of matching journal articles that the user has permission to view 6641 * @throws SystemException if a system exception occurred 6642 */ 6643 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6644 long groupId, java.lang.String articleId, int status, int start, 6645 int end, 6646 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6647 throws com.liferay.portal.kernel.exception.SystemException { 6648 return getPersistence() 6649 .filterFindByG_A_ST(groupId, articleId, status, start, end, 6650 orderByComparator); 6651 } 6652 6653 /** 6654 * 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 = ?. 6655 * 6656 * @param id the primary key of the current journal article 6657 * @param groupId the group ID 6658 * @param articleId the article ID 6659 * @param status the status 6660 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6661 * @return the previous, current, and next journal article 6662 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6663 * @throws SystemException if a system exception occurred 6664 */ 6665 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext( 6666 long id, long groupId, java.lang.String articleId, int status, 6667 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6668 throws com.liferay.portal.kernel.exception.SystemException, 6669 com.liferay.portlet.journal.NoSuchArticleException { 6670 return getPersistence() 6671 .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId, 6672 status, orderByComparator); 6673 } 6674 6675 /** 6676 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 6677 * 6678 * @param groupId the group ID 6679 * @param articleId the article ID 6680 * @param statuses the statuses 6681 * @return the matching journal articles that the user has permission to view 6682 * @throws SystemException if a system exception occurred 6683 */ 6684 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6685 long groupId, java.lang.String articleId, int[] statuses) 6686 throws com.liferay.portal.kernel.exception.SystemException { 6687 return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses); 6688 } 6689 6690 /** 6691 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 6692 * 6693 * <p> 6694 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6695 * </p> 6696 * 6697 * @param groupId the group ID 6698 * @param articleId the article ID 6699 * @param statuses the statuses 6700 * @param start the lower bound of the range of journal articles 6701 * @param end the upper bound of the range of journal articles (not inclusive) 6702 * @return the range of matching journal articles that the user has permission to view 6703 * @throws SystemException if a system exception occurred 6704 */ 6705 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6706 long groupId, java.lang.String articleId, int[] statuses, int start, 6707 int end) throws com.liferay.portal.kernel.exception.SystemException { 6708 return getPersistence() 6709 .filterFindByG_A_ST(groupId, articleId, statuses, start, end); 6710 } 6711 6712 /** 6713 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 6714 * 6715 * <p> 6716 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6717 * </p> 6718 * 6719 * @param groupId the group ID 6720 * @param articleId the article ID 6721 * @param statuses the statuses 6722 * @param start the lower bound of the range of journal articles 6723 * @param end the upper bound of the range of journal articles (not inclusive) 6724 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6725 * @return the ordered range of matching journal articles that the user has permission to view 6726 * @throws SystemException if a system exception occurred 6727 */ 6728 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6729 long groupId, java.lang.String articleId, int[] statuses, int start, 6730 int end, 6731 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6732 throws com.liferay.portal.kernel.exception.SystemException { 6733 return getPersistence() 6734 .filterFindByG_A_ST(groupId, articleId, statuses, start, 6735 end, orderByComparator); 6736 } 6737 6738 /** 6739 * Returns all the journal articles where groupId = ? and articleId = ? and status = any ?. 6740 * 6741 * <p> 6742 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6743 * </p> 6744 * 6745 * @param groupId the group ID 6746 * @param articleId the article ID 6747 * @param statuses the statuses 6748 * @return the matching journal articles 6749 * @throws SystemException if a system exception occurred 6750 */ 6751 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6752 long groupId, java.lang.String articleId, int[] statuses) 6753 throws com.liferay.portal.kernel.exception.SystemException { 6754 return getPersistence().findByG_A_ST(groupId, articleId, statuses); 6755 } 6756 6757 /** 6758 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 6759 * 6760 * <p> 6761 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6762 * </p> 6763 * 6764 * @param groupId the group ID 6765 * @param articleId the article ID 6766 * @param statuses the statuses 6767 * @param start the lower bound of the range of journal articles 6768 * @param end the upper bound of the range of journal articles (not inclusive) 6769 * @return the range of matching journal articles 6770 * @throws SystemException if a system exception occurred 6771 */ 6772 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6773 long groupId, java.lang.String articleId, int[] statuses, int start, 6774 int end) throws com.liferay.portal.kernel.exception.SystemException { 6775 return getPersistence() 6776 .findByG_A_ST(groupId, articleId, statuses, start, end); 6777 } 6778 6779 /** 6780 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 6781 * 6782 * <p> 6783 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6784 * </p> 6785 * 6786 * @param groupId the group ID 6787 * @param articleId the article ID 6788 * @param statuses the statuses 6789 * @param start the lower bound of the range of journal articles 6790 * @param end the upper bound of the range of journal articles (not inclusive) 6791 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6792 * @return the ordered range of matching journal articles 6793 * @throws SystemException if a system exception occurred 6794 */ 6795 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6796 long groupId, java.lang.String articleId, int[] statuses, int start, 6797 int end, 6798 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6799 throws com.liferay.portal.kernel.exception.SystemException { 6800 return getPersistence() 6801 .findByG_A_ST(groupId, articleId, statuses, start, end, 6802 orderByComparator); 6803 } 6804 6805 /** 6806 * Removes all the journal articles where groupId = ? and articleId = ? and status = ? from the database. 6807 * 6808 * @param groupId the group ID 6809 * @param articleId the article ID 6810 * @param status the status 6811 * @throws SystemException if a system exception occurred 6812 */ 6813 public static void removeByG_A_ST(long groupId, java.lang.String articleId, 6814 int status) throws com.liferay.portal.kernel.exception.SystemException { 6815 getPersistence().removeByG_A_ST(groupId, articleId, status); 6816 } 6817 6818 /** 6819 * Returns the number of journal articles where groupId = ? and articleId = ? and status = ?. 6820 * 6821 * @param groupId the group ID 6822 * @param articleId the article ID 6823 * @param status the status 6824 * @return the number of matching journal articles 6825 * @throws SystemException if a system exception occurred 6826 */ 6827 public static int countByG_A_ST(long groupId, java.lang.String articleId, 6828 int status) throws com.liferay.portal.kernel.exception.SystemException { 6829 return getPersistence().countByG_A_ST(groupId, articleId, status); 6830 } 6831 6832 /** 6833 * Returns the number of journal articles where groupId = ? and articleId = ? and status = any ?. 6834 * 6835 * @param groupId the group ID 6836 * @param articleId the article ID 6837 * @param statuses the statuses 6838 * @return the number of matching journal articles 6839 * @throws SystemException if a system exception occurred 6840 */ 6841 public static int countByG_A_ST(long groupId, java.lang.String articleId, 6842 int[] statuses) 6843 throws com.liferay.portal.kernel.exception.SystemException { 6844 return getPersistence().countByG_A_ST(groupId, articleId, statuses); 6845 } 6846 6847 /** 6848 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 6849 * 6850 * @param groupId the group ID 6851 * @param articleId the article ID 6852 * @param status the status 6853 * @return the number of matching journal articles that the user has permission to view 6854 * @throws SystemException if a system exception occurred 6855 */ 6856 public static int filterCountByG_A_ST(long groupId, 6857 java.lang.String articleId, int status) 6858 throws com.liferay.portal.kernel.exception.SystemException { 6859 return getPersistence().filterCountByG_A_ST(groupId, articleId, status); 6860 } 6861 6862 /** 6863 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 6864 * 6865 * @param groupId the group ID 6866 * @param articleId the article ID 6867 * @param statuses the statuses 6868 * @return the number of matching journal articles that the user has permission to view 6869 * @throws SystemException if a system exception occurred 6870 */ 6871 public static int filterCountByG_A_ST(long groupId, 6872 java.lang.String articleId, int[] statuses) 6873 throws com.liferay.portal.kernel.exception.SystemException { 6874 return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses); 6875 } 6876 6877 /** 6878 * Returns all the journal articles where groupId = ? and urlTitle = ? and status = ?. 6879 * 6880 * @param groupId the group ID 6881 * @param urlTitle the url title 6882 * @param status the status 6883 * @return the 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_UT_ST( 6887 long groupId, java.lang.String urlTitle, int status) 6888 throws com.liferay.portal.kernel.exception.SystemException { 6889 return getPersistence().findByG_UT_ST(groupId, urlTitle, status); 6890 } 6891 6892 /** 6893 * Returns a range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 6894 * 6895 * <p> 6896 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6897 * </p> 6898 * 6899 * @param groupId the group ID 6900 * @param urlTitle the url title 6901 * @param status the status 6902 * @param start the lower bound of the range of journal articles 6903 * @param end the upper bound of the range of journal articles (not inclusive) 6904 * @return the range of matching journal articles 6905 * @throws SystemException if a system exception occurred 6906 */ 6907 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 6908 long groupId, java.lang.String urlTitle, int status, int start, int end) 6909 throws com.liferay.portal.kernel.exception.SystemException { 6910 return getPersistence() 6911 .findByG_UT_ST(groupId, urlTitle, status, start, end); 6912 } 6913 6914 /** 6915 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 6916 * 6917 * <p> 6918 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6919 * </p> 6920 * 6921 * @param groupId the group ID 6922 * @param urlTitle the url title 6923 * @param status the status 6924 * @param start the lower bound of the range of journal articles 6925 * @param end the upper bound of the range of journal articles (not inclusive) 6926 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6927 * @return the ordered range of matching journal articles 6928 * @throws SystemException if a system exception occurred 6929 */ 6930 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 6931 long groupId, java.lang.String urlTitle, int status, int start, 6932 int end, 6933 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6934 throws com.liferay.portal.kernel.exception.SystemException { 6935 return getPersistence() 6936 .findByG_UT_ST(groupId, urlTitle, status, start, end, 6937 orderByComparator); 6938 } 6939 6940 /** 6941 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 6942 * 6943 * @param groupId the group ID 6944 * @param urlTitle the url title 6945 * @param status the status 6946 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6947 * @return the first matching journal article 6948 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6949 * @throws SystemException if a system exception occurred 6950 */ 6951 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First( 6952 long groupId, java.lang.String urlTitle, int status, 6953 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6954 throws com.liferay.portal.kernel.exception.SystemException, 6955 com.liferay.portlet.journal.NoSuchArticleException { 6956 return getPersistence() 6957 .findByG_UT_ST_First(groupId, urlTitle, status, 6958 orderByComparator); 6959 } 6960 6961 /** 6962 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 6963 * 6964 * @param groupId the group ID 6965 * @param urlTitle the url title 6966 * @param status the status 6967 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6968 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6969 * @throws SystemException if a system exception occurred 6970 */ 6971 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First( 6972 long groupId, java.lang.String urlTitle, int status, 6973 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6974 throws com.liferay.portal.kernel.exception.SystemException { 6975 return getPersistence() 6976 .fetchByG_UT_ST_First(groupId, urlTitle, status, 6977 orderByComparator); 6978 } 6979 6980 /** 6981 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 6982 * 6983 * @param groupId the group ID 6984 * @param urlTitle the url title 6985 * @param status the status 6986 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6987 * @return the last matching journal article 6988 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6989 * @throws SystemException if a system exception occurred 6990 */ 6991 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last( 6992 long groupId, java.lang.String urlTitle, int status, 6993 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6994 throws com.liferay.portal.kernel.exception.SystemException, 6995 com.liferay.portlet.journal.NoSuchArticleException { 6996 return getPersistence() 6997 .findByG_UT_ST_Last(groupId, urlTitle, status, 6998 orderByComparator); 6999 } 7000 7001 /** 7002 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7003 * 7004 * @param groupId the group ID 7005 * @param urlTitle the url title 7006 * @param status the status 7007 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7008 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7009 * @throws SystemException if a system exception occurred 7010 */ 7011 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last( 7012 long groupId, java.lang.String urlTitle, int status, 7013 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7014 throws com.liferay.portal.kernel.exception.SystemException { 7015 return getPersistence() 7016 .fetchByG_UT_ST_Last(groupId, urlTitle, status, 7017 orderByComparator); 7018 } 7019 7020 /** 7021 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7022 * 7023 * @param id the primary key of the current journal article 7024 * @param groupId the group ID 7025 * @param urlTitle the url title 7026 * @param status the status 7027 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7028 * @return the previous, current, and next journal article 7029 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7030 * @throws SystemException if a system exception occurred 7031 */ 7032 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext( 7033 long id, long groupId, java.lang.String urlTitle, int status, 7034 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7035 throws com.liferay.portal.kernel.exception.SystemException, 7036 com.liferay.portlet.journal.NoSuchArticleException { 7037 return getPersistence() 7038 .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status, 7039 orderByComparator); 7040 } 7041 7042 /** 7043 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7044 * 7045 * @param groupId the group ID 7046 * @param urlTitle the url title 7047 * @param status the status 7048 * @return the matching journal articles that the user has permission to view 7049 * @throws SystemException if a system exception occurred 7050 */ 7051 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7052 long groupId, java.lang.String urlTitle, int status) 7053 throws com.liferay.portal.kernel.exception.SystemException { 7054 return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status); 7055 } 7056 7057 /** 7058 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7059 * 7060 * <p> 7061 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7062 * </p> 7063 * 7064 * @param groupId the group ID 7065 * @param urlTitle the url title 7066 * @param status the status 7067 * @param start the lower bound of the range of journal articles 7068 * @param end the upper bound of the range of journal articles (not inclusive) 7069 * @return the range of matching journal articles that the user has permission to view 7070 * @throws SystemException if a system exception occurred 7071 */ 7072 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7073 long groupId, java.lang.String urlTitle, int status, int start, int end) 7074 throws com.liferay.portal.kernel.exception.SystemException { 7075 return getPersistence() 7076 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end); 7077 } 7078 7079 /** 7080 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ? and status = ?. 7081 * 7082 * <p> 7083 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7084 * </p> 7085 * 7086 * @param groupId the group ID 7087 * @param urlTitle the url title 7088 * @param status the status 7089 * @param start the lower bound of the range of journal articles 7090 * @param end the upper bound of the range of journal articles (not inclusive) 7091 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7092 * @return the ordered range of matching journal articles that the user has permission to view 7093 * @throws SystemException if a system exception occurred 7094 */ 7095 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7096 long groupId, java.lang.String urlTitle, int status, int start, 7097 int end, 7098 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7099 throws com.liferay.portal.kernel.exception.SystemException { 7100 return getPersistence() 7101 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end, 7102 orderByComparator); 7103 } 7104 7105 /** 7106 * 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 = ?. 7107 * 7108 * @param id the primary key of the current journal article 7109 * @param groupId the group ID 7110 * @param urlTitle the url title 7111 * @param status the status 7112 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7113 * @return the previous, current, and next journal article 7114 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7115 * @throws SystemException if a system exception occurred 7116 */ 7117 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext( 7118 long id, long groupId, java.lang.String urlTitle, int status, 7119 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7120 throws com.liferay.portal.kernel.exception.SystemException, 7121 com.liferay.portlet.journal.NoSuchArticleException { 7122 return getPersistence() 7123 .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle, 7124 status, orderByComparator); 7125 } 7126 7127 /** 7128 * Removes all the journal articles where groupId = ? and urlTitle = ? and status = ? from the database. 7129 * 7130 * @param groupId the group ID 7131 * @param urlTitle the url title 7132 * @param status the status 7133 * @throws SystemException if a system exception occurred 7134 */ 7135 public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle, 7136 int status) throws com.liferay.portal.kernel.exception.SystemException { 7137 getPersistence().removeByG_UT_ST(groupId, urlTitle, status); 7138 } 7139 7140 /** 7141 * Returns the number of journal articles where groupId = ? and urlTitle = ? and status = ?. 7142 * 7143 * @param groupId the group ID 7144 * @param urlTitle the url title 7145 * @param status the status 7146 * @return the number of matching journal articles 7147 * @throws SystemException if a system exception occurred 7148 */ 7149 public static int countByG_UT_ST(long groupId, java.lang.String urlTitle, 7150 int status) throws com.liferay.portal.kernel.exception.SystemException { 7151 return getPersistence().countByG_UT_ST(groupId, urlTitle, status); 7152 } 7153 7154 /** 7155 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7156 * 7157 * @param groupId the group ID 7158 * @param urlTitle the url title 7159 * @param status the status 7160 * @return the number of matching journal articles that the user has permission to view 7161 * @throws SystemException if a system exception occurred 7162 */ 7163 public static int filterCountByG_UT_ST(long groupId, 7164 java.lang.String urlTitle, int status) 7165 throws com.liferay.portal.kernel.exception.SystemException { 7166 return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status); 7167 } 7168 7169 /** 7170 * Returns all the journal articles where companyId = ? and version = ? and status = ?. 7171 * 7172 * @param companyId the company ID 7173 * @param version the version 7174 * @param status the status 7175 * @return the matching journal articles 7176 * @throws SystemException if a system exception occurred 7177 */ 7178 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7179 long companyId, double version, int status) 7180 throws com.liferay.portal.kernel.exception.SystemException { 7181 return getPersistence().findByC_V_ST(companyId, version, status); 7182 } 7183 7184 /** 7185 * Returns a range of all the journal articles where companyId = ? and version = ? and status = ?. 7186 * 7187 * <p> 7188 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7189 * </p> 7190 * 7191 * @param companyId the company ID 7192 * @param version the version 7193 * @param status the status 7194 * @param start the lower bound of the range of journal articles 7195 * @param end the upper bound of the range of journal articles (not inclusive) 7196 * @return the range of matching journal articles 7197 * @throws SystemException if a system exception occurred 7198 */ 7199 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7200 long companyId, double version, int status, int start, int end) 7201 throws com.liferay.portal.kernel.exception.SystemException { 7202 return getPersistence() 7203 .findByC_V_ST(companyId, version, status, start, end); 7204 } 7205 7206 /** 7207 * Returns an ordered range of all the journal articles where companyId = ? and version = ? and status = ?. 7208 * 7209 * <p> 7210 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7211 * </p> 7212 * 7213 * @param companyId the company ID 7214 * @param version the version 7215 * @param status the status 7216 * @param start the lower bound of the range of journal articles 7217 * @param end the upper bound of the range of journal articles (not inclusive) 7218 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7219 * @return the ordered range of matching journal articles 7220 * @throws SystemException if a system exception occurred 7221 */ 7222 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7223 long companyId, double version, int status, int start, int end, 7224 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7225 throws com.liferay.portal.kernel.exception.SystemException { 7226 return getPersistence() 7227 .findByC_V_ST(companyId, version, status, start, end, 7228 orderByComparator); 7229 } 7230 7231 /** 7232 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 7233 * 7234 * @param companyId the company ID 7235 * @param version the version 7236 * @param status the status 7237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7238 * @return the first matching journal article 7239 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7240 * @throws SystemException if a system exception occurred 7241 */ 7242 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First( 7243 long companyId, double version, int status, 7244 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7245 throws com.liferay.portal.kernel.exception.SystemException, 7246 com.liferay.portlet.journal.NoSuchArticleException { 7247 return getPersistence() 7248 .findByC_V_ST_First(companyId, version, status, 7249 orderByComparator); 7250 } 7251 7252 /** 7253 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 7254 * 7255 * @param companyId the company ID 7256 * @param version the version 7257 * @param status the status 7258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7259 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7260 * @throws SystemException if a system exception occurred 7261 */ 7262 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First( 7263 long companyId, double version, int status, 7264 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7265 throws com.liferay.portal.kernel.exception.SystemException { 7266 return getPersistence() 7267 .fetchByC_V_ST_First(companyId, version, status, 7268 orderByComparator); 7269 } 7270 7271 /** 7272 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 7273 * 7274 * @param companyId the company ID 7275 * @param version the version 7276 * @param status the status 7277 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7278 * @return the last matching journal article 7279 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7280 * @throws SystemException if a system exception occurred 7281 */ 7282 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last( 7283 long companyId, double version, int status, 7284 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7285 throws com.liferay.portal.kernel.exception.SystemException, 7286 com.liferay.portlet.journal.NoSuchArticleException { 7287 return getPersistence() 7288 .findByC_V_ST_Last(companyId, version, status, 7289 orderByComparator); 7290 } 7291 7292 /** 7293 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 7294 * 7295 * @param companyId the company ID 7296 * @param version the version 7297 * @param status the status 7298 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7299 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7300 * @throws SystemException if a system exception occurred 7301 */ 7302 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last( 7303 long companyId, double version, int status, 7304 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7305 throws com.liferay.portal.kernel.exception.SystemException { 7306 return getPersistence() 7307 .fetchByC_V_ST_Last(companyId, version, status, 7308 orderByComparator); 7309 } 7310 7311 /** 7312 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ? and status = ?. 7313 * 7314 * @param id the primary key of the current journal article 7315 * @param companyId the company ID 7316 * @param version the version 7317 * @param status the status 7318 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7319 * @return the previous, current, and next journal article 7320 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7321 * @throws SystemException if a system exception occurred 7322 */ 7323 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext( 7324 long id, long companyId, double version, int status, 7325 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7326 throws com.liferay.portal.kernel.exception.SystemException, 7327 com.liferay.portlet.journal.NoSuchArticleException { 7328 return getPersistence() 7329 .findByC_V_ST_PrevAndNext(id, companyId, version, status, 7330 orderByComparator); 7331 } 7332 7333 /** 7334 * Removes all the journal articles where companyId = ? and version = ? and status = ? from the database. 7335 * 7336 * @param companyId the company ID 7337 * @param version the version 7338 * @param status the status 7339 * @throws SystemException if a system exception occurred 7340 */ 7341 public static void removeByC_V_ST(long companyId, double version, int status) 7342 throws com.liferay.portal.kernel.exception.SystemException { 7343 getPersistence().removeByC_V_ST(companyId, version, status); 7344 } 7345 7346 /** 7347 * Returns the number of journal articles where companyId = ? and version = ? and status = ?. 7348 * 7349 * @param companyId the company ID 7350 * @param version the version 7351 * @param status the status 7352 * @return the number of matching journal articles 7353 * @throws SystemException if a system exception occurred 7354 */ 7355 public static int countByC_V_ST(long companyId, double version, int status) 7356 throws com.liferay.portal.kernel.exception.SystemException { 7357 return getPersistence().countByC_V_ST(companyId, version, status); 7358 } 7359 7360 /** 7361 * Caches the journal article in the entity cache if it is enabled. 7362 * 7363 * @param journalArticle the journal article 7364 */ 7365 public static void cacheResult( 7366 com.liferay.portlet.journal.model.JournalArticle journalArticle) { 7367 getPersistence().cacheResult(journalArticle); 7368 } 7369 7370 /** 7371 * Caches the journal articles in the entity cache if it is enabled. 7372 * 7373 * @param journalArticles the journal articles 7374 */ 7375 public static void cacheResult( 7376 java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) { 7377 getPersistence().cacheResult(journalArticles); 7378 } 7379 7380 /** 7381 * Creates a new journal article with the primary key. Does not add the journal article to the database. 7382 * 7383 * @param id the primary key for the new journal article 7384 * @return the new journal article 7385 */ 7386 public static com.liferay.portlet.journal.model.JournalArticle create( 7387 long id) { 7388 return getPersistence().create(id); 7389 } 7390 7391 /** 7392 * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners. 7393 * 7394 * @param id the primary key of the journal article 7395 * @return the journal article that was removed 7396 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7397 * @throws SystemException if a system exception occurred 7398 */ 7399 public static com.liferay.portlet.journal.model.JournalArticle remove( 7400 long id) 7401 throws com.liferay.portal.kernel.exception.SystemException, 7402 com.liferay.portlet.journal.NoSuchArticleException { 7403 return getPersistence().remove(id); 7404 } 7405 7406 public static com.liferay.portlet.journal.model.JournalArticle updateImpl( 7407 com.liferay.portlet.journal.model.JournalArticle journalArticle) 7408 throws com.liferay.portal.kernel.exception.SystemException { 7409 return getPersistence().updateImpl(journalArticle); 7410 } 7411 7412 /** 7413 * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 7414 * 7415 * @param id the primary key of the journal article 7416 * @return the journal article 7417 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7418 * @throws SystemException if a system exception occurred 7419 */ 7420 public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey( 7421 long id) 7422 throws com.liferay.portal.kernel.exception.SystemException, 7423 com.liferay.portlet.journal.NoSuchArticleException { 7424 return getPersistence().findByPrimaryKey(id); 7425 } 7426 7427 /** 7428 * Returns the journal article with the primary key or returns <code>null</code> if it could not be found. 7429 * 7430 * @param id the primary key of the journal article 7431 * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found 7432 * @throws SystemException if a system exception occurred 7433 */ 7434 public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey( 7435 long id) throws com.liferay.portal.kernel.exception.SystemException { 7436 return getPersistence().fetchByPrimaryKey(id); 7437 } 7438 7439 /** 7440 * Returns all the journal articles. 7441 * 7442 * @return the journal articles 7443 * @throws SystemException if a system exception occurred 7444 */ 7445 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll() 7446 throws com.liferay.portal.kernel.exception.SystemException { 7447 return getPersistence().findAll(); 7448 } 7449 7450 /** 7451 * Returns a range of all the journal articles. 7452 * 7453 * <p> 7454 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7455 * </p> 7456 * 7457 * @param start the lower bound of the range of journal articles 7458 * @param end the upper bound of the range of journal articles (not inclusive) 7459 * @return the range of journal articles 7460 * @throws SystemException if a system exception occurred 7461 */ 7462 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 7463 int start, int end) 7464 throws com.liferay.portal.kernel.exception.SystemException { 7465 return getPersistence().findAll(start, end); 7466 } 7467 7468 /** 7469 * Returns an ordered range of all the journal articles. 7470 * 7471 * <p> 7472 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7473 * </p> 7474 * 7475 * @param start the lower bound of the range of journal articles 7476 * @param end the upper bound of the range of journal articles (not inclusive) 7477 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7478 * @return the ordered range of journal articles 7479 * @throws SystemException if a system exception occurred 7480 */ 7481 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 7482 int start, int end, 7483 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7484 throws com.liferay.portal.kernel.exception.SystemException { 7485 return getPersistence().findAll(start, end, orderByComparator); 7486 } 7487 7488 /** 7489 * Removes all the journal articles from the database. 7490 * 7491 * @throws SystemException if a system exception occurred 7492 */ 7493 public static void removeAll() 7494 throws com.liferay.portal.kernel.exception.SystemException { 7495 getPersistence().removeAll(); 7496 } 7497 7498 /** 7499 * Returns the number of journal articles. 7500 * 7501 * @return the number of journal articles 7502 * @throws SystemException if a system exception occurred 7503 */ 7504 public static int countAll() 7505 throws com.liferay.portal.kernel.exception.SystemException { 7506 return getPersistence().countAll(); 7507 } 7508 7509 public static JournalArticlePersistence getPersistence() { 7510 if (_persistence == null) { 7511 _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName()); 7512 7513 ReferenceRegistry.registerReference(JournalArticleUtil.class, 7514 "_persistence"); 7515 } 7516 7517 return _persistence; 7518 } 7519 7520 /** 7521 * @deprecated As of 6.2.0 7522 */ 7523 public void setPersistence(JournalArticlePersistence persistence) { 7524 } 7525 7526 private static JournalArticlePersistence _persistence; 7527 }