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