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 static 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 companyId = ? and status ≠ ?. 4643 * 4644 * @param companyId the company ID 4645 * @param status the status 4646 * @return the matching journal articles 4647 * @throws SystemException if a system exception occurred 4648 */ 4649 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4650 long companyId, int status) 4651 throws com.liferay.portal.kernel.exception.SystemException { 4652 return getPersistence().findByC_NotST(companyId, status); 4653 } 4654 4655 /** 4656 * Returns a range of all the journal articles where companyId = ? and status ≠ ?. 4657 * 4658 * <p> 4659 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4660 * </p> 4661 * 4662 * @param companyId the company ID 4663 * @param status the status 4664 * @param start the lower bound of the range of journal articles 4665 * @param end the upper bound of the range of journal articles (not inclusive) 4666 * @return the range of matching journal articles 4667 * @throws SystemException if a system exception occurred 4668 */ 4669 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4670 long companyId, int status, int start, int end) 4671 throws com.liferay.portal.kernel.exception.SystemException { 4672 return getPersistence().findByC_NotST(companyId, status, start, end); 4673 } 4674 4675 /** 4676 * Returns an ordered range of all the journal articles where companyId = ? and status ≠ ?. 4677 * 4678 * <p> 4679 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4680 * </p> 4681 * 4682 * @param companyId the company ID 4683 * @param status the status 4684 * @param start the lower bound of the range of journal articles 4685 * @param end the upper bound of the range of journal articles (not inclusive) 4686 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4687 * @return the ordered range of matching journal articles 4688 * @throws SystemException if a system exception occurred 4689 */ 4690 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 4691 long companyId, int status, int start, int end, 4692 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4693 throws com.liferay.portal.kernel.exception.SystemException { 4694 return getPersistence() 4695 .findByC_NotST(companyId, status, start, end, 4696 orderByComparator); 4697 } 4698 4699 /** 4700 * Returns the first journal article in the ordered set where companyId = ? and status ≠ ?. 4701 * 4702 * @param companyId the company ID 4703 * @param status the status 4704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4705 * @return the first matching journal article 4706 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4707 * @throws SystemException if a system exception occurred 4708 */ 4709 public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_First( 4710 long companyId, int status, 4711 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4712 throws com.liferay.portal.kernel.exception.SystemException, 4713 com.liferay.portlet.journal.NoSuchArticleException { 4714 return getPersistence() 4715 .findByC_NotST_First(companyId, status, orderByComparator); 4716 } 4717 4718 /** 4719 * Returns the first journal article in the ordered set where companyId = ? and status ≠ ?. 4720 * 4721 * @param companyId the company ID 4722 * @param status the status 4723 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4724 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4725 * @throws SystemException if a system exception occurred 4726 */ 4727 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_First( 4728 long companyId, int status, 4729 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4730 throws com.liferay.portal.kernel.exception.SystemException { 4731 return getPersistence() 4732 .fetchByC_NotST_First(companyId, status, orderByComparator); 4733 } 4734 4735 /** 4736 * Returns the last journal article in the ordered set where companyId = ? and status ≠ ?. 4737 * 4738 * @param companyId the company ID 4739 * @param status the status 4740 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4741 * @return the last matching journal article 4742 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4743 * @throws SystemException if a system exception occurred 4744 */ 4745 public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_Last( 4746 long companyId, int status, 4747 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4748 throws com.liferay.portal.kernel.exception.SystemException, 4749 com.liferay.portlet.journal.NoSuchArticleException { 4750 return getPersistence() 4751 .findByC_NotST_Last(companyId, status, orderByComparator); 4752 } 4753 4754 /** 4755 * Returns the last journal article in the ordered set where companyId = ? and status ≠ ?. 4756 * 4757 * @param companyId the company ID 4758 * @param status the status 4759 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4760 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4761 * @throws SystemException if a system exception occurred 4762 */ 4763 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_Last( 4764 long companyId, int status, 4765 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4766 throws com.liferay.portal.kernel.exception.SystemException { 4767 return getPersistence() 4768 .fetchByC_NotST_Last(companyId, status, orderByComparator); 4769 } 4770 4771 /** 4772 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status ≠ ?. 4773 * 4774 * @param id the primary key of the current journal article 4775 * @param companyId the company ID 4776 * @param status the status 4777 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4778 * @return the previous, current, and next journal article 4779 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4780 * @throws SystemException if a system exception occurred 4781 */ 4782 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_NotST_PrevAndNext( 4783 long id, long companyId, int status, 4784 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4785 throws com.liferay.portal.kernel.exception.SystemException, 4786 com.liferay.portlet.journal.NoSuchArticleException { 4787 return getPersistence() 4788 .findByC_NotST_PrevAndNext(id, companyId, status, 4789 orderByComparator); 4790 } 4791 4792 /** 4793 * Removes all the journal articles where companyId = ? and status ≠ ? from the database. 4794 * 4795 * @param companyId the company ID 4796 * @param status the status 4797 * @throws SystemException if a system exception occurred 4798 */ 4799 public static void removeByC_NotST(long companyId, int status) 4800 throws com.liferay.portal.kernel.exception.SystemException { 4801 getPersistence().removeByC_NotST(companyId, status); 4802 } 4803 4804 /** 4805 * Returns the number of journal articles where companyId = ? and status ≠ ?. 4806 * 4807 * @param companyId the company ID 4808 * @param status the status 4809 * @return the number of matching journal articles 4810 * @throws SystemException if a system exception occurred 4811 */ 4812 public static int countByC_NotST(long companyId, int status) 4813 throws com.liferay.portal.kernel.exception.SystemException { 4814 return getPersistence().countByC_NotST(companyId, status); 4815 } 4816 4817 /** 4818 * Returns all the journal articles where displayDate < ? and status = ?. 4819 * 4820 * @param displayDate the display date 4821 * @param status the status 4822 * @return the matching journal articles 4823 * @throws SystemException if a system exception occurred 4824 */ 4825 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 4826 java.util.Date displayDate, int status) 4827 throws com.liferay.portal.kernel.exception.SystemException { 4828 return getPersistence().findByLtD_S(displayDate, status); 4829 } 4830 4831 /** 4832 * Returns a range of all the journal articles where displayDate < ? and status = ?. 4833 * 4834 * <p> 4835 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4836 * </p> 4837 * 4838 * @param displayDate the display date 4839 * @param status the status 4840 * @param start the lower bound of the range of journal articles 4841 * @param end the upper bound of the range of journal articles (not inclusive) 4842 * @return the range of matching journal articles 4843 * @throws SystemException if a system exception occurred 4844 */ 4845 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 4846 java.util.Date displayDate, int status, int start, int end) 4847 throws com.liferay.portal.kernel.exception.SystemException { 4848 return getPersistence().findByLtD_S(displayDate, status, start, end); 4849 } 4850 4851 /** 4852 * Returns an ordered range of all the journal articles where displayDate < ? and status = ?. 4853 * 4854 * <p> 4855 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4856 * </p> 4857 * 4858 * @param displayDate the display date 4859 * @param status the status 4860 * @param start the lower bound of the range of journal articles 4861 * @param end the upper bound of the range of journal articles (not inclusive) 4862 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4863 * @return the ordered range of matching journal articles 4864 * @throws SystemException if a system exception occurred 4865 */ 4866 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 4867 java.util.Date displayDate, int status, int start, int end, 4868 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4869 throws com.liferay.portal.kernel.exception.SystemException { 4870 return getPersistence() 4871 .findByLtD_S(displayDate, status, start, end, 4872 orderByComparator); 4873 } 4874 4875 /** 4876 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 4877 * 4878 * @param displayDate the display date 4879 * @param status the status 4880 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4881 * @return the first matching journal article 4882 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4883 * @throws SystemException if a system exception occurred 4884 */ 4885 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First( 4886 java.util.Date displayDate, int status, 4887 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4888 throws com.liferay.portal.kernel.exception.SystemException, 4889 com.liferay.portlet.journal.NoSuchArticleException { 4890 return getPersistence() 4891 .findByLtD_S_First(displayDate, status, orderByComparator); 4892 } 4893 4894 /** 4895 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 4896 * 4897 * @param displayDate the display date 4898 * @param status the status 4899 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4900 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4901 * @throws SystemException if a system exception occurred 4902 */ 4903 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First( 4904 java.util.Date displayDate, int status, 4905 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4906 throws com.liferay.portal.kernel.exception.SystemException { 4907 return getPersistence() 4908 .fetchByLtD_S_First(displayDate, status, orderByComparator); 4909 } 4910 4911 /** 4912 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 4913 * 4914 * @param displayDate the display date 4915 * @param status the status 4916 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4917 * @return the last matching journal article 4918 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4919 * @throws SystemException if a system exception occurred 4920 */ 4921 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_Last( 4922 java.util.Date displayDate, int status, 4923 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4924 throws com.liferay.portal.kernel.exception.SystemException, 4925 com.liferay.portlet.journal.NoSuchArticleException { 4926 return getPersistence() 4927 .findByLtD_S_Last(displayDate, status, orderByComparator); 4928 } 4929 4930 /** 4931 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 4932 * 4933 * @param displayDate the display date 4934 * @param status the status 4935 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4936 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4937 * @throws SystemException if a system exception occurred 4938 */ 4939 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last( 4940 java.util.Date displayDate, int status, 4941 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4942 throws com.liferay.portal.kernel.exception.SystemException { 4943 return getPersistence() 4944 .fetchByLtD_S_Last(displayDate, status, orderByComparator); 4945 } 4946 4947 /** 4948 * Returns the journal articles before and after the current journal article in the ordered set where displayDate < ? and status = ?. 4949 * 4950 * @param id the primary key of the current journal article 4951 * @param displayDate the display date 4952 * @param status the status 4953 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4954 * @return the previous, current, and next journal article 4955 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4956 * @throws SystemException if a system exception occurred 4957 */ 4958 public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext( 4959 long id, java.util.Date displayDate, int status, 4960 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4961 throws com.liferay.portal.kernel.exception.SystemException, 4962 com.liferay.portlet.journal.NoSuchArticleException { 4963 return getPersistence() 4964 .findByLtD_S_PrevAndNext(id, displayDate, status, 4965 orderByComparator); 4966 } 4967 4968 /** 4969 * Removes all the journal articles where displayDate < ? and status = ? from the database. 4970 * 4971 * @param displayDate the display date 4972 * @param status the status 4973 * @throws SystemException if a system exception occurred 4974 */ 4975 public static void removeByLtD_S(java.util.Date displayDate, int status) 4976 throws com.liferay.portal.kernel.exception.SystemException { 4977 getPersistence().removeByLtD_S(displayDate, status); 4978 } 4979 4980 /** 4981 * Returns the number of journal articles where displayDate < ? and status = ?. 4982 * 4983 * @param displayDate the display date 4984 * @param status the status 4985 * @return the number of matching journal articles 4986 * @throws SystemException if a system exception occurred 4987 */ 4988 public static int countByLtD_S(java.util.Date displayDate, int status) 4989 throws com.liferay.portal.kernel.exception.SystemException { 4990 return getPersistence().countByLtD_S(displayDate, status); 4991 } 4992 4993 /** 4994 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 4995 * 4996 * @param resourcePrimKey the resource prim key 4997 * @param indexable the indexable 4998 * @param status the status 4999 * @return the matching journal articles 5000 * @throws SystemException if a system exception occurred 5001 */ 5002 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5003 long resourcePrimKey, boolean indexable, int status) 5004 throws com.liferay.portal.kernel.exception.SystemException { 5005 return getPersistence().findByR_I_S(resourcePrimKey, indexable, status); 5006 } 5007 5008 /** 5009 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5010 * 5011 * <p> 5012 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5013 * </p> 5014 * 5015 * @param resourcePrimKey the resource prim key 5016 * @param indexable the indexable 5017 * @param status the status 5018 * @param start the lower bound of the range of journal articles 5019 * @param end the upper bound of the range of journal articles (not inclusive) 5020 * @return the range of matching journal articles 5021 * @throws SystemException if a system exception occurred 5022 */ 5023 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5024 long resourcePrimKey, boolean indexable, int status, int start, int end) 5025 throws com.liferay.portal.kernel.exception.SystemException { 5026 return getPersistence() 5027 .findByR_I_S(resourcePrimKey, indexable, status, start, end); 5028 } 5029 5030 /** 5031 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5032 * 5033 * <p> 5034 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5035 * </p> 5036 * 5037 * @param resourcePrimKey the resource prim key 5038 * @param indexable the indexable 5039 * @param status the status 5040 * @param start the lower bound of the range of journal articles 5041 * @param end the upper bound of the range of journal articles (not inclusive) 5042 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5043 * @return the ordered range of matching journal articles 5044 * @throws SystemException if a system exception occurred 5045 */ 5046 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5047 long resourcePrimKey, boolean indexable, int status, int start, 5048 int end, 5049 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5050 throws com.liferay.portal.kernel.exception.SystemException { 5051 return getPersistence() 5052 .findByR_I_S(resourcePrimKey, indexable, status, start, end, 5053 orderByComparator); 5054 } 5055 5056 /** 5057 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5058 * 5059 * @param resourcePrimKey the resource prim key 5060 * @param indexable the indexable 5061 * @param status the status 5062 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5063 * @return the first matching journal article 5064 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5065 * @throws SystemException if a system exception occurred 5066 */ 5067 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First( 5068 long resourcePrimKey, boolean indexable, int status, 5069 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5070 throws com.liferay.portal.kernel.exception.SystemException, 5071 com.liferay.portlet.journal.NoSuchArticleException { 5072 return getPersistence() 5073 .findByR_I_S_First(resourcePrimKey, indexable, status, 5074 orderByComparator); 5075 } 5076 5077 /** 5078 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5079 * 5080 * @param resourcePrimKey the resource prim key 5081 * @param indexable the indexable 5082 * @param status the status 5083 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5084 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5085 * @throws SystemException if a system exception occurred 5086 */ 5087 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First( 5088 long resourcePrimKey, boolean indexable, int status, 5089 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5090 throws com.liferay.portal.kernel.exception.SystemException { 5091 return getPersistence() 5092 .fetchByR_I_S_First(resourcePrimKey, indexable, status, 5093 orderByComparator); 5094 } 5095 5096 /** 5097 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5098 * 5099 * @param resourcePrimKey the resource prim key 5100 * @param indexable the indexable 5101 * @param status the status 5102 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5103 * @return the last matching journal article 5104 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5105 * @throws SystemException if a system exception occurred 5106 */ 5107 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last( 5108 long resourcePrimKey, boolean indexable, int status, 5109 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5110 throws com.liferay.portal.kernel.exception.SystemException, 5111 com.liferay.portlet.journal.NoSuchArticleException { 5112 return getPersistence() 5113 .findByR_I_S_Last(resourcePrimKey, indexable, status, 5114 orderByComparator); 5115 } 5116 5117 /** 5118 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5119 * 5120 * @param resourcePrimKey the resource prim key 5121 * @param indexable the indexable 5122 * @param status the status 5123 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5124 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5125 * @throws SystemException if a system exception occurred 5126 */ 5127 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last( 5128 long resourcePrimKey, boolean indexable, int status, 5129 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5130 throws com.liferay.portal.kernel.exception.SystemException { 5131 return getPersistence() 5132 .fetchByR_I_S_Last(resourcePrimKey, indexable, status, 5133 orderByComparator); 5134 } 5135 5136 /** 5137 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5138 * 5139 * @param id the primary key of the current journal article 5140 * @param resourcePrimKey the resource prim key 5141 * @param indexable the indexable 5142 * @param status the status 5143 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5144 * @return the previous, current, and next journal article 5145 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5146 * @throws SystemException if a system exception occurred 5147 */ 5148 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext( 5149 long id, long resourcePrimKey, boolean indexable, int status, 5150 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5151 throws com.liferay.portal.kernel.exception.SystemException, 5152 com.liferay.portlet.journal.NoSuchArticleException { 5153 return getPersistence() 5154 .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable, 5155 status, orderByComparator); 5156 } 5157 5158 /** 5159 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5160 * 5161 * <p> 5162 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5163 * </p> 5164 * 5165 * @param resourcePrimKey the resource prim key 5166 * @param indexable the indexable 5167 * @param statuses the statuses 5168 * @return the matching journal articles 5169 * @throws SystemException if a system exception occurred 5170 */ 5171 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5172 long resourcePrimKey, boolean indexable, int[] statuses) 5173 throws com.liferay.portal.kernel.exception.SystemException { 5174 return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses); 5175 } 5176 5177 /** 5178 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5179 * 5180 * <p> 5181 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5182 * </p> 5183 * 5184 * @param resourcePrimKey the resource prim key 5185 * @param indexable the indexable 5186 * @param statuses the statuses 5187 * @param start the lower bound of the range of journal articles 5188 * @param end the upper bound of the range of journal articles (not inclusive) 5189 * @return the range of matching journal articles 5190 * @throws SystemException if a system exception occurred 5191 */ 5192 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5193 long resourcePrimKey, boolean indexable, int[] statuses, int start, 5194 int end) throws com.liferay.portal.kernel.exception.SystemException { 5195 return getPersistence() 5196 .findByR_I_S(resourcePrimKey, indexable, statuses, start, end); 5197 } 5198 5199 /** 5200 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5201 * 5202 * <p> 5203 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5204 * </p> 5205 * 5206 * @param resourcePrimKey the resource prim key 5207 * @param indexable the indexable 5208 * @param statuses the statuses 5209 * @param start the lower bound of the range of journal articles 5210 * @param end the upper bound of the range of journal articles (not inclusive) 5211 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5212 * @return the ordered range of matching journal articles 5213 * @throws SystemException if a system exception occurred 5214 */ 5215 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5216 long resourcePrimKey, boolean indexable, int[] statuses, int start, 5217 int end, 5218 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5219 throws com.liferay.portal.kernel.exception.SystemException { 5220 return getPersistence() 5221 .findByR_I_S(resourcePrimKey, indexable, statuses, start, 5222 end, orderByComparator); 5223 } 5224 5225 /** 5226 * Removes all the journal articles where resourcePrimKey = ? and indexable = ? and status = ? from the database. 5227 * 5228 * @param resourcePrimKey the resource prim key 5229 * @param indexable the indexable 5230 * @param status the status 5231 * @throws SystemException if a system exception occurred 5232 */ 5233 public static void removeByR_I_S(long resourcePrimKey, boolean indexable, 5234 int status) throws com.liferay.portal.kernel.exception.SystemException { 5235 getPersistence().removeByR_I_S(resourcePrimKey, indexable, status); 5236 } 5237 5238 /** 5239 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5240 * 5241 * @param resourcePrimKey the resource prim key 5242 * @param indexable the indexable 5243 * @param status the status 5244 * @return the number of matching journal articles 5245 * @throws SystemException if a system exception occurred 5246 */ 5247 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 5248 int status) throws com.liferay.portal.kernel.exception.SystemException { 5249 return getPersistence().countByR_I_S(resourcePrimKey, indexable, status); 5250 } 5251 5252 /** 5253 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 5254 * 5255 * @param resourcePrimKey the resource prim key 5256 * @param indexable the indexable 5257 * @param statuses the statuses 5258 * @return the number of matching journal articles 5259 * @throws SystemException if a system exception occurred 5260 */ 5261 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 5262 int[] statuses) 5263 throws com.liferay.portal.kernel.exception.SystemException { 5264 return getPersistence() 5265 .countByR_I_S(resourcePrimKey, indexable, statuses); 5266 } 5267 5268 /** 5269 * Returns all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5270 * 5271 * @param groupId the group ID 5272 * @param userId the user ID 5273 * @param classNameId the class name ID 5274 * @return the matching journal articles 5275 * @throws SystemException if a system exception occurred 5276 */ 5277 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5278 long groupId, long userId, long classNameId) 5279 throws com.liferay.portal.kernel.exception.SystemException { 5280 return getPersistence().findByG_U_C(groupId, userId, classNameId); 5281 } 5282 5283 /** 5284 * Returns a range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5285 * 5286 * <p> 5287 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5288 * </p> 5289 * 5290 * @param groupId the group ID 5291 * @param userId the user ID 5292 * @param classNameId the class name ID 5293 * @param start the lower bound of the range of journal articles 5294 * @param end the upper bound of the range of journal articles (not inclusive) 5295 * @return the range of matching journal articles 5296 * @throws SystemException if a system exception occurred 5297 */ 5298 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5299 long groupId, long userId, long classNameId, int start, int end) 5300 throws com.liferay.portal.kernel.exception.SystemException { 5301 return getPersistence() 5302 .findByG_U_C(groupId, userId, classNameId, start, end); 5303 } 5304 5305 /** 5306 * Returns an ordered range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 5307 * 5308 * <p> 5309 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5310 * </p> 5311 * 5312 * @param groupId the group ID 5313 * @param userId the user ID 5314 * @param classNameId the class name ID 5315 * @param start the lower bound of the range of journal articles 5316 * @param end the upper bound of the range of journal articles (not inclusive) 5317 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5318 * @return the ordered range of matching journal articles 5319 * @throws SystemException if a system exception occurred 5320 */ 5321 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 5322 long groupId, long userId, long classNameId, int start, int end, 5323 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5324 throws com.liferay.portal.kernel.exception.SystemException { 5325 return getPersistence() 5326 .findByG_U_C(groupId, userId, classNameId, start, end, 5327 orderByComparator); 5328 } 5329 5330 /** 5331 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5332 * 5333 * @param groupId the group ID 5334 * @param userId the user ID 5335 * @param classNameId the class name ID 5336 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5337 * @return the first matching journal article 5338 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5339 * @throws SystemException if a system exception occurred 5340 */ 5341 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First( 5342 long groupId, long userId, long classNameId, 5343 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5344 throws com.liferay.portal.kernel.exception.SystemException, 5345 com.liferay.portlet.journal.NoSuchArticleException { 5346 return getPersistence() 5347 .findByG_U_C_First(groupId, userId, classNameId, 5348 orderByComparator); 5349 } 5350 5351 /** 5352 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5353 * 5354 * @param groupId the group ID 5355 * @param userId the user ID 5356 * @param classNameId the class name ID 5357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5358 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5359 * @throws SystemException if a system exception occurred 5360 */ 5361 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First( 5362 long groupId, long userId, long classNameId, 5363 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5364 throws com.liferay.portal.kernel.exception.SystemException { 5365 return getPersistence() 5366 .fetchByG_U_C_First(groupId, userId, classNameId, 5367 orderByComparator); 5368 } 5369 5370 /** 5371 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5372 * 5373 * @param groupId the group ID 5374 * @param userId the user ID 5375 * @param classNameId the class name ID 5376 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5377 * @return the last matching journal article 5378 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5379 * @throws SystemException if a system exception occurred 5380 */ 5381 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last( 5382 long groupId, long userId, long classNameId, 5383 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5384 throws com.liferay.portal.kernel.exception.SystemException, 5385 com.liferay.portlet.journal.NoSuchArticleException { 5386 return getPersistence() 5387 .findByG_U_C_Last(groupId, userId, classNameId, 5388 orderByComparator); 5389 } 5390 5391 /** 5392 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5393 * 5394 * @param groupId the group ID 5395 * @param userId the user ID 5396 * @param classNameId the class name ID 5397 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5398 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5399 * @throws SystemException if a system exception occurred 5400 */ 5401 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last( 5402 long groupId, long userId, long classNameId, 5403 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5404 throws com.liferay.portal.kernel.exception.SystemException { 5405 return getPersistence() 5406 .fetchByG_U_C_Last(groupId, userId, classNameId, 5407 orderByComparator); 5408 } 5409 5410 /** 5411 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 5412 * 5413 * @param id the primary key of the current journal article 5414 * @param groupId the group ID 5415 * @param userId the user ID 5416 * @param classNameId the class name ID 5417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5418 * @return the previous, current, and next journal article 5419 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5420 * @throws SystemException if a system exception occurred 5421 */ 5422 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext( 5423 long id, long groupId, long userId, long classNameId, 5424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5425 throws com.liferay.portal.kernel.exception.SystemException, 5426 com.liferay.portlet.journal.NoSuchArticleException { 5427 return getPersistence() 5428 .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId, 5429 orderByComparator); 5430 } 5431 5432 /** 5433 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5434 * 5435 * @param groupId the group ID 5436 * @param userId the user ID 5437 * @param classNameId the class name ID 5438 * @return the matching journal articles that the user has permission to view 5439 * @throws SystemException if a system exception occurred 5440 */ 5441 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5442 long groupId, long userId, long classNameId) 5443 throws com.liferay.portal.kernel.exception.SystemException { 5444 return getPersistence().filterFindByG_U_C(groupId, userId, classNameId); 5445 } 5446 5447 /** 5448 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5449 * 5450 * <p> 5451 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5452 * </p> 5453 * 5454 * @param groupId the group ID 5455 * @param userId the user ID 5456 * @param classNameId the class name ID 5457 * @param start the lower bound of the range of journal articles 5458 * @param end the upper bound of the range of journal articles (not inclusive) 5459 * @return the range of matching journal articles that the user has permission to view 5460 * @throws SystemException if a system exception occurred 5461 */ 5462 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5463 long groupId, long userId, long classNameId, int start, int end) 5464 throws com.liferay.portal.kernel.exception.SystemException { 5465 return getPersistence() 5466 .filterFindByG_U_C(groupId, userId, classNameId, start, end); 5467 } 5468 5469 /** 5470 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ? and classNameId = ?. 5471 * 5472 * <p> 5473 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5474 * </p> 5475 * 5476 * @param groupId the group ID 5477 * @param userId the user ID 5478 * @param classNameId the class name ID 5479 * @param start the lower bound of the range of journal articles 5480 * @param end the upper bound of the range of journal articles (not inclusive) 5481 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5482 * @return the ordered range of matching journal articles that the user has permission to view 5483 * @throws SystemException if a system exception occurred 5484 */ 5485 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 5486 long groupId, long userId, long classNameId, int start, int end, 5487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5488 throws com.liferay.portal.kernel.exception.SystemException { 5489 return getPersistence() 5490 .filterFindByG_U_C(groupId, userId, classNameId, start, end, 5491 orderByComparator); 5492 } 5493 5494 /** 5495 * 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 = ?. 5496 * 5497 * @param id the primary key of the current journal article 5498 * @param groupId the group ID 5499 * @param userId the user ID 5500 * @param classNameId the class name ID 5501 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5502 * @return the previous, current, and next journal article 5503 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5504 * @throws SystemException if a system exception occurred 5505 */ 5506 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext( 5507 long id, long groupId, long userId, long classNameId, 5508 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5509 throws com.liferay.portal.kernel.exception.SystemException, 5510 com.liferay.portlet.journal.NoSuchArticleException { 5511 return getPersistence() 5512 .filterFindByG_U_C_PrevAndNext(id, groupId, userId, 5513 classNameId, orderByComparator); 5514 } 5515 5516 /** 5517 * Removes all the journal articles where groupId = ? and userId = ? and classNameId = ? from the database. 5518 * 5519 * @param groupId the group ID 5520 * @param userId the user ID 5521 * @param classNameId the class name ID 5522 * @throws SystemException if a system exception occurred 5523 */ 5524 public static void removeByG_U_C(long groupId, long userId, long classNameId) 5525 throws com.liferay.portal.kernel.exception.SystemException { 5526 getPersistence().removeByG_U_C(groupId, userId, classNameId); 5527 } 5528 5529 /** 5530 * Returns the number of journal articles where groupId = ? and userId = ? and classNameId = ?. 5531 * 5532 * @param groupId the group ID 5533 * @param userId the user ID 5534 * @param classNameId the class name ID 5535 * @return the number of matching journal articles 5536 * @throws SystemException if a system exception occurred 5537 */ 5538 public static int countByG_U_C(long groupId, long userId, long classNameId) 5539 throws com.liferay.portal.kernel.exception.SystemException { 5540 return getPersistence().countByG_U_C(groupId, userId, classNameId); 5541 } 5542 5543 /** 5544 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 5545 * 5546 * @param groupId the group ID 5547 * @param userId the user ID 5548 * @param classNameId the class name ID 5549 * @return the number of matching journal articles that the user has permission to view 5550 * @throws SystemException if a system exception occurred 5551 */ 5552 public static int filterCountByG_U_C(long groupId, long userId, 5553 long classNameId) 5554 throws com.liferay.portal.kernel.exception.SystemException { 5555 return getPersistence().filterCountByG_U_C(groupId, userId, classNameId); 5556 } 5557 5558 /** 5559 * Returns all the journal articles where groupId = ? and folderId = ? and status = ?. 5560 * 5561 * @param groupId the group ID 5562 * @param folderId the folder ID 5563 * @param status the status 5564 * @return the matching journal articles 5565 * @throws SystemException if a system exception occurred 5566 */ 5567 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5568 long groupId, long folderId, int status) 5569 throws com.liferay.portal.kernel.exception.SystemException { 5570 return getPersistence().findByG_F_ST(groupId, folderId, status); 5571 } 5572 5573 /** 5574 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = ?. 5575 * 5576 * <p> 5577 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5578 * </p> 5579 * 5580 * @param groupId the group ID 5581 * @param folderId the folder ID 5582 * @param status the status 5583 * @param start the lower bound of the range of journal articles 5584 * @param end the upper bound of the range of journal articles (not inclusive) 5585 * @return the range of matching journal articles 5586 * @throws SystemException if a system exception occurred 5587 */ 5588 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5589 long groupId, long folderId, int status, int start, int end) 5590 throws com.liferay.portal.kernel.exception.SystemException { 5591 return getPersistence() 5592 .findByG_F_ST(groupId, folderId, status, start, end); 5593 } 5594 5595 /** 5596 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = ?. 5597 * 5598 * <p> 5599 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5600 * </p> 5601 * 5602 * @param groupId the group ID 5603 * @param folderId the folder ID 5604 * @param status the status 5605 * @param start the lower bound of the range of journal articles 5606 * @param end the upper bound of the range of journal articles (not inclusive) 5607 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5608 * @return the ordered range of matching journal articles 5609 * @throws SystemException if a system exception occurred 5610 */ 5611 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5612 long groupId, long folderId, int status, int start, int end, 5613 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5614 throws com.liferay.portal.kernel.exception.SystemException { 5615 return getPersistence() 5616 .findByG_F_ST(groupId, folderId, status, start, end, 5617 orderByComparator); 5618 } 5619 5620 /** 5621 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5622 * 5623 * @param groupId the group ID 5624 * @param folderId the folder ID 5625 * @param status the status 5626 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5627 * @return the first matching journal article 5628 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5629 * @throws SystemException if a system exception occurred 5630 */ 5631 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First( 5632 long groupId, long folderId, int status, 5633 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5634 throws com.liferay.portal.kernel.exception.SystemException, 5635 com.liferay.portlet.journal.NoSuchArticleException { 5636 return getPersistence() 5637 .findByG_F_ST_First(groupId, folderId, status, 5638 orderByComparator); 5639 } 5640 5641 /** 5642 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5643 * 5644 * @param groupId the group ID 5645 * @param folderId the folder ID 5646 * @param status the status 5647 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5648 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5649 * @throws SystemException if a system exception occurred 5650 */ 5651 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First( 5652 long groupId, long folderId, int status, 5653 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5654 throws com.liferay.portal.kernel.exception.SystemException { 5655 return getPersistence() 5656 .fetchByG_F_ST_First(groupId, folderId, status, 5657 orderByComparator); 5658 } 5659 5660 /** 5661 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5662 * 5663 * @param groupId the group ID 5664 * @param folderId the folder ID 5665 * @param status the status 5666 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5667 * @return the last matching journal article 5668 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5669 * @throws SystemException if a system exception occurred 5670 */ 5671 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last( 5672 long groupId, long folderId, int status, 5673 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5674 throws com.liferay.portal.kernel.exception.SystemException, 5675 com.liferay.portlet.journal.NoSuchArticleException { 5676 return getPersistence() 5677 .findByG_F_ST_Last(groupId, folderId, status, 5678 orderByComparator); 5679 } 5680 5681 /** 5682 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5683 * 5684 * @param groupId the group ID 5685 * @param folderId the folder ID 5686 * @param status the status 5687 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5688 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5689 * @throws SystemException if a system exception occurred 5690 */ 5691 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last( 5692 long groupId, long folderId, int status, 5693 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5694 throws com.liferay.portal.kernel.exception.SystemException { 5695 return getPersistence() 5696 .fetchByG_F_ST_Last(groupId, folderId, status, 5697 orderByComparator); 5698 } 5699 5700 /** 5701 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 5702 * 5703 * @param id the primary key of the current journal article 5704 * @param groupId the group ID 5705 * @param folderId the folder ID 5706 * @param status the status 5707 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5708 * @return the previous, current, and next journal article 5709 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5710 * @throws SystemException if a system exception occurred 5711 */ 5712 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext( 5713 long id, long groupId, long folderId, int status, 5714 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5715 throws com.liferay.portal.kernel.exception.SystemException, 5716 com.liferay.portlet.journal.NoSuchArticleException { 5717 return getPersistence() 5718 .findByG_F_ST_PrevAndNext(id, groupId, folderId, status, 5719 orderByComparator); 5720 } 5721 5722 /** 5723 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5724 * 5725 * @param groupId the group ID 5726 * @param folderId the folder ID 5727 * @param status the status 5728 * @return the matching journal articles that the user has permission to view 5729 * @throws SystemException if a system exception occurred 5730 */ 5731 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5732 long groupId, long folderId, int status) 5733 throws com.liferay.portal.kernel.exception.SystemException { 5734 return getPersistence().filterFindByG_F_ST(groupId, folderId, status); 5735 } 5736 5737 /** 5738 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5739 * 5740 * <p> 5741 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5742 * </p> 5743 * 5744 * @param groupId the group ID 5745 * @param folderId the folder ID 5746 * @param status the status 5747 * @param start the lower bound of the range of journal articles 5748 * @param end the upper bound of the range of journal articles (not inclusive) 5749 * @return the range of matching journal articles that the user has permission to view 5750 * @throws SystemException if a system exception occurred 5751 */ 5752 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5753 long groupId, long folderId, int status, int start, int end) 5754 throws com.liferay.portal.kernel.exception.SystemException { 5755 return getPersistence() 5756 .filterFindByG_F_ST(groupId, folderId, status, start, end); 5757 } 5758 5759 /** 5760 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 5761 * 5762 * <p> 5763 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5764 * </p> 5765 * 5766 * @param groupId the group ID 5767 * @param folderId the folder ID 5768 * @param status the status 5769 * @param start the lower bound of the range of journal articles 5770 * @param end the upper bound of the range of journal articles (not inclusive) 5771 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5772 * @return the ordered range of matching journal articles that the user has permission to view 5773 * @throws SystemException if a system exception occurred 5774 */ 5775 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5776 long groupId, long folderId, int status, int start, int end, 5777 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5778 throws com.liferay.portal.kernel.exception.SystemException { 5779 return getPersistence() 5780 .filterFindByG_F_ST(groupId, folderId, status, start, end, 5781 orderByComparator); 5782 } 5783 5784 /** 5785 * 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 = ?. 5786 * 5787 * @param id the primary key of the current journal article 5788 * @param groupId the group ID 5789 * @param folderId the folder ID 5790 * @param status the status 5791 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5792 * @return the previous, current, and next journal article 5793 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5794 * @throws SystemException if a system exception occurred 5795 */ 5796 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext( 5797 long id, long groupId, long folderId, int status, 5798 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5799 throws com.liferay.portal.kernel.exception.SystemException, 5800 com.liferay.portlet.journal.NoSuchArticleException { 5801 return getPersistence() 5802 .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId, 5803 status, orderByComparator); 5804 } 5805 5806 /** 5807 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5808 * 5809 * @param groupId the group ID 5810 * @param folderId the folder ID 5811 * @param statuses the statuses 5812 * @return the matching journal articles that the user has permission to view 5813 * @throws SystemException if a system exception occurred 5814 */ 5815 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5816 long groupId, long folderId, int[] statuses) 5817 throws com.liferay.portal.kernel.exception.SystemException { 5818 return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses); 5819 } 5820 5821 /** 5822 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5823 * 5824 * <p> 5825 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5826 * </p> 5827 * 5828 * @param groupId the group ID 5829 * @param folderId the folder ID 5830 * @param statuses the statuses 5831 * @param start the lower bound of the range of journal articles 5832 * @param end the upper bound of the range of journal articles (not inclusive) 5833 * @return the range of matching journal articles that the user has permission to view 5834 * @throws SystemException if a system exception occurred 5835 */ 5836 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5837 long groupId, long folderId, int[] statuses, int start, int end) 5838 throws com.liferay.portal.kernel.exception.SystemException { 5839 return getPersistence() 5840 .filterFindByG_F_ST(groupId, folderId, statuses, start, end); 5841 } 5842 5843 /** 5844 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5845 * 5846 * <p> 5847 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5848 * </p> 5849 * 5850 * @param groupId the group ID 5851 * @param folderId the folder ID 5852 * @param statuses the statuses 5853 * @param start the lower bound of the range of journal articles 5854 * @param end the upper bound of the range of journal articles (not inclusive) 5855 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5856 * @return the ordered range of matching journal articles that the user has permission to view 5857 * @throws SystemException if a system exception occurred 5858 */ 5859 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 5860 long groupId, long folderId, int[] statuses, int start, int end, 5861 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5862 throws com.liferay.portal.kernel.exception.SystemException { 5863 return getPersistence() 5864 .filterFindByG_F_ST(groupId, folderId, statuses, start, end, 5865 orderByComparator); 5866 } 5867 5868 /** 5869 * Returns all the journal articles where groupId = ? and folderId = ? and status = any ?. 5870 * 5871 * <p> 5872 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5873 * </p> 5874 * 5875 * @param groupId the group ID 5876 * @param folderId the folder ID 5877 * @param statuses the statuses 5878 * @return the matching journal articles 5879 * @throws SystemException if a system exception occurred 5880 */ 5881 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5882 long groupId, long folderId, int[] statuses) 5883 throws com.liferay.portal.kernel.exception.SystemException { 5884 return getPersistence().findByG_F_ST(groupId, folderId, statuses); 5885 } 5886 5887 /** 5888 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 5889 * 5890 * <p> 5891 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5892 * </p> 5893 * 5894 * @param groupId the group ID 5895 * @param folderId the folder ID 5896 * @param statuses the statuses 5897 * @param start the lower bound of the range of journal articles 5898 * @param end the upper bound of the range of journal articles (not inclusive) 5899 * @return the range of matching journal articles 5900 * @throws SystemException if a system exception occurred 5901 */ 5902 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5903 long groupId, long folderId, int[] statuses, int start, int end) 5904 throws com.liferay.portal.kernel.exception.SystemException { 5905 return getPersistence() 5906 .findByG_F_ST(groupId, folderId, statuses, start, end); 5907 } 5908 5909 /** 5910 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 5911 * 5912 * <p> 5913 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5914 * </p> 5915 * 5916 * @param groupId the group ID 5917 * @param folderId the folder ID 5918 * @param statuses the statuses 5919 * @param start the lower bound of the range of journal articles 5920 * @param end the upper bound of the range of journal articles (not inclusive) 5921 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5922 * @return the ordered range of matching journal articles 5923 * @throws SystemException if a system exception occurred 5924 */ 5925 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 5926 long groupId, long folderId, int[] statuses, int start, int end, 5927 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5928 throws com.liferay.portal.kernel.exception.SystemException { 5929 return getPersistence() 5930 .findByG_F_ST(groupId, folderId, statuses, start, end, 5931 orderByComparator); 5932 } 5933 5934 /** 5935 * Removes all the journal articles where groupId = ? and folderId = ? and status = ? from the database. 5936 * 5937 * @param groupId the group ID 5938 * @param folderId the folder ID 5939 * @param status the status 5940 * @throws SystemException if a system exception occurred 5941 */ 5942 public static void removeByG_F_ST(long groupId, long folderId, int status) 5943 throws com.liferay.portal.kernel.exception.SystemException { 5944 getPersistence().removeByG_F_ST(groupId, folderId, status); 5945 } 5946 5947 /** 5948 * Returns the number of journal articles where groupId = ? and folderId = ? and status = ?. 5949 * 5950 * @param groupId the group ID 5951 * @param folderId the folder ID 5952 * @param status the status 5953 * @return the number of matching journal articles 5954 * @throws SystemException if a system exception occurred 5955 */ 5956 public static int countByG_F_ST(long groupId, long folderId, int status) 5957 throws com.liferay.portal.kernel.exception.SystemException { 5958 return getPersistence().countByG_F_ST(groupId, folderId, status); 5959 } 5960 5961 /** 5962 * Returns the number of journal articles where groupId = ? and folderId = ? and status = any ?. 5963 * 5964 * @param groupId the group ID 5965 * @param folderId the folder ID 5966 * @param statuses the statuses 5967 * @return the number of matching journal articles 5968 * @throws SystemException if a system exception occurred 5969 */ 5970 public static int countByG_F_ST(long groupId, long folderId, int[] statuses) 5971 throws com.liferay.portal.kernel.exception.SystemException { 5972 return getPersistence().countByG_F_ST(groupId, folderId, statuses); 5973 } 5974 5975 /** 5976 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 5977 * 5978 * @param groupId the group ID 5979 * @param folderId the folder ID 5980 * @param status the status 5981 * @return the number of matching journal articles that the user has permission to view 5982 * @throws SystemException if a system exception occurred 5983 */ 5984 public static int filterCountByG_F_ST(long groupId, long folderId, 5985 int status) throws com.liferay.portal.kernel.exception.SystemException { 5986 return getPersistence().filterCountByG_F_ST(groupId, folderId, status); 5987 } 5988 5989 /** 5990 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 5991 * 5992 * @param groupId the group ID 5993 * @param folderId the folder ID 5994 * @param statuses the statuses 5995 * @return the number of matching journal articles that the user has permission to view 5996 * @throws SystemException if a system exception occurred 5997 */ 5998 public static int filterCountByG_F_ST(long groupId, long folderId, 5999 int[] statuses) 6000 throws com.liferay.portal.kernel.exception.SystemException { 6001 return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses); 6002 } 6003 6004 /** 6005 * Returns all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6006 * 6007 * @param groupId the group ID 6008 * @param classNameId the class name ID 6009 * @param classPK the class p k 6010 * @return the matching journal articles 6011 * @throws SystemException if a system exception occurred 6012 */ 6013 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6014 long groupId, long classNameId, long classPK) 6015 throws com.liferay.portal.kernel.exception.SystemException { 6016 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 6017 } 6018 6019 /** 6020 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6021 * 6022 * <p> 6023 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6024 * </p> 6025 * 6026 * @param groupId the group ID 6027 * @param classNameId the class name ID 6028 * @param classPK the class p k 6029 * @param start the lower bound of the range of journal articles 6030 * @param end the upper bound of the range of journal articles (not inclusive) 6031 * @return the range of matching journal articles 6032 * @throws SystemException if a system exception occurred 6033 */ 6034 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6035 long groupId, long classNameId, long classPK, int start, int end) 6036 throws com.liferay.portal.kernel.exception.SystemException { 6037 return getPersistence() 6038 .findByG_C_C(groupId, classNameId, classPK, start, end); 6039 } 6040 6041 /** 6042 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6043 * 6044 * <p> 6045 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6046 * </p> 6047 * 6048 * @param groupId the group ID 6049 * @param classNameId the class name ID 6050 * @param classPK the class p k 6051 * @param start the lower bound of the range of journal articles 6052 * @param end the upper bound of the range of journal articles (not inclusive) 6053 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6054 * @return the ordered range of matching journal articles 6055 * @throws SystemException if a system exception occurred 6056 */ 6057 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6058 long groupId, long classNameId, long classPK, int start, int end, 6059 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6060 throws com.liferay.portal.kernel.exception.SystemException { 6061 return getPersistence() 6062 .findByG_C_C(groupId, classNameId, classPK, start, end, 6063 orderByComparator); 6064 } 6065 6066 /** 6067 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6068 * 6069 * @param groupId the group ID 6070 * @param classNameId the class name ID 6071 * @param classPK the class p k 6072 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6073 * @return the first matching journal article 6074 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6075 * @throws SystemException if a system exception occurred 6076 */ 6077 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First( 6078 long groupId, long classNameId, long classPK, 6079 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6080 throws com.liferay.portal.kernel.exception.SystemException, 6081 com.liferay.portlet.journal.NoSuchArticleException { 6082 return getPersistence() 6083 .findByG_C_C_First(groupId, classNameId, classPK, 6084 orderByComparator); 6085 } 6086 6087 /** 6088 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6089 * 6090 * @param groupId the group ID 6091 * @param classNameId the class name ID 6092 * @param classPK the class p k 6093 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6094 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6095 * @throws SystemException if a system exception occurred 6096 */ 6097 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First( 6098 long groupId, long classNameId, long classPK, 6099 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6100 throws com.liferay.portal.kernel.exception.SystemException { 6101 return getPersistence() 6102 .fetchByG_C_C_First(groupId, classNameId, classPK, 6103 orderByComparator); 6104 } 6105 6106 /** 6107 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6108 * 6109 * @param groupId the group ID 6110 * @param classNameId the class name ID 6111 * @param classPK the class p k 6112 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6113 * @return the last matching journal article 6114 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6115 * @throws SystemException if a system exception occurred 6116 */ 6117 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last( 6118 long groupId, long classNameId, long classPK, 6119 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6120 throws com.liferay.portal.kernel.exception.SystemException, 6121 com.liferay.portlet.journal.NoSuchArticleException { 6122 return getPersistence() 6123 .findByG_C_C_Last(groupId, classNameId, classPK, 6124 orderByComparator); 6125 } 6126 6127 /** 6128 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6129 * 6130 * @param groupId the group ID 6131 * @param classNameId the class name ID 6132 * @param classPK the class p k 6133 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6134 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6135 * @throws SystemException if a system exception occurred 6136 */ 6137 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last( 6138 long groupId, long classNameId, long classPK, 6139 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6140 throws com.liferay.portal.kernel.exception.SystemException { 6141 return getPersistence() 6142 .fetchByG_C_C_Last(groupId, classNameId, classPK, 6143 orderByComparator); 6144 } 6145 6146 /** 6147 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6148 * 6149 * @param id the primary key of the current journal article 6150 * @param groupId the group ID 6151 * @param classNameId the class name ID 6152 * @param classPK the class p k 6153 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6154 * @return the previous, current, and next journal article 6155 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6156 * @throws SystemException if a system exception occurred 6157 */ 6158 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext( 6159 long id, long groupId, long classNameId, long classPK, 6160 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6161 throws com.liferay.portal.kernel.exception.SystemException, 6162 com.liferay.portlet.journal.NoSuchArticleException { 6163 return getPersistence() 6164 .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK, 6165 orderByComparator); 6166 } 6167 6168 /** 6169 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6170 * 6171 * @param groupId the group ID 6172 * @param classNameId the class name ID 6173 * @param classPK the class p k 6174 * @return the matching journal articles that the user has permission to view 6175 * @throws SystemException if a system exception occurred 6176 */ 6177 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6178 long groupId, long classNameId, long classPK) 6179 throws com.liferay.portal.kernel.exception.SystemException { 6180 return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK); 6181 } 6182 6183 /** 6184 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6185 * 6186 * <p> 6187 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6188 * </p> 6189 * 6190 * @param groupId the group ID 6191 * @param classNameId the class name ID 6192 * @param classPK the class p k 6193 * @param start the lower bound of the range of journal articles 6194 * @param end the upper bound of the range of journal articles (not inclusive) 6195 * @return the range of matching journal articles that the user has permission to view 6196 * @throws SystemException if a system exception occurred 6197 */ 6198 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6199 long groupId, long classNameId, long classPK, int start, int end) 6200 throws com.liferay.portal.kernel.exception.SystemException { 6201 return getPersistence() 6202 .filterFindByG_C_C(groupId, classNameId, classPK, start, end); 6203 } 6204 6205 /** 6206 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and classPK = ?. 6207 * 6208 * <p> 6209 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6210 * </p> 6211 * 6212 * @param groupId the group ID 6213 * @param classNameId the class name ID 6214 * @param classPK the class p k 6215 * @param start the lower bound of the range of journal articles 6216 * @param end the upper bound of the range of journal articles (not inclusive) 6217 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6218 * @return the ordered range of matching journal articles that the user has permission to view 6219 * @throws SystemException if a system exception occurred 6220 */ 6221 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 6222 long groupId, long classNameId, long classPK, int start, int end, 6223 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6224 throws com.liferay.portal.kernel.exception.SystemException { 6225 return getPersistence() 6226 .filterFindByG_C_C(groupId, classNameId, classPK, start, 6227 end, orderByComparator); 6228 } 6229 6230 /** 6231 * 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 = ?. 6232 * 6233 * @param id the primary key of the current journal article 6234 * @param groupId the group ID 6235 * @param classNameId the class name ID 6236 * @param classPK the class p k 6237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6238 * @return the previous, current, and next journal article 6239 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6240 * @throws SystemException if a system exception occurred 6241 */ 6242 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext( 6243 long id, long groupId, long classNameId, long classPK, 6244 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6245 throws com.liferay.portal.kernel.exception.SystemException, 6246 com.liferay.portlet.journal.NoSuchArticleException { 6247 return getPersistence() 6248 .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId, 6249 classPK, orderByComparator); 6250 } 6251 6252 /** 6253 * Removes all the journal articles where groupId = ? and classNameId = ? and classPK = ? from the database. 6254 * 6255 * @param groupId the group ID 6256 * @param classNameId the class name ID 6257 * @param classPK the class p k 6258 * @throws SystemException if a system exception occurred 6259 */ 6260 public static void removeByG_C_C(long groupId, long classNameId, 6261 long classPK) 6262 throws com.liferay.portal.kernel.exception.SystemException { 6263 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 6264 } 6265 6266 /** 6267 * Returns the number of journal articles where groupId = ? and classNameId = ? and classPK = ?. 6268 * 6269 * @param groupId the group ID 6270 * @param classNameId the class name ID 6271 * @param classPK the class p k 6272 * @return the number of matching journal articles 6273 * @throws SystemException if a system exception occurred 6274 */ 6275 public static int countByG_C_C(long groupId, long classNameId, long classPK) 6276 throws com.liferay.portal.kernel.exception.SystemException { 6277 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 6278 } 6279 6280 /** 6281 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 6282 * 6283 * @param groupId the group ID 6284 * @param classNameId the class name ID 6285 * @param classPK the class p k 6286 * @return the number of matching journal articles that the user has permission to view 6287 * @throws SystemException if a system exception occurred 6288 */ 6289 public static int filterCountByG_C_C(long groupId, long classNameId, 6290 long classPK) 6291 throws com.liferay.portal.kernel.exception.SystemException { 6292 return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK); 6293 } 6294 6295 /** 6296 * 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. 6297 * 6298 * @param groupId the group ID 6299 * @param classNameId the class name ID 6300 * @param structureId the structure ID 6301 * @return the matching journal article 6302 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6303 * @throws SystemException if a system exception occurred 6304 */ 6305 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S( 6306 long groupId, long classNameId, java.lang.String structureId) 6307 throws com.liferay.portal.kernel.exception.SystemException, 6308 com.liferay.portlet.journal.NoSuchArticleException { 6309 return getPersistence().findByG_C_S(groupId, classNameId, structureId); 6310 } 6311 6312 /** 6313 * 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. 6314 * 6315 * @param groupId the group ID 6316 * @param classNameId the class name ID 6317 * @param structureId the structure ID 6318 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6319 * @throws SystemException if a system exception occurred 6320 */ 6321 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 6322 long groupId, long classNameId, java.lang.String structureId) 6323 throws com.liferay.portal.kernel.exception.SystemException { 6324 return getPersistence().fetchByG_C_S(groupId, classNameId, structureId); 6325 } 6326 6327 /** 6328 * 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. 6329 * 6330 * @param groupId the group ID 6331 * @param classNameId the class name ID 6332 * @param structureId the structure ID 6333 * @param retrieveFromCache whether to use the finder cache 6334 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6335 * @throws SystemException if a system exception occurred 6336 */ 6337 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 6338 long groupId, long classNameId, java.lang.String structureId, 6339 boolean retrieveFromCache) 6340 throws com.liferay.portal.kernel.exception.SystemException { 6341 return getPersistence() 6342 .fetchByG_C_S(groupId, classNameId, structureId, 6343 retrieveFromCache); 6344 } 6345 6346 /** 6347 * Removes the journal article where groupId = ? and classNameId = ? and structureId = ? from the database. 6348 * 6349 * @param groupId the group ID 6350 * @param classNameId the class name ID 6351 * @param structureId the structure ID 6352 * @return the journal article that was removed 6353 * @throws SystemException if a system exception occurred 6354 */ 6355 public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S( 6356 long groupId, long classNameId, java.lang.String structureId) 6357 throws com.liferay.portal.kernel.exception.SystemException, 6358 com.liferay.portlet.journal.NoSuchArticleException { 6359 return getPersistence().removeByG_C_S(groupId, classNameId, structureId); 6360 } 6361 6362 /** 6363 * Returns the number of journal articles where groupId = ? and classNameId = ? and structureId = ?. 6364 * 6365 * @param groupId the group ID 6366 * @param classNameId the class name ID 6367 * @param structureId the structure ID 6368 * @return the number of matching journal articles 6369 * @throws SystemException if a system exception occurred 6370 */ 6371 public static int countByG_C_S(long groupId, long classNameId, 6372 java.lang.String structureId) 6373 throws com.liferay.portal.kernel.exception.SystemException { 6374 return getPersistence().countByG_C_S(groupId, classNameId, structureId); 6375 } 6376 6377 /** 6378 * Returns all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6379 * 6380 * @param groupId the group ID 6381 * @param classNameId the class name ID 6382 * @param templateId the template ID 6383 * @return the matching journal articles 6384 * @throws SystemException if a system exception occurred 6385 */ 6386 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6387 long groupId, long classNameId, java.lang.String templateId) 6388 throws com.liferay.portal.kernel.exception.SystemException { 6389 return getPersistence().findByG_C_T(groupId, classNameId, templateId); 6390 } 6391 6392 /** 6393 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6394 * 6395 * <p> 6396 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6397 * </p> 6398 * 6399 * @param groupId the group ID 6400 * @param classNameId the class name ID 6401 * @param templateId the template ID 6402 * @param start the lower bound of the range of journal articles 6403 * @param end the upper bound of the range of journal articles (not inclusive) 6404 * @return the range of matching journal articles 6405 * @throws SystemException if a system exception occurred 6406 */ 6407 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6408 long groupId, long classNameId, java.lang.String templateId, int start, 6409 int end) throws com.liferay.portal.kernel.exception.SystemException { 6410 return getPersistence() 6411 .findByG_C_T(groupId, classNameId, templateId, start, end); 6412 } 6413 6414 /** 6415 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 6416 * 6417 * <p> 6418 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6419 * </p> 6420 * 6421 * @param groupId the group ID 6422 * @param classNameId the class name ID 6423 * @param templateId the template ID 6424 * @param start the lower bound of the range of journal articles 6425 * @param end the upper bound of the range of journal articles (not inclusive) 6426 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6427 * @return the ordered range of matching journal articles 6428 * @throws SystemException if a system exception occurred 6429 */ 6430 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 6431 long groupId, long classNameId, java.lang.String templateId, int start, 6432 int end, 6433 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6434 throws com.liferay.portal.kernel.exception.SystemException { 6435 return getPersistence() 6436 .findByG_C_T(groupId, classNameId, templateId, start, end, 6437 orderByComparator); 6438 } 6439 6440 /** 6441 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6442 * 6443 * @param groupId the group ID 6444 * @param classNameId the class name ID 6445 * @param templateId the template ID 6446 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6447 * @return the first matching journal article 6448 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6449 * @throws SystemException if a system exception occurred 6450 */ 6451 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First( 6452 long groupId, long classNameId, java.lang.String templateId, 6453 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6454 throws com.liferay.portal.kernel.exception.SystemException, 6455 com.liferay.portlet.journal.NoSuchArticleException { 6456 return getPersistence() 6457 .findByG_C_T_First(groupId, classNameId, templateId, 6458 orderByComparator); 6459 } 6460 6461 /** 6462 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6463 * 6464 * @param groupId the group ID 6465 * @param classNameId the class name ID 6466 * @param templateId the template ID 6467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6468 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6469 * @throws SystemException if a system exception occurred 6470 */ 6471 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First( 6472 long groupId, long classNameId, java.lang.String templateId, 6473 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6474 throws com.liferay.portal.kernel.exception.SystemException { 6475 return getPersistence() 6476 .fetchByG_C_T_First(groupId, classNameId, templateId, 6477 orderByComparator); 6478 } 6479 6480 /** 6481 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6482 * 6483 * @param groupId the group ID 6484 * @param classNameId the class name ID 6485 * @param templateId the template ID 6486 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6487 * @return the last matching journal article 6488 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6489 * @throws SystemException if a system exception occurred 6490 */ 6491 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last( 6492 long groupId, long classNameId, java.lang.String templateId, 6493 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6494 throws com.liferay.portal.kernel.exception.SystemException, 6495 com.liferay.portlet.journal.NoSuchArticleException { 6496 return getPersistence() 6497 .findByG_C_T_Last(groupId, classNameId, templateId, 6498 orderByComparator); 6499 } 6500 6501 /** 6502 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6503 * 6504 * @param groupId the group ID 6505 * @param classNameId the class name ID 6506 * @param templateId the template ID 6507 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6508 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6509 * @throws SystemException if a system exception occurred 6510 */ 6511 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last( 6512 long groupId, long classNameId, java.lang.String templateId, 6513 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6514 throws com.liferay.portal.kernel.exception.SystemException { 6515 return getPersistence() 6516 .fetchByG_C_T_Last(groupId, classNameId, templateId, 6517 orderByComparator); 6518 } 6519 6520 /** 6521 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 6522 * 6523 * @param id the primary key of the current journal article 6524 * @param groupId the group ID 6525 * @param classNameId the class name ID 6526 * @param templateId the template ID 6527 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6528 * @return the previous, current, and next journal article 6529 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6530 * @throws SystemException if a system exception occurred 6531 */ 6532 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext( 6533 long id, long groupId, long classNameId, java.lang.String templateId, 6534 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6535 throws com.liferay.portal.kernel.exception.SystemException, 6536 com.liferay.portlet.journal.NoSuchArticleException { 6537 return getPersistence() 6538 .findByG_C_T_PrevAndNext(id, groupId, classNameId, 6539 templateId, orderByComparator); 6540 } 6541 6542 /** 6543 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6544 * 6545 * @param groupId the group ID 6546 * @param classNameId the class name ID 6547 * @param templateId the template ID 6548 * @return the matching journal articles that the user has permission to view 6549 * @throws SystemException if a system exception occurred 6550 */ 6551 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6552 long groupId, long classNameId, java.lang.String templateId) 6553 throws com.liferay.portal.kernel.exception.SystemException { 6554 return getPersistence() 6555 .filterFindByG_C_T(groupId, classNameId, templateId); 6556 } 6557 6558 /** 6559 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6560 * 6561 * <p> 6562 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6563 * </p> 6564 * 6565 * @param groupId the group ID 6566 * @param classNameId the class name ID 6567 * @param templateId the template ID 6568 * @param start the lower bound of the range of journal articles 6569 * @param end the upper bound of the range of journal articles (not inclusive) 6570 * @return the range of matching journal articles that the user has permission to view 6571 * @throws SystemException if a system exception occurred 6572 */ 6573 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6574 long groupId, long classNameId, java.lang.String templateId, int start, 6575 int end) throws com.liferay.portal.kernel.exception.SystemException { 6576 return getPersistence() 6577 .filterFindByG_C_T(groupId, classNameId, templateId, start, 6578 end); 6579 } 6580 6581 /** 6582 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and templateId = ?. 6583 * 6584 * <p> 6585 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6586 * </p> 6587 * 6588 * @param groupId the group ID 6589 * @param classNameId the class name ID 6590 * @param templateId the template ID 6591 * @param start the lower bound of the range of journal articles 6592 * @param end the upper bound of the range of journal articles (not inclusive) 6593 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6594 * @return the ordered range of matching journal articles that the user has permission to view 6595 * @throws SystemException if a system exception occurred 6596 */ 6597 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 6598 long groupId, long classNameId, java.lang.String templateId, int start, 6599 int end, 6600 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6601 throws com.liferay.portal.kernel.exception.SystemException { 6602 return getPersistence() 6603 .filterFindByG_C_T(groupId, classNameId, templateId, start, 6604 end, orderByComparator); 6605 } 6606 6607 /** 6608 * 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 = ?. 6609 * 6610 * @param id the primary key of the current journal article 6611 * @param groupId the group ID 6612 * @param classNameId the class name ID 6613 * @param templateId the template ID 6614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6615 * @return the previous, current, and next journal article 6616 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6617 * @throws SystemException if a system exception occurred 6618 */ 6619 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext( 6620 long id, long groupId, long classNameId, java.lang.String templateId, 6621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6622 throws com.liferay.portal.kernel.exception.SystemException, 6623 com.liferay.portlet.journal.NoSuchArticleException { 6624 return getPersistence() 6625 .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId, 6626 templateId, orderByComparator); 6627 } 6628 6629 /** 6630 * Removes all the journal articles where groupId = ? and classNameId = ? and templateId = ? from the database. 6631 * 6632 * @param groupId the group ID 6633 * @param classNameId the class name ID 6634 * @param templateId the template ID 6635 * @throws SystemException if a system exception occurred 6636 */ 6637 public static void removeByG_C_T(long groupId, long classNameId, 6638 java.lang.String templateId) 6639 throws com.liferay.portal.kernel.exception.SystemException { 6640 getPersistence().removeByG_C_T(groupId, classNameId, templateId); 6641 } 6642 6643 /** 6644 * Returns the number of journal articles where groupId = ? and classNameId = ? and templateId = ?. 6645 * 6646 * @param groupId the group ID 6647 * @param classNameId the class name ID 6648 * @param templateId the template ID 6649 * @return the number of matching journal articles 6650 * @throws SystemException if a system exception occurred 6651 */ 6652 public static int countByG_C_T(long groupId, long classNameId, 6653 java.lang.String templateId) 6654 throws com.liferay.portal.kernel.exception.SystemException { 6655 return getPersistence().countByG_C_T(groupId, classNameId, templateId); 6656 } 6657 6658 /** 6659 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 6660 * 6661 * @param groupId the group ID 6662 * @param classNameId the class name ID 6663 * @param templateId the template ID 6664 * @return the number of matching journal articles that the user has permission to view 6665 * @throws SystemException if a system exception occurred 6666 */ 6667 public static int filterCountByG_C_T(long groupId, long classNameId, 6668 java.lang.String templateId) 6669 throws com.liferay.portal.kernel.exception.SystemException { 6670 return getPersistence() 6671 .filterCountByG_C_T(groupId, classNameId, templateId); 6672 } 6673 6674 /** 6675 * Returns all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6676 * 6677 * @param groupId the group ID 6678 * @param classNameId the class name ID 6679 * @param layoutUuid the layout uuid 6680 * @return the matching journal articles 6681 * @throws SystemException if a system exception occurred 6682 */ 6683 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6684 long groupId, long classNameId, java.lang.String layoutUuid) 6685 throws com.liferay.portal.kernel.exception.SystemException { 6686 return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid); 6687 } 6688 6689 /** 6690 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6691 * 6692 * <p> 6693 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6694 * </p> 6695 * 6696 * @param groupId the group ID 6697 * @param classNameId the class name ID 6698 * @param layoutUuid the layout uuid 6699 * @param start the lower bound of the range of journal articles 6700 * @param end the upper bound of the range of journal articles (not inclusive) 6701 * @return the range of matching journal articles 6702 * @throws SystemException if a system exception occurred 6703 */ 6704 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6705 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6706 int end) throws com.liferay.portal.kernel.exception.SystemException { 6707 return getPersistence() 6708 .findByG_C_L(groupId, classNameId, layoutUuid, start, end); 6709 } 6710 6711 /** 6712 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6713 * 6714 * <p> 6715 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6716 * </p> 6717 * 6718 * @param groupId the group ID 6719 * @param classNameId the class name ID 6720 * @param layoutUuid the layout uuid 6721 * @param start the lower bound of the range of journal articles 6722 * @param end the upper bound of the range of journal articles (not inclusive) 6723 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6724 * @return the ordered range of matching journal articles 6725 * @throws SystemException if a system exception occurred 6726 */ 6727 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6728 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6729 int end, 6730 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6731 throws com.liferay.portal.kernel.exception.SystemException { 6732 return getPersistence() 6733 .findByG_C_L(groupId, classNameId, layoutUuid, start, end, 6734 orderByComparator); 6735 } 6736 6737 /** 6738 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6739 * 6740 * @param groupId the group ID 6741 * @param classNameId the class name ID 6742 * @param layoutUuid the layout uuid 6743 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6744 * @return the first matching journal article 6745 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6746 * @throws SystemException if a system exception occurred 6747 */ 6748 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First( 6749 long groupId, long classNameId, java.lang.String layoutUuid, 6750 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6751 throws com.liferay.portal.kernel.exception.SystemException, 6752 com.liferay.portlet.journal.NoSuchArticleException { 6753 return getPersistence() 6754 .findByG_C_L_First(groupId, classNameId, layoutUuid, 6755 orderByComparator); 6756 } 6757 6758 /** 6759 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6760 * 6761 * @param groupId the group ID 6762 * @param classNameId the class name ID 6763 * @param layoutUuid the layout uuid 6764 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6765 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6766 * @throws SystemException if a system exception occurred 6767 */ 6768 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First( 6769 long groupId, long classNameId, java.lang.String layoutUuid, 6770 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6771 throws com.liferay.portal.kernel.exception.SystemException { 6772 return getPersistence() 6773 .fetchByG_C_L_First(groupId, classNameId, layoutUuid, 6774 orderByComparator); 6775 } 6776 6777 /** 6778 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6779 * 6780 * @param groupId the group ID 6781 * @param classNameId the class name ID 6782 * @param layoutUuid the layout uuid 6783 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6784 * @return the last matching journal article 6785 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6786 * @throws SystemException if a system exception occurred 6787 */ 6788 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last( 6789 long groupId, long classNameId, java.lang.String layoutUuid, 6790 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6791 throws com.liferay.portal.kernel.exception.SystemException, 6792 com.liferay.portlet.journal.NoSuchArticleException { 6793 return getPersistence() 6794 .findByG_C_L_Last(groupId, classNameId, layoutUuid, 6795 orderByComparator); 6796 } 6797 6798 /** 6799 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6800 * 6801 * @param groupId the group ID 6802 * @param classNameId the class name ID 6803 * @param layoutUuid the layout uuid 6804 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6805 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6806 * @throws SystemException if a system exception occurred 6807 */ 6808 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last( 6809 long groupId, long classNameId, java.lang.String layoutUuid, 6810 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6811 throws com.liferay.portal.kernel.exception.SystemException { 6812 return getPersistence() 6813 .fetchByG_C_L_Last(groupId, classNameId, layoutUuid, 6814 orderByComparator); 6815 } 6816 6817 /** 6818 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6819 * 6820 * @param id the primary key of the current journal article 6821 * @param groupId the group ID 6822 * @param classNameId the class name ID 6823 * @param layoutUuid the layout uuid 6824 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6825 * @return the previous, current, and next journal article 6826 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6827 * @throws SystemException if a system exception occurred 6828 */ 6829 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext( 6830 long id, long groupId, long classNameId, java.lang.String layoutUuid, 6831 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6832 throws com.liferay.portal.kernel.exception.SystemException, 6833 com.liferay.portlet.journal.NoSuchArticleException { 6834 return getPersistence() 6835 .findByG_C_L_PrevAndNext(id, groupId, classNameId, 6836 layoutUuid, orderByComparator); 6837 } 6838 6839 /** 6840 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6841 * 6842 * @param groupId the group ID 6843 * @param classNameId the class name ID 6844 * @param layoutUuid the layout uuid 6845 * @return the matching journal articles that the user has permission to view 6846 * @throws SystemException if a system exception occurred 6847 */ 6848 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6849 long groupId, long classNameId, java.lang.String layoutUuid) 6850 throws com.liferay.portal.kernel.exception.SystemException { 6851 return getPersistence() 6852 .filterFindByG_C_L(groupId, classNameId, layoutUuid); 6853 } 6854 6855 /** 6856 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6857 * 6858 * <p> 6859 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6860 * </p> 6861 * 6862 * @param groupId the group ID 6863 * @param classNameId the class name ID 6864 * @param layoutUuid the layout uuid 6865 * @param start the lower bound of the range of journal articles 6866 * @param end the upper bound of the range of journal articles (not inclusive) 6867 * @return the range of matching journal articles that the user has permission to view 6868 * @throws SystemException if a system exception occurred 6869 */ 6870 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6871 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6872 int end) throws com.liferay.portal.kernel.exception.SystemException { 6873 return getPersistence() 6874 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 6875 end); 6876 } 6877 6878 /** 6879 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6880 * 6881 * <p> 6882 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6883 * </p> 6884 * 6885 * @param groupId the group ID 6886 * @param classNameId the class name ID 6887 * @param layoutUuid the layout uuid 6888 * @param start the lower bound of the range of journal articles 6889 * @param end the upper bound of the range of journal articles (not inclusive) 6890 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6891 * @return the ordered range of matching journal articles that the user has permission to view 6892 * @throws SystemException if a system exception occurred 6893 */ 6894 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6895 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6896 int end, 6897 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6898 throws com.liferay.portal.kernel.exception.SystemException { 6899 return getPersistence() 6900 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 6901 end, orderByComparator); 6902 } 6903 6904 /** 6905 * 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 = ?. 6906 * 6907 * @param id the primary key of the current journal article 6908 * @param groupId the group ID 6909 * @param classNameId the class name ID 6910 * @param layoutUuid the layout uuid 6911 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6912 * @return the previous, current, and next journal article 6913 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6914 * @throws SystemException if a system exception occurred 6915 */ 6916 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext( 6917 long id, long groupId, long classNameId, java.lang.String layoutUuid, 6918 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6919 throws com.liferay.portal.kernel.exception.SystemException, 6920 com.liferay.portlet.journal.NoSuchArticleException { 6921 return getPersistence() 6922 .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId, 6923 layoutUuid, orderByComparator); 6924 } 6925 6926 /** 6927 * Removes all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ? from the database. 6928 * 6929 * @param groupId the group ID 6930 * @param classNameId the class name ID 6931 * @param layoutUuid the layout uuid 6932 * @throws SystemException if a system exception occurred 6933 */ 6934 public static void removeByG_C_L(long groupId, long classNameId, 6935 java.lang.String layoutUuid) 6936 throws com.liferay.portal.kernel.exception.SystemException { 6937 getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid); 6938 } 6939 6940 /** 6941 * Returns the number of journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6942 * 6943 * @param groupId the group ID 6944 * @param classNameId the class name ID 6945 * @param layoutUuid the layout uuid 6946 * @return the number of matching journal articles 6947 * @throws SystemException if a system exception occurred 6948 */ 6949 public static int countByG_C_L(long groupId, long classNameId, 6950 java.lang.String layoutUuid) 6951 throws com.liferay.portal.kernel.exception.SystemException { 6952 return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid); 6953 } 6954 6955 /** 6956 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6957 * 6958 * @param groupId the group ID 6959 * @param classNameId the class name ID 6960 * @param layoutUuid the layout uuid 6961 * @return the number of matching journal articles that the user has permission to view 6962 * @throws SystemException if a system exception occurred 6963 */ 6964 public static int filterCountByG_C_L(long groupId, long classNameId, 6965 java.lang.String layoutUuid) 6966 throws com.liferay.portal.kernel.exception.SystemException { 6967 return getPersistence() 6968 .filterCountByG_C_L(groupId, classNameId, layoutUuid); 6969 } 6970 6971 /** 6972 * 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. 6973 * 6974 * @param groupId the group ID 6975 * @param articleId the article ID 6976 * @param version the version 6977 * @return the matching journal article 6978 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6979 * @throws SystemException if a system exception occurred 6980 */ 6981 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V( 6982 long groupId, java.lang.String articleId, double version) 6983 throws com.liferay.portal.kernel.exception.SystemException, 6984 com.liferay.portlet.journal.NoSuchArticleException { 6985 return getPersistence().findByG_A_V(groupId, articleId, version); 6986 } 6987 6988 /** 6989 * 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. 6990 * 6991 * @param groupId the group ID 6992 * @param articleId the article ID 6993 * @param version the version 6994 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6995 * @throws SystemException if a system exception occurred 6996 */ 6997 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 6998 long groupId, java.lang.String articleId, double version) 6999 throws com.liferay.portal.kernel.exception.SystemException { 7000 return getPersistence().fetchByG_A_V(groupId, articleId, version); 7001 } 7002 7003 /** 7004 * 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. 7005 * 7006 * @param groupId the group ID 7007 * @param articleId the article ID 7008 * @param version the version 7009 * @param retrieveFromCache whether to use the finder cache 7010 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7011 * @throws SystemException if a system exception occurred 7012 */ 7013 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 7014 long groupId, java.lang.String articleId, double version, 7015 boolean retrieveFromCache) 7016 throws com.liferay.portal.kernel.exception.SystemException { 7017 return getPersistence() 7018 .fetchByG_A_V(groupId, articleId, version, retrieveFromCache); 7019 } 7020 7021 /** 7022 * Removes the journal article where groupId = ? and articleId = ? and version = ? from the database. 7023 * 7024 * @param groupId the group ID 7025 * @param articleId the article ID 7026 * @param version the version 7027 * @return the journal article that was removed 7028 * @throws SystemException if a system exception occurred 7029 */ 7030 public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V( 7031 long groupId, java.lang.String articleId, double version) 7032 throws com.liferay.portal.kernel.exception.SystemException, 7033 com.liferay.portlet.journal.NoSuchArticleException { 7034 return getPersistence().removeByG_A_V(groupId, articleId, version); 7035 } 7036 7037 /** 7038 * Returns the number of journal articles where groupId = ? and articleId = ? and version = ?. 7039 * 7040 * @param groupId the group ID 7041 * @param articleId the article ID 7042 * @param version the version 7043 * @return the number of matching journal articles 7044 * @throws SystemException if a system exception occurred 7045 */ 7046 public static int countByG_A_V(long groupId, java.lang.String articleId, 7047 double version) 7048 throws com.liferay.portal.kernel.exception.SystemException { 7049 return getPersistence().countByG_A_V(groupId, articleId, version); 7050 } 7051 7052 /** 7053 * Returns all the journal articles where groupId = ? and articleId = ? and status = ?. 7054 * 7055 * @param groupId the group ID 7056 * @param articleId the article ID 7057 * @param status the status 7058 * @return the matching journal articles 7059 * @throws SystemException if a system exception occurred 7060 */ 7061 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7062 long groupId, java.lang.String articleId, int status) 7063 throws com.liferay.portal.kernel.exception.SystemException { 7064 return getPersistence().findByG_A_ST(groupId, articleId, status); 7065 } 7066 7067 /** 7068 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = ?. 7069 * 7070 * <p> 7071 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7072 * </p> 7073 * 7074 * @param groupId the group ID 7075 * @param articleId the article ID 7076 * @param status the status 7077 * @param start the lower bound of the range of journal articles 7078 * @param end the upper bound of the range of journal articles (not inclusive) 7079 * @return the range of matching journal articles 7080 * @throws SystemException if a system exception occurred 7081 */ 7082 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7083 long groupId, java.lang.String articleId, int status, int start, int end) 7084 throws com.liferay.portal.kernel.exception.SystemException { 7085 return getPersistence() 7086 .findByG_A_ST(groupId, articleId, status, start, end); 7087 } 7088 7089 /** 7090 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = ?. 7091 * 7092 * <p> 7093 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7094 * </p> 7095 * 7096 * @param groupId the group ID 7097 * @param articleId the article ID 7098 * @param status the status 7099 * @param start the lower bound of the range of journal articles 7100 * @param end the upper bound of the range of journal articles (not inclusive) 7101 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7102 * @return the ordered range of matching journal articles 7103 * @throws SystemException if a system exception occurred 7104 */ 7105 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7106 long groupId, java.lang.String articleId, int status, int start, 7107 int end, 7108 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7109 throws com.liferay.portal.kernel.exception.SystemException { 7110 return getPersistence() 7111 .findByG_A_ST(groupId, articleId, status, start, end, 7112 orderByComparator); 7113 } 7114 7115 /** 7116 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7117 * 7118 * @param groupId the group ID 7119 * @param articleId the article ID 7120 * @param status the status 7121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7122 * @return the first matching journal article 7123 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7124 * @throws SystemException if a system exception occurred 7125 */ 7126 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First( 7127 long groupId, java.lang.String articleId, int status, 7128 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7129 throws com.liferay.portal.kernel.exception.SystemException, 7130 com.liferay.portlet.journal.NoSuchArticleException { 7131 return getPersistence() 7132 .findByG_A_ST_First(groupId, articleId, status, 7133 orderByComparator); 7134 } 7135 7136 /** 7137 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7138 * 7139 * @param groupId the group ID 7140 * @param articleId the article ID 7141 * @param status the status 7142 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7143 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7144 * @throws SystemException if a system exception occurred 7145 */ 7146 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First( 7147 long groupId, java.lang.String articleId, int status, 7148 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7149 throws com.liferay.portal.kernel.exception.SystemException { 7150 return getPersistence() 7151 .fetchByG_A_ST_First(groupId, articleId, status, 7152 orderByComparator); 7153 } 7154 7155 /** 7156 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7157 * 7158 * @param groupId the group ID 7159 * @param articleId the article ID 7160 * @param status the status 7161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7162 * @return the last matching journal article 7163 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7164 * @throws SystemException if a system exception occurred 7165 */ 7166 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last( 7167 long groupId, java.lang.String articleId, int status, 7168 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7169 throws com.liferay.portal.kernel.exception.SystemException, 7170 com.liferay.portlet.journal.NoSuchArticleException { 7171 return getPersistence() 7172 .findByG_A_ST_Last(groupId, articleId, status, 7173 orderByComparator); 7174 } 7175 7176 /** 7177 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7178 * 7179 * @param groupId the group ID 7180 * @param articleId the article ID 7181 * @param status the status 7182 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7183 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7184 * @throws SystemException if a system exception occurred 7185 */ 7186 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last( 7187 long groupId, java.lang.String articleId, int status, 7188 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7189 throws com.liferay.portal.kernel.exception.SystemException { 7190 return getPersistence() 7191 .fetchByG_A_ST_Last(groupId, articleId, status, 7192 orderByComparator); 7193 } 7194 7195 /** 7196 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7197 * 7198 * @param id the primary key of the current journal article 7199 * @param groupId the group ID 7200 * @param articleId the article ID 7201 * @param status the status 7202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7203 * @return the previous, current, and next journal article 7204 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7205 * @throws SystemException if a system exception occurred 7206 */ 7207 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext( 7208 long id, long groupId, java.lang.String articleId, int status, 7209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7210 throws com.liferay.portal.kernel.exception.SystemException, 7211 com.liferay.portlet.journal.NoSuchArticleException { 7212 return getPersistence() 7213 .findByG_A_ST_PrevAndNext(id, groupId, articleId, status, 7214 orderByComparator); 7215 } 7216 7217 /** 7218 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7219 * 7220 * @param groupId the group ID 7221 * @param articleId the article ID 7222 * @param status the status 7223 * @return the matching journal articles that the user has permission to view 7224 * @throws SystemException if a system exception occurred 7225 */ 7226 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7227 long groupId, java.lang.String articleId, int status) 7228 throws com.liferay.portal.kernel.exception.SystemException { 7229 return getPersistence().filterFindByG_A_ST(groupId, articleId, status); 7230 } 7231 7232 /** 7233 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7234 * 7235 * <p> 7236 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7237 * </p> 7238 * 7239 * @param groupId the group ID 7240 * @param articleId the article ID 7241 * @param status the status 7242 * @param start the lower bound of the range of journal articles 7243 * @param end the upper bound of the range of journal articles (not inclusive) 7244 * @return the range of matching journal articles that the user has permission to view 7245 * @throws SystemException if a system exception occurred 7246 */ 7247 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7248 long groupId, java.lang.String articleId, int status, int start, int end) 7249 throws com.liferay.portal.kernel.exception.SystemException { 7250 return getPersistence() 7251 .filterFindByG_A_ST(groupId, articleId, status, start, end); 7252 } 7253 7254 /** 7255 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status = ?. 7256 * 7257 * <p> 7258 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7259 * </p> 7260 * 7261 * @param groupId the group ID 7262 * @param articleId the article ID 7263 * @param status the status 7264 * @param start the lower bound of the range of journal articles 7265 * @param end the upper bound of the range of journal articles (not inclusive) 7266 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7267 * @return the ordered range of matching journal articles that the user has permission to view 7268 * @throws SystemException if a system exception occurred 7269 */ 7270 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7271 long groupId, java.lang.String articleId, int status, int start, 7272 int end, 7273 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7274 throws com.liferay.portal.kernel.exception.SystemException { 7275 return getPersistence() 7276 .filterFindByG_A_ST(groupId, articleId, status, start, end, 7277 orderByComparator); 7278 } 7279 7280 /** 7281 * 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 = ?. 7282 * 7283 * @param id the primary key of the current journal article 7284 * @param groupId the group ID 7285 * @param articleId the article ID 7286 * @param status the status 7287 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7288 * @return the previous, current, and next journal article 7289 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7290 * @throws SystemException if a system exception occurred 7291 */ 7292 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext( 7293 long id, long groupId, java.lang.String articleId, int status, 7294 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7295 throws com.liferay.portal.kernel.exception.SystemException, 7296 com.liferay.portlet.journal.NoSuchArticleException { 7297 return getPersistence() 7298 .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId, 7299 status, orderByComparator); 7300 } 7301 7302 /** 7303 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7304 * 7305 * @param groupId the group ID 7306 * @param articleId the article ID 7307 * @param statuses the statuses 7308 * @return the matching journal articles that the user has permission to view 7309 * @throws SystemException if a system exception occurred 7310 */ 7311 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7312 long groupId, java.lang.String articleId, int[] statuses) 7313 throws com.liferay.portal.kernel.exception.SystemException { 7314 return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses); 7315 } 7316 7317 /** 7318 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7319 * 7320 * <p> 7321 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7322 * </p> 7323 * 7324 * @param groupId the group ID 7325 * @param articleId the article ID 7326 * @param statuses the statuses 7327 * @param start the lower bound of the range of journal articles 7328 * @param end the upper bound of the range of journal articles (not inclusive) 7329 * @return the range of matching journal articles that the user has permission to view 7330 * @throws SystemException if a system exception occurred 7331 */ 7332 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7333 long groupId, java.lang.String articleId, int[] statuses, int start, 7334 int end) throws com.liferay.portal.kernel.exception.SystemException { 7335 return getPersistence() 7336 .filterFindByG_A_ST(groupId, articleId, statuses, start, end); 7337 } 7338 7339 /** 7340 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7341 * 7342 * <p> 7343 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7344 * </p> 7345 * 7346 * @param groupId the group ID 7347 * @param articleId the article ID 7348 * @param statuses the statuses 7349 * @param start the lower bound of the range of journal articles 7350 * @param end the upper bound of the range of journal articles (not inclusive) 7351 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7352 * @return the ordered range of matching journal articles that the user has permission to view 7353 * @throws SystemException if a system exception occurred 7354 */ 7355 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 7356 long groupId, java.lang.String articleId, int[] statuses, int start, 7357 int end, 7358 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7359 throws com.liferay.portal.kernel.exception.SystemException { 7360 return getPersistence() 7361 .filterFindByG_A_ST(groupId, articleId, statuses, start, 7362 end, orderByComparator); 7363 } 7364 7365 /** 7366 * Returns all the journal articles where groupId = ? and articleId = ? and status = any ?. 7367 * 7368 * <p> 7369 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7370 * </p> 7371 * 7372 * @param groupId the group ID 7373 * @param articleId the article ID 7374 * @param statuses the statuses 7375 * @return the matching journal articles 7376 * @throws SystemException if a system exception occurred 7377 */ 7378 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7379 long groupId, java.lang.String articleId, int[] statuses) 7380 throws com.liferay.portal.kernel.exception.SystemException { 7381 return getPersistence().findByG_A_ST(groupId, articleId, statuses); 7382 } 7383 7384 /** 7385 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 7386 * 7387 * <p> 7388 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7389 * </p> 7390 * 7391 * @param groupId the group ID 7392 * @param articleId the article ID 7393 * @param statuses the statuses 7394 * @param start the lower bound of the range of journal articles 7395 * @param end the upper bound of the range of journal articles (not inclusive) 7396 * @return the range of matching journal articles 7397 * @throws SystemException if a system exception occurred 7398 */ 7399 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7400 long groupId, java.lang.String articleId, int[] statuses, int start, 7401 int end) throws com.liferay.portal.kernel.exception.SystemException { 7402 return getPersistence() 7403 .findByG_A_ST(groupId, articleId, statuses, start, end); 7404 } 7405 7406 /** 7407 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 7408 * 7409 * <p> 7410 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7411 * </p> 7412 * 7413 * @param groupId the group ID 7414 * @param articleId the article ID 7415 * @param statuses the statuses 7416 * @param start the lower bound of the range of journal articles 7417 * @param end the upper bound of the range of journal articles (not inclusive) 7418 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7419 * @return the ordered range of matching journal articles 7420 * @throws SystemException if a system exception occurred 7421 */ 7422 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7423 long groupId, java.lang.String articleId, int[] statuses, int start, 7424 int end, 7425 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7426 throws com.liferay.portal.kernel.exception.SystemException { 7427 return getPersistence() 7428 .findByG_A_ST(groupId, articleId, statuses, start, end, 7429 orderByComparator); 7430 } 7431 7432 /** 7433 * Removes all the journal articles where groupId = ? and articleId = ? and status = ? from the database. 7434 * 7435 * @param groupId the group ID 7436 * @param articleId the article ID 7437 * @param status the status 7438 * @throws SystemException if a system exception occurred 7439 */ 7440 public static void removeByG_A_ST(long groupId, java.lang.String articleId, 7441 int status) throws com.liferay.portal.kernel.exception.SystemException { 7442 getPersistence().removeByG_A_ST(groupId, articleId, status); 7443 } 7444 7445 /** 7446 * Returns the number of journal articles where groupId = ? and articleId = ? and status = ?. 7447 * 7448 * @param groupId the group ID 7449 * @param articleId the article ID 7450 * @param status the status 7451 * @return the number of matching journal articles 7452 * @throws SystemException if a system exception occurred 7453 */ 7454 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7455 int status) throws com.liferay.portal.kernel.exception.SystemException { 7456 return getPersistence().countByG_A_ST(groupId, articleId, status); 7457 } 7458 7459 /** 7460 * Returns the number of journal articles where groupId = ? and articleId = ? and status = any ?. 7461 * 7462 * @param groupId the group ID 7463 * @param articleId the article ID 7464 * @param statuses the statuses 7465 * @return the number of matching journal articles 7466 * @throws SystemException if a system exception occurred 7467 */ 7468 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7469 int[] statuses) 7470 throws com.liferay.portal.kernel.exception.SystemException { 7471 return getPersistence().countByG_A_ST(groupId, articleId, statuses); 7472 } 7473 7474 /** 7475 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7476 * 7477 * @param groupId the group ID 7478 * @param articleId the article ID 7479 * @param status the status 7480 * @return the number of matching journal articles that the user has permission to view 7481 * @throws SystemException if a system exception occurred 7482 */ 7483 public static int filterCountByG_A_ST(long groupId, 7484 java.lang.String articleId, int status) 7485 throws com.liferay.portal.kernel.exception.SystemException { 7486 return getPersistence().filterCountByG_A_ST(groupId, articleId, status); 7487 } 7488 7489 /** 7490 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7491 * 7492 * @param groupId the group ID 7493 * @param articleId the article ID 7494 * @param statuses the statuses 7495 * @return the number of matching journal articles that the user has permission to view 7496 * @throws SystemException if a system exception occurred 7497 */ 7498 public static int filterCountByG_A_ST(long groupId, 7499 java.lang.String articleId, int[] statuses) 7500 throws com.liferay.portal.kernel.exception.SystemException { 7501 return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses); 7502 } 7503 7504 /** 7505 * Returns all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7506 * 7507 * @param groupId the group ID 7508 * @param urlTitle the url title 7509 * @param status the status 7510 * @return the matching journal articles 7511 * @throws SystemException if a system exception occurred 7512 */ 7513 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7514 long groupId, java.lang.String urlTitle, int status) 7515 throws com.liferay.portal.kernel.exception.SystemException { 7516 return getPersistence().findByG_UT_ST(groupId, urlTitle, status); 7517 } 7518 7519 /** 7520 * Returns a range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7521 * 7522 * <p> 7523 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7524 * </p> 7525 * 7526 * @param groupId the group ID 7527 * @param urlTitle the url title 7528 * @param status the status 7529 * @param start the lower bound of the range of journal articles 7530 * @param end the upper bound of the range of journal articles (not inclusive) 7531 * @return the range of matching journal articles 7532 * @throws SystemException if a system exception occurred 7533 */ 7534 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7535 long groupId, java.lang.String urlTitle, int status, int start, int end) 7536 throws com.liferay.portal.kernel.exception.SystemException { 7537 return getPersistence() 7538 .findByG_UT_ST(groupId, urlTitle, status, start, end); 7539 } 7540 7541 /** 7542 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7543 * 7544 * <p> 7545 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7546 * </p> 7547 * 7548 * @param groupId the group ID 7549 * @param urlTitle the url title 7550 * @param status the status 7551 * @param start the lower bound of the range of journal articles 7552 * @param end the upper bound of the range of journal articles (not inclusive) 7553 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7554 * @return the ordered range of matching journal articles 7555 * @throws SystemException if a system exception occurred 7556 */ 7557 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7558 long groupId, java.lang.String urlTitle, int status, int start, 7559 int end, 7560 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7561 throws com.liferay.portal.kernel.exception.SystemException { 7562 return getPersistence() 7563 .findByG_UT_ST(groupId, urlTitle, status, start, end, 7564 orderByComparator); 7565 } 7566 7567 /** 7568 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7569 * 7570 * @param groupId the group ID 7571 * @param urlTitle the url title 7572 * @param status the status 7573 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7574 * @return the first matching journal article 7575 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7576 * @throws SystemException if a system exception occurred 7577 */ 7578 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First( 7579 long groupId, java.lang.String urlTitle, int status, 7580 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7581 throws com.liferay.portal.kernel.exception.SystemException, 7582 com.liferay.portlet.journal.NoSuchArticleException { 7583 return getPersistence() 7584 .findByG_UT_ST_First(groupId, urlTitle, status, 7585 orderByComparator); 7586 } 7587 7588 /** 7589 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7590 * 7591 * @param groupId the group ID 7592 * @param urlTitle the url title 7593 * @param status the status 7594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7595 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7596 * @throws SystemException if a system exception occurred 7597 */ 7598 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First( 7599 long groupId, java.lang.String urlTitle, int status, 7600 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7601 throws com.liferay.portal.kernel.exception.SystemException { 7602 return getPersistence() 7603 .fetchByG_UT_ST_First(groupId, urlTitle, status, 7604 orderByComparator); 7605 } 7606 7607 /** 7608 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7609 * 7610 * @param groupId the group ID 7611 * @param urlTitle the url title 7612 * @param status the status 7613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7614 * @return the last matching journal article 7615 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7616 * @throws SystemException if a system exception occurred 7617 */ 7618 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last( 7619 long groupId, java.lang.String urlTitle, int status, 7620 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7621 throws com.liferay.portal.kernel.exception.SystemException, 7622 com.liferay.portlet.journal.NoSuchArticleException { 7623 return getPersistence() 7624 .findByG_UT_ST_Last(groupId, urlTitle, status, 7625 orderByComparator); 7626 } 7627 7628 /** 7629 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7630 * 7631 * @param groupId the group ID 7632 * @param urlTitle the url title 7633 * @param status the status 7634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7635 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7636 * @throws SystemException if a system exception occurred 7637 */ 7638 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last( 7639 long groupId, java.lang.String urlTitle, int status, 7640 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7641 throws com.liferay.portal.kernel.exception.SystemException { 7642 return getPersistence() 7643 .fetchByG_UT_ST_Last(groupId, urlTitle, status, 7644 orderByComparator); 7645 } 7646 7647 /** 7648 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7649 * 7650 * @param id the primary key of the current journal article 7651 * @param groupId the group ID 7652 * @param urlTitle the url title 7653 * @param status the status 7654 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7655 * @return the previous, current, and next journal article 7656 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7657 * @throws SystemException if a system exception occurred 7658 */ 7659 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext( 7660 long id, long groupId, java.lang.String urlTitle, int status, 7661 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7662 throws com.liferay.portal.kernel.exception.SystemException, 7663 com.liferay.portlet.journal.NoSuchArticleException { 7664 return getPersistence() 7665 .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status, 7666 orderByComparator); 7667 } 7668 7669 /** 7670 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7671 * 7672 * @param groupId the group ID 7673 * @param urlTitle the url title 7674 * @param status the status 7675 * @return the matching journal articles that the user has permission to view 7676 * @throws SystemException if a system exception occurred 7677 */ 7678 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7679 long groupId, java.lang.String urlTitle, int status) 7680 throws com.liferay.portal.kernel.exception.SystemException { 7681 return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status); 7682 } 7683 7684 /** 7685 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7686 * 7687 * <p> 7688 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7689 * </p> 7690 * 7691 * @param groupId the group ID 7692 * @param urlTitle the url title 7693 * @param status the status 7694 * @param start the lower bound of the range of journal articles 7695 * @param end the upper bound of the range of journal articles (not inclusive) 7696 * @return the range of matching journal articles that the user has permission to view 7697 * @throws SystemException if a system exception occurred 7698 */ 7699 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7700 long groupId, java.lang.String urlTitle, int status, int start, int end) 7701 throws com.liferay.portal.kernel.exception.SystemException { 7702 return getPersistence() 7703 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end); 7704 } 7705 7706 /** 7707 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ? and status = ?. 7708 * 7709 * <p> 7710 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7711 * </p> 7712 * 7713 * @param groupId the group ID 7714 * @param urlTitle the url title 7715 * @param status the status 7716 * @param start the lower bound of the range of journal articles 7717 * @param end the upper bound of the range of journal articles (not inclusive) 7718 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7719 * @return the ordered range of matching journal articles that the user has permission to view 7720 * @throws SystemException if a system exception occurred 7721 */ 7722 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7723 long groupId, java.lang.String urlTitle, int status, int start, 7724 int end, 7725 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7726 throws com.liferay.portal.kernel.exception.SystemException { 7727 return getPersistence() 7728 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end, 7729 orderByComparator); 7730 } 7731 7732 /** 7733 * 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 = ?. 7734 * 7735 * @param id the primary key of the current journal article 7736 * @param groupId the group ID 7737 * @param urlTitle the url title 7738 * @param status the status 7739 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7740 * @return the previous, current, and next journal article 7741 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7742 * @throws SystemException if a system exception occurred 7743 */ 7744 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext( 7745 long id, long groupId, java.lang.String urlTitle, int status, 7746 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7747 throws com.liferay.portal.kernel.exception.SystemException, 7748 com.liferay.portlet.journal.NoSuchArticleException { 7749 return getPersistence() 7750 .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle, 7751 status, orderByComparator); 7752 } 7753 7754 /** 7755 * Removes all the journal articles where groupId = ? and urlTitle = ? and status = ? from the database. 7756 * 7757 * @param groupId the group ID 7758 * @param urlTitle the url title 7759 * @param status the status 7760 * @throws SystemException if a system exception occurred 7761 */ 7762 public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle, 7763 int status) throws com.liferay.portal.kernel.exception.SystemException { 7764 getPersistence().removeByG_UT_ST(groupId, urlTitle, status); 7765 } 7766 7767 /** 7768 * Returns the number of journal articles where groupId = ? and urlTitle = ? and status = ?. 7769 * 7770 * @param groupId the group ID 7771 * @param urlTitle the url title 7772 * @param status the status 7773 * @return the number of matching journal articles 7774 * @throws SystemException if a system exception occurred 7775 */ 7776 public static int countByG_UT_ST(long groupId, java.lang.String urlTitle, 7777 int status) throws com.liferay.portal.kernel.exception.SystemException { 7778 return getPersistence().countByG_UT_ST(groupId, urlTitle, status); 7779 } 7780 7781 /** 7782 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7783 * 7784 * @param groupId the group ID 7785 * @param urlTitle the url title 7786 * @param status the status 7787 * @return the number of matching journal articles that the user has permission to view 7788 * @throws SystemException if a system exception occurred 7789 */ 7790 public static int filterCountByG_UT_ST(long groupId, 7791 java.lang.String urlTitle, int status) 7792 throws com.liferay.portal.kernel.exception.SystemException { 7793 return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status); 7794 } 7795 7796 /** 7797 * Returns all the journal articles where companyId = ? and version = ? and status = ?. 7798 * 7799 * @param companyId the company ID 7800 * @param version the version 7801 * @param status the status 7802 * @return the matching journal articles 7803 * @throws SystemException if a system exception occurred 7804 */ 7805 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7806 long companyId, double version, int status) 7807 throws com.liferay.portal.kernel.exception.SystemException { 7808 return getPersistence().findByC_V_ST(companyId, version, status); 7809 } 7810 7811 /** 7812 * Returns a range of all the journal articles where companyId = ? and version = ? and status = ?. 7813 * 7814 * <p> 7815 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7816 * </p> 7817 * 7818 * @param companyId the company ID 7819 * @param version the version 7820 * @param status the status 7821 * @param start the lower bound of the range of journal articles 7822 * @param end the upper bound of the range of journal articles (not inclusive) 7823 * @return the range of matching journal articles 7824 * @throws SystemException if a system exception occurred 7825 */ 7826 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7827 long companyId, double version, int status, int start, int end) 7828 throws com.liferay.portal.kernel.exception.SystemException { 7829 return getPersistence() 7830 .findByC_V_ST(companyId, version, status, start, end); 7831 } 7832 7833 /** 7834 * Returns an ordered range of all the journal articles where companyId = ? and version = ? and status = ?. 7835 * 7836 * <p> 7837 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7838 * </p> 7839 * 7840 * @param companyId the company ID 7841 * @param version the version 7842 * @param status the status 7843 * @param start the lower bound of the range of journal articles 7844 * @param end the upper bound of the range of journal articles (not inclusive) 7845 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7846 * @return the ordered range of matching journal articles 7847 * @throws SystemException if a system exception occurred 7848 */ 7849 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7850 long companyId, double version, int status, int start, int end, 7851 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7852 throws com.liferay.portal.kernel.exception.SystemException { 7853 return getPersistence() 7854 .findByC_V_ST(companyId, version, status, start, end, 7855 orderByComparator); 7856 } 7857 7858 /** 7859 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 7860 * 7861 * @param companyId the company ID 7862 * @param version the version 7863 * @param status the status 7864 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7865 * @return the first matching journal article 7866 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7867 * @throws SystemException if a system exception occurred 7868 */ 7869 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First( 7870 long companyId, double version, int status, 7871 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7872 throws com.liferay.portal.kernel.exception.SystemException, 7873 com.liferay.portlet.journal.NoSuchArticleException { 7874 return getPersistence() 7875 .findByC_V_ST_First(companyId, version, status, 7876 orderByComparator); 7877 } 7878 7879 /** 7880 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 7881 * 7882 * @param companyId the company ID 7883 * @param version the version 7884 * @param status the status 7885 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7886 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7887 * @throws SystemException if a system exception occurred 7888 */ 7889 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First( 7890 long companyId, double version, int status, 7891 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7892 throws com.liferay.portal.kernel.exception.SystemException { 7893 return getPersistence() 7894 .fetchByC_V_ST_First(companyId, version, status, 7895 orderByComparator); 7896 } 7897 7898 /** 7899 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 7900 * 7901 * @param companyId the company ID 7902 * @param version the version 7903 * @param status the status 7904 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7905 * @return the last matching journal article 7906 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7907 * @throws SystemException if a system exception occurred 7908 */ 7909 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last( 7910 long companyId, double version, int status, 7911 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7912 throws com.liferay.portal.kernel.exception.SystemException, 7913 com.liferay.portlet.journal.NoSuchArticleException { 7914 return getPersistence() 7915 .findByC_V_ST_Last(companyId, version, status, 7916 orderByComparator); 7917 } 7918 7919 /** 7920 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 7921 * 7922 * @param companyId the company ID 7923 * @param version the version 7924 * @param status the status 7925 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7926 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7927 * @throws SystemException if a system exception occurred 7928 */ 7929 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last( 7930 long companyId, double version, int status, 7931 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7932 throws com.liferay.portal.kernel.exception.SystemException { 7933 return getPersistence() 7934 .fetchByC_V_ST_Last(companyId, version, status, 7935 orderByComparator); 7936 } 7937 7938 /** 7939 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ? and status = ?. 7940 * 7941 * @param id the primary key of the current journal article 7942 * @param companyId the company ID 7943 * @param version the version 7944 * @param status the status 7945 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7946 * @return the previous, current, and next journal article 7947 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7948 * @throws SystemException if a system exception occurred 7949 */ 7950 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext( 7951 long id, long companyId, double version, int status, 7952 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7953 throws com.liferay.portal.kernel.exception.SystemException, 7954 com.liferay.portlet.journal.NoSuchArticleException { 7955 return getPersistence() 7956 .findByC_V_ST_PrevAndNext(id, companyId, version, status, 7957 orderByComparator); 7958 } 7959 7960 /** 7961 * Removes all the journal articles where companyId = ? and version = ? and status = ? from the database. 7962 * 7963 * @param companyId the company ID 7964 * @param version the version 7965 * @param status the status 7966 * @throws SystemException if a system exception occurred 7967 */ 7968 public static void removeByC_V_ST(long companyId, double version, int status) 7969 throws com.liferay.portal.kernel.exception.SystemException { 7970 getPersistence().removeByC_V_ST(companyId, version, status); 7971 } 7972 7973 /** 7974 * Returns the number of journal articles where companyId = ? and version = ? and status = ?. 7975 * 7976 * @param companyId the company ID 7977 * @param version the version 7978 * @param status the status 7979 * @return the number of matching journal articles 7980 * @throws SystemException if a system exception occurred 7981 */ 7982 public static int countByC_V_ST(long companyId, double version, int status) 7983 throws com.liferay.portal.kernel.exception.SystemException { 7984 return getPersistence().countByC_V_ST(companyId, version, status); 7985 } 7986 7987 /** 7988 * Caches the journal article in the entity cache if it is enabled. 7989 * 7990 * @param journalArticle the journal article 7991 */ 7992 public static void cacheResult( 7993 com.liferay.portlet.journal.model.JournalArticle journalArticle) { 7994 getPersistence().cacheResult(journalArticle); 7995 } 7996 7997 /** 7998 * Caches the journal articles in the entity cache if it is enabled. 7999 * 8000 * @param journalArticles the journal articles 8001 */ 8002 public static void cacheResult( 8003 java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) { 8004 getPersistence().cacheResult(journalArticles); 8005 } 8006 8007 /** 8008 * Creates a new journal article with the primary key. Does not add the journal article to the database. 8009 * 8010 * @param id the primary key for the new journal article 8011 * @return the new journal article 8012 */ 8013 public static com.liferay.portlet.journal.model.JournalArticle create( 8014 long id) { 8015 return getPersistence().create(id); 8016 } 8017 8018 /** 8019 * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners. 8020 * 8021 * @param id the primary key of the journal article 8022 * @return the journal article that was removed 8023 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8024 * @throws SystemException if a system exception occurred 8025 */ 8026 public static com.liferay.portlet.journal.model.JournalArticle remove( 8027 long id) 8028 throws com.liferay.portal.kernel.exception.SystemException, 8029 com.liferay.portlet.journal.NoSuchArticleException { 8030 return getPersistence().remove(id); 8031 } 8032 8033 public static com.liferay.portlet.journal.model.JournalArticle updateImpl( 8034 com.liferay.portlet.journal.model.JournalArticle journalArticle) 8035 throws com.liferay.portal.kernel.exception.SystemException { 8036 return getPersistence().updateImpl(journalArticle); 8037 } 8038 8039 /** 8040 * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 8041 * 8042 * @param id the primary key of the journal article 8043 * @return the journal article 8044 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8045 * @throws SystemException if a system exception occurred 8046 */ 8047 public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey( 8048 long id) 8049 throws com.liferay.portal.kernel.exception.SystemException, 8050 com.liferay.portlet.journal.NoSuchArticleException { 8051 return getPersistence().findByPrimaryKey(id); 8052 } 8053 8054 /** 8055 * Returns the journal article with the primary key or returns <code>null</code> if it could not be found. 8056 * 8057 * @param id the primary key of the journal article 8058 * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found 8059 * @throws SystemException if a system exception occurred 8060 */ 8061 public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey( 8062 long id) throws com.liferay.portal.kernel.exception.SystemException { 8063 return getPersistence().fetchByPrimaryKey(id); 8064 } 8065 8066 /** 8067 * Returns all the journal articles. 8068 * 8069 * @return the journal articles 8070 * @throws SystemException if a system exception occurred 8071 */ 8072 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll() 8073 throws com.liferay.portal.kernel.exception.SystemException { 8074 return getPersistence().findAll(); 8075 } 8076 8077 /** 8078 * Returns a range of all the journal articles. 8079 * 8080 * <p> 8081 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8082 * </p> 8083 * 8084 * @param start the lower bound of the range of journal articles 8085 * @param end the upper bound of the range of journal articles (not inclusive) 8086 * @return the range of journal articles 8087 * @throws SystemException if a system exception occurred 8088 */ 8089 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 8090 int start, int end) 8091 throws com.liferay.portal.kernel.exception.SystemException { 8092 return getPersistence().findAll(start, end); 8093 } 8094 8095 /** 8096 * Returns an ordered range of all the journal articles. 8097 * 8098 * <p> 8099 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8100 * </p> 8101 * 8102 * @param start the lower bound of the range of journal articles 8103 * @param end the upper bound of the range of journal articles (not inclusive) 8104 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8105 * @return the ordered range of journal articles 8106 * @throws SystemException if a system exception occurred 8107 */ 8108 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 8109 int start, int end, 8110 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8111 throws com.liferay.portal.kernel.exception.SystemException { 8112 return getPersistence().findAll(start, end, orderByComparator); 8113 } 8114 8115 /** 8116 * Removes all the journal articles from the database. 8117 * 8118 * @throws SystemException if a system exception occurred 8119 */ 8120 public static void removeAll() 8121 throws com.liferay.portal.kernel.exception.SystemException { 8122 getPersistence().removeAll(); 8123 } 8124 8125 /** 8126 * Returns the number of journal articles. 8127 * 8128 * @return the number of journal articles 8129 * @throws SystemException if a system exception occurred 8130 */ 8131 public static int countAll() 8132 throws com.liferay.portal.kernel.exception.SystemException { 8133 return getPersistence().countAll(); 8134 } 8135 8136 public static JournalArticlePersistence getPersistence() { 8137 if (_persistence == null) { 8138 _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName()); 8139 8140 ReferenceRegistry.registerReference(JournalArticleUtil.class, 8141 "_persistence"); 8142 } 8143 8144 return _persistence; 8145 } 8146 8147 /** 8148 * @deprecated As of 6.2.0 8149 */ 8150 public void setPersistence(JournalArticlePersistence persistence) { 8151 } 8152 8153 private static JournalArticlePersistence _persistence; 8154 }