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 folderId = ? and status ≠ ?. 5018 * 5019 * @param groupId the group ID 5020 * @param folderId the folder ID 5021 * @param status the status 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_F_NotST( 5026 long groupId, long folderId, int status) 5027 throws com.liferay.portal.kernel.exception.SystemException { 5028 return getPersistence().findByG_F_NotST(groupId, folderId, status); 5029 } 5030 5031 /** 5032 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status ≠ ?. 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 folderId the folder ID 5040 * @param status the status 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_F_NotST( 5047 long groupId, long folderId, int status, int start, int end) 5048 throws com.liferay.portal.kernel.exception.SystemException { 5049 return getPersistence() 5050 .findByG_F_NotST(groupId, folderId, status, start, end); 5051 } 5052 5053 /** 5054 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status ≠ ?. 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 folderId the folder ID 5062 * @param status the status 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_F_NotST( 5070 long groupId, long folderId, int status, 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_F_NotST(groupId, folderId, status, start, end, 5075 orderByComparator); 5076 } 5077 5078 /** 5079 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 5080 * 5081 * @param groupId the group ID 5082 * @param folderId the folder ID 5083 * @param status the status 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_F_NotST_First( 5090 long groupId, long folderId, int status, 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_F_NotST_First(groupId, folderId, status, 5096 orderByComparator); 5097 } 5098 5099 /** 5100 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 5101 * 5102 * @param groupId the group ID 5103 * @param folderId the folder ID 5104 * @param status the status 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_F_NotST_First( 5110 long groupId, long folderId, int status, 5111 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5112 throws com.liferay.portal.kernel.exception.SystemException { 5113 return getPersistence() 5114 .fetchByG_F_NotST_First(groupId, folderId, status, 5115 orderByComparator); 5116 } 5117 5118 /** 5119 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 5120 * 5121 * @param groupId the group ID 5122 * @param folderId the folder ID 5123 * @param status the status 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_F_NotST_Last( 5130 long groupId, long folderId, int status, 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_F_NotST_Last(groupId, folderId, status, 5136 orderByComparator); 5137 } 5138 5139 /** 5140 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 5141 * 5142 * @param groupId the group ID 5143 * @param folderId the folder ID 5144 * @param status the status 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_F_NotST_Last( 5150 long groupId, long folderId, int status, 5151 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5152 throws com.liferay.portal.kernel.exception.SystemException { 5153 return getPersistence() 5154 .fetchByG_F_NotST_Last(groupId, folderId, status, 5155 orderByComparator); 5156 } 5157 5158 /** 5159 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ? and status ≠ ?. 5160 * 5161 * @param id the primary key of the current journal article 5162 * @param groupId the group ID 5163 * @param folderId the folder ID 5164 * @param status the status 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_F_NotST_PrevAndNext( 5171 long id, long groupId, long folderId, int status, 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_F_NotST_PrevAndNext(id, groupId, folderId, status, 5177 orderByComparator); 5178 } 5179 5180 /** 5181 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 5182 * 5183 * @param groupId the group ID 5184 * @param folderId the folder ID 5185 * @param status the status 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_F_NotST( 5190 long groupId, long folderId, int status) 5191 throws com.liferay.portal.kernel.exception.SystemException { 5192 return getPersistence().filterFindByG_F_NotST(groupId, folderId, status); 5193 } 5194 5195 /** 5196 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 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 folderId the folder ID 5204 * @param status the status 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_F_NotST( 5211 long groupId, long folderId, int status, int start, int end) 5212 throws com.liferay.portal.kernel.exception.SystemException { 5213 return getPersistence() 5214 .filterFindByG_F_NotST(groupId, folderId, status, 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 folderId = ? and status ≠ ?. 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 folderId the folder ID 5226 * @param status the status 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_F_NotST( 5234 long groupId, long folderId, int status, 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_F_NotST(groupId, folderId, status, 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 folderId = ? and status ≠ ?. 5244 * 5245 * @param id the primary key of the current journal article 5246 * @param groupId the group ID 5247 * @param folderId the folder ID 5248 * @param status the status 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_F_NotST_PrevAndNext( 5255 long id, long groupId, long folderId, int status, 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_F_NotST_PrevAndNext(id, groupId, folderId, 5261 status, orderByComparator); 5262 } 5263 5264 /** 5265 * Removes all the journal articles where groupId = ? and folderId = ? and status ≠ ? from the database. 5266 * 5267 * @param groupId the group ID 5268 * @param folderId the folder ID 5269 * @param status the status 5270 * @throws SystemException if a system exception occurred 5271 */ 5272 public static void removeByG_F_NotST(long groupId, long folderId, int status) 5273 throws com.liferay.portal.kernel.exception.SystemException { 5274 getPersistence().removeByG_F_NotST(groupId, folderId, status); 5275 } 5276 5277 /** 5278 * Returns the number of journal articles where groupId = ? and folderId = ? and status ≠ ?. 5279 * 5280 * @param groupId the group ID 5281 * @param folderId the folder ID 5282 * @param status the status 5283 * @return the number of matching journal articles 5284 * @throws SystemException if a system exception occurred 5285 */ 5286 public static int countByG_F_NotST(long groupId, long folderId, int status) 5287 throws com.liferay.portal.kernel.exception.SystemException { 5288 return getPersistence().countByG_F_NotST(groupId, folderId, status); 5289 } 5290 5291 /** 5292 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status ≠ ?. 5293 * 5294 * @param groupId the group ID 5295 * @param folderId the folder ID 5296 * @param status the status 5297 * @return the number of matching journal articles that the user has permission to view 5298 * @throws SystemException if a system exception occurred 5299 */ 5300 public static int filterCountByG_F_NotST(long groupId, long folderId, 5301 int status) throws com.liferay.portal.kernel.exception.SystemException { 5302 return getPersistence().filterCountByG_F_NotST(groupId, folderId, status); 5303 } 5304 5305 /** 5306 * Returns all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5307 * 5308 * @param groupId the group ID 5309 * @param classNameId the class name ID 5310 * @param classPK the class p k 5311 * @return the matching journal articles 5312 * @throws SystemException if a system exception occurred 5313 */ 5314 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5315 long groupId, long classNameId, long classPK) 5316 throws com.liferay.portal.kernel.exception.SystemException { 5317 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 5318 } 5319 5320 /** 5321 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5322 * 5323 * <p> 5324 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5325 * </p> 5326 * 5327 * @param groupId the group ID 5328 * @param classNameId the class name ID 5329 * @param classPK the class p k 5330 * @param start the lower bound of the range of journal articles 5331 * @param end the upper bound of the range of journal articles (not inclusive) 5332 * @return the range of matching journal articles 5333 * @throws SystemException if a system exception occurred 5334 */ 5335 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5336 long groupId, long classNameId, long classPK, int start, int end) 5337 throws com.liferay.portal.kernel.exception.SystemException { 5338 return getPersistence() 5339 .findByG_C_C(groupId, classNameId, classPK, start, end); 5340 } 5341 5342 /** 5343 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 5344 * 5345 * <p> 5346 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5347 * </p> 5348 * 5349 * @param groupId the group ID 5350 * @param classNameId the class name ID 5351 * @param classPK the class p k 5352 * @param start the lower bound of the range of journal articles 5353 * @param end the upper bound of the range of journal articles (not inclusive) 5354 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5355 * @return the ordered range of matching journal articles 5356 * @throws SystemException if a system exception occurred 5357 */ 5358 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 5359 long groupId, long classNameId, long classPK, int start, int end, 5360 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5361 throws com.liferay.portal.kernel.exception.SystemException { 5362 return getPersistence() 5363 .findByG_C_C(groupId, classNameId, classPK, start, end, 5364 orderByComparator); 5365 } 5366 5367 /** 5368 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5369 * 5370 * @param groupId the group ID 5371 * @param classNameId the class name ID 5372 * @param classPK the class p k 5373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5374 * @return the first matching journal article 5375 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5376 * @throws SystemException if a system exception occurred 5377 */ 5378 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First( 5379 long groupId, long classNameId, long classPK, 5380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5381 throws com.liferay.portal.kernel.exception.SystemException, 5382 com.liferay.portlet.journal.NoSuchArticleException { 5383 return getPersistence() 5384 .findByG_C_C_First(groupId, classNameId, classPK, 5385 orderByComparator); 5386 } 5387 5388 /** 5389 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5390 * 5391 * @param groupId the group ID 5392 * @param classNameId the class name ID 5393 * @param classPK the class p k 5394 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5395 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5396 * @throws SystemException if a system exception occurred 5397 */ 5398 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First( 5399 long groupId, long classNameId, long classPK, 5400 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5401 throws com.liferay.portal.kernel.exception.SystemException { 5402 return getPersistence() 5403 .fetchByG_C_C_First(groupId, classNameId, classPK, 5404 orderByComparator); 5405 } 5406 5407 /** 5408 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5409 * 5410 * @param groupId the group ID 5411 * @param classNameId the class name ID 5412 * @param classPK the class p k 5413 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5414 * @return the last matching journal article 5415 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5416 * @throws SystemException if a system exception occurred 5417 */ 5418 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last( 5419 long groupId, long classNameId, long classPK, 5420 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5421 throws com.liferay.portal.kernel.exception.SystemException, 5422 com.liferay.portlet.journal.NoSuchArticleException { 5423 return getPersistence() 5424 .findByG_C_C_Last(groupId, classNameId, classPK, 5425 orderByComparator); 5426 } 5427 5428 /** 5429 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5430 * 5431 * @param groupId the group ID 5432 * @param classNameId the class name ID 5433 * @param classPK the class p k 5434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5435 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5436 * @throws SystemException if a system exception occurred 5437 */ 5438 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last( 5439 long groupId, long classNameId, long classPK, 5440 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5441 throws com.liferay.portal.kernel.exception.SystemException { 5442 return getPersistence() 5443 .fetchByG_C_C_Last(groupId, classNameId, classPK, 5444 orderByComparator); 5445 } 5446 5447 /** 5448 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 5449 * 5450 * @param id the primary key of the current journal article 5451 * @param groupId the group ID 5452 * @param classNameId the class name ID 5453 * @param classPK the class p k 5454 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5455 * @return the previous, current, and next journal article 5456 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5457 * @throws SystemException if a system exception occurred 5458 */ 5459 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext( 5460 long id, long groupId, long classNameId, long classPK, 5461 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5462 throws com.liferay.portal.kernel.exception.SystemException, 5463 com.liferay.portlet.journal.NoSuchArticleException { 5464 return getPersistence() 5465 .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK, 5466 orderByComparator); 5467 } 5468 5469 /** 5470 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5471 * 5472 * @param groupId the group ID 5473 * @param classNameId the class name ID 5474 * @param classPK the class p k 5475 * @return the matching journal articles that the user has permission to view 5476 * @throws SystemException if a system exception occurred 5477 */ 5478 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5479 long groupId, long classNameId, long classPK) 5480 throws com.liferay.portal.kernel.exception.SystemException { 5481 return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK); 5482 } 5483 5484 /** 5485 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5486 * 5487 * <p> 5488 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5489 * </p> 5490 * 5491 * @param groupId the group ID 5492 * @param classNameId the class name ID 5493 * @param classPK the class p k 5494 * @param start the lower bound of the range of journal articles 5495 * @param end the upper bound of the range of journal articles (not inclusive) 5496 * @return the range of matching journal articles that the user has permission to view 5497 * @throws SystemException if a system exception occurred 5498 */ 5499 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5500 long groupId, long classNameId, long classPK, int start, int end) 5501 throws com.liferay.portal.kernel.exception.SystemException { 5502 return getPersistence() 5503 .filterFindByG_C_C(groupId, classNameId, classPK, start, end); 5504 } 5505 5506 /** 5507 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and classPK = ?. 5508 * 5509 * <p> 5510 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5511 * </p> 5512 * 5513 * @param groupId the group ID 5514 * @param classNameId the class name ID 5515 * @param classPK the class p k 5516 * @param start the lower bound of the range of journal articles 5517 * @param end the upper bound of the range of journal articles (not inclusive) 5518 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5519 * @return the ordered range of matching journal articles that the user has permission to view 5520 * @throws SystemException if a system exception occurred 5521 */ 5522 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 5523 long groupId, long classNameId, long classPK, int start, int end, 5524 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5525 throws com.liferay.portal.kernel.exception.SystemException { 5526 return getPersistence() 5527 .filterFindByG_C_C(groupId, classNameId, classPK, start, 5528 end, orderByComparator); 5529 } 5530 5531 /** 5532 * 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 = ?. 5533 * 5534 * @param id the primary key of the current journal article 5535 * @param groupId the group ID 5536 * @param classNameId the class name ID 5537 * @param classPK the class p k 5538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5539 * @return the previous, current, and next journal article 5540 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5541 * @throws SystemException if a system exception occurred 5542 */ 5543 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext( 5544 long id, long groupId, long classNameId, long classPK, 5545 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5546 throws com.liferay.portal.kernel.exception.SystemException, 5547 com.liferay.portlet.journal.NoSuchArticleException { 5548 return getPersistence() 5549 .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId, 5550 classPK, orderByComparator); 5551 } 5552 5553 /** 5554 * Removes all the journal articles where groupId = ? and classNameId = ? and classPK = ? from the database. 5555 * 5556 * @param groupId the group ID 5557 * @param classNameId the class name ID 5558 * @param classPK the class p k 5559 * @throws SystemException if a system exception occurred 5560 */ 5561 public static void removeByG_C_C(long groupId, long classNameId, 5562 long classPK) 5563 throws com.liferay.portal.kernel.exception.SystemException { 5564 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 5565 } 5566 5567 /** 5568 * Returns the number of journal articles where groupId = ? and classNameId = ? and classPK = ?. 5569 * 5570 * @param groupId the group ID 5571 * @param classNameId the class name ID 5572 * @param classPK the class p k 5573 * @return the number of matching journal articles 5574 * @throws SystemException if a system exception occurred 5575 */ 5576 public static int countByG_C_C(long groupId, long classNameId, long classPK) 5577 throws com.liferay.portal.kernel.exception.SystemException { 5578 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 5579 } 5580 5581 /** 5582 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 5583 * 5584 * @param groupId the group ID 5585 * @param classNameId the class name ID 5586 * @param classPK the class p k 5587 * @return the number of matching journal articles that the user has permission to view 5588 * @throws SystemException if a system exception occurred 5589 */ 5590 public static int filterCountByG_C_C(long groupId, long classNameId, 5591 long classPK) 5592 throws com.liferay.portal.kernel.exception.SystemException { 5593 return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK); 5594 } 5595 5596 /** 5597 * 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. 5598 * 5599 * @param groupId the group ID 5600 * @param classNameId the class name ID 5601 * @param structureId the structure ID 5602 * @return the matching journal article 5603 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5604 * @throws SystemException if a system exception occurred 5605 */ 5606 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S( 5607 long groupId, long classNameId, java.lang.String structureId) 5608 throws com.liferay.portal.kernel.exception.SystemException, 5609 com.liferay.portlet.journal.NoSuchArticleException { 5610 return getPersistence().findByG_C_S(groupId, classNameId, structureId); 5611 } 5612 5613 /** 5614 * 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. 5615 * 5616 * @param groupId the group ID 5617 * @param classNameId the class name ID 5618 * @param structureId the structure ID 5619 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 5620 * @throws SystemException if a system exception occurred 5621 */ 5622 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 5623 long groupId, long classNameId, java.lang.String structureId) 5624 throws com.liferay.portal.kernel.exception.SystemException { 5625 return getPersistence().fetchByG_C_S(groupId, classNameId, structureId); 5626 } 5627 5628 /** 5629 * 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. 5630 * 5631 * @param groupId the group ID 5632 * @param classNameId the class name ID 5633 * @param structureId the structure ID 5634 * @param retrieveFromCache whether to use the finder cache 5635 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 5636 * @throws SystemException if a system exception occurred 5637 */ 5638 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 5639 long groupId, long classNameId, java.lang.String structureId, 5640 boolean retrieveFromCache) 5641 throws com.liferay.portal.kernel.exception.SystemException { 5642 return getPersistence() 5643 .fetchByG_C_S(groupId, classNameId, structureId, 5644 retrieveFromCache); 5645 } 5646 5647 /** 5648 * Removes the journal article where groupId = ? and classNameId = ? and structureId = ? from the database. 5649 * 5650 * @param groupId the group ID 5651 * @param classNameId the class name ID 5652 * @param structureId the structure ID 5653 * @return the journal article that was removed 5654 * @throws SystemException if a system exception occurred 5655 */ 5656 public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S( 5657 long groupId, long classNameId, java.lang.String structureId) 5658 throws com.liferay.portal.kernel.exception.SystemException, 5659 com.liferay.portlet.journal.NoSuchArticleException { 5660 return getPersistence().removeByG_C_S(groupId, classNameId, structureId); 5661 } 5662 5663 /** 5664 * Returns the number of journal articles where groupId = ? and classNameId = ? and structureId = ?. 5665 * 5666 * @param groupId the group ID 5667 * @param classNameId the class name ID 5668 * @param structureId the structure ID 5669 * @return the number of matching journal articles 5670 * @throws SystemException if a system exception occurred 5671 */ 5672 public static int countByG_C_S(long groupId, long classNameId, 5673 java.lang.String structureId) 5674 throws com.liferay.portal.kernel.exception.SystemException { 5675 return getPersistence().countByG_C_S(groupId, classNameId, structureId); 5676 } 5677 5678 /** 5679 * Returns all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5680 * 5681 * @param groupId the group ID 5682 * @param classNameId the class name ID 5683 * @param templateId the template ID 5684 * @return the matching journal articles 5685 * @throws SystemException if a system exception occurred 5686 */ 5687 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5688 long groupId, long classNameId, java.lang.String templateId) 5689 throws com.liferay.portal.kernel.exception.SystemException { 5690 return getPersistence().findByG_C_T(groupId, classNameId, templateId); 5691 } 5692 5693 /** 5694 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5695 * 5696 * <p> 5697 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5698 * </p> 5699 * 5700 * @param groupId the group ID 5701 * @param classNameId the class name ID 5702 * @param templateId the template ID 5703 * @param start the lower bound of the range of journal articles 5704 * @param end the upper bound of the range of journal articles (not inclusive) 5705 * @return the range of matching journal articles 5706 * @throws SystemException if a system exception occurred 5707 */ 5708 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5709 long groupId, long classNameId, java.lang.String templateId, int start, 5710 int end) throws com.liferay.portal.kernel.exception.SystemException { 5711 return getPersistence() 5712 .findByG_C_T(groupId, classNameId, templateId, start, end); 5713 } 5714 5715 /** 5716 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 5717 * 5718 * <p> 5719 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5720 * </p> 5721 * 5722 * @param groupId the group ID 5723 * @param classNameId the class name ID 5724 * @param templateId the template ID 5725 * @param start the lower bound of the range of journal articles 5726 * @param end the upper bound of the range of journal articles (not inclusive) 5727 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5728 * @return the ordered range of matching journal articles 5729 * @throws SystemException if a system exception occurred 5730 */ 5731 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 5732 long groupId, long classNameId, java.lang.String templateId, int start, 5733 int end, 5734 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5735 throws com.liferay.portal.kernel.exception.SystemException { 5736 return getPersistence() 5737 .findByG_C_T(groupId, classNameId, templateId, start, end, 5738 orderByComparator); 5739 } 5740 5741 /** 5742 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5743 * 5744 * @param groupId the group ID 5745 * @param classNameId the class name ID 5746 * @param templateId the template ID 5747 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5748 * @return the first matching journal article 5749 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5750 * @throws SystemException if a system exception occurred 5751 */ 5752 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First( 5753 long groupId, long classNameId, java.lang.String templateId, 5754 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5755 throws com.liferay.portal.kernel.exception.SystemException, 5756 com.liferay.portlet.journal.NoSuchArticleException { 5757 return getPersistence() 5758 .findByG_C_T_First(groupId, classNameId, templateId, 5759 orderByComparator); 5760 } 5761 5762 /** 5763 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5764 * 5765 * @param groupId the group ID 5766 * @param classNameId the class name ID 5767 * @param templateId the template ID 5768 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5769 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5770 * @throws SystemException if a system exception occurred 5771 */ 5772 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First( 5773 long groupId, long classNameId, java.lang.String templateId, 5774 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5775 throws com.liferay.portal.kernel.exception.SystemException { 5776 return getPersistence() 5777 .fetchByG_C_T_First(groupId, classNameId, templateId, 5778 orderByComparator); 5779 } 5780 5781 /** 5782 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5783 * 5784 * @param groupId the group ID 5785 * @param classNameId the class name ID 5786 * @param templateId the template ID 5787 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5788 * @return the last matching journal article 5789 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5790 * @throws SystemException if a system exception occurred 5791 */ 5792 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last( 5793 long groupId, long classNameId, java.lang.String templateId, 5794 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5795 throws com.liferay.portal.kernel.exception.SystemException, 5796 com.liferay.portlet.journal.NoSuchArticleException { 5797 return getPersistence() 5798 .findByG_C_T_Last(groupId, classNameId, templateId, 5799 orderByComparator); 5800 } 5801 5802 /** 5803 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5804 * 5805 * @param groupId the group ID 5806 * @param classNameId the class name ID 5807 * @param templateId the template ID 5808 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5809 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5810 * @throws SystemException if a system exception occurred 5811 */ 5812 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last( 5813 long groupId, long classNameId, java.lang.String templateId, 5814 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5815 throws com.liferay.portal.kernel.exception.SystemException { 5816 return getPersistence() 5817 .fetchByG_C_T_Last(groupId, classNameId, templateId, 5818 orderByComparator); 5819 } 5820 5821 /** 5822 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 5823 * 5824 * @param id the primary key of the current journal article 5825 * @param groupId the group ID 5826 * @param classNameId the class name ID 5827 * @param templateId the template ID 5828 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5829 * @return the previous, current, and next journal article 5830 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5831 * @throws SystemException if a system exception occurred 5832 */ 5833 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext( 5834 long id, long groupId, long classNameId, java.lang.String templateId, 5835 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5836 throws com.liferay.portal.kernel.exception.SystemException, 5837 com.liferay.portlet.journal.NoSuchArticleException { 5838 return getPersistence() 5839 .findByG_C_T_PrevAndNext(id, groupId, classNameId, 5840 templateId, orderByComparator); 5841 } 5842 5843 /** 5844 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 5845 * 5846 * @param groupId the group ID 5847 * @param classNameId the class name ID 5848 * @param templateId the template ID 5849 * @return the matching journal articles that the user has permission to view 5850 * @throws SystemException if a system exception occurred 5851 */ 5852 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 5853 long groupId, long classNameId, java.lang.String templateId) 5854 throws com.liferay.portal.kernel.exception.SystemException { 5855 return getPersistence() 5856 .filterFindByG_C_T(groupId, classNameId, templateId); 5857 } 5858 5859 /** 5860 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 5861 * 5862 * <p> 5863 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5864 * </p> 5865 * 5866 * @param groupId the group ID 5867 * @param classNameId the class name ID 5868 * @param templateId the template ID 5869 * @param start the lower bound of the range of journal articles 5870 * @param end the upper bound of the range of journal articles (not inclusive) 5871 * @return the range of matching journal articles that the user has permission to view 5872 * @throws SystemException if a system exception occurred 5873 */ 5874 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 5875 long groupId, long classNameId, java.lang.String templateId, int start, 5876 int end) throws com.liferay.portal.kernel.exception.SystemException { 5877 return getPersistence() 5878 .filterFindByG_C_T(groupId, classNameId, templateId, start, 5879 end); 5880 } 5881 5882 /** 5883 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and templateId = ?. 5884 * 5885 * <p> 5886 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5887 * </p> 5888 * 5889 * @param groupId the group ID 5890 * @param classNameId the class name ID 5891 * @param templateId the template ID 5892 * @param start the lower bound of the range of journal articles 5893 * @param end the upper bound of the range of journal articles (not inclusive) 5894 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5895 * @return the ordered range of matching journal articles that the user has permission to view 5896 * @throws SystemException if a system exception occurred 5897 */ 5898 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 5899 long groupId, long classNameId, java.lang.String templateId, int start, 5900 int end, 5901 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5902 throws com.liferay.portal.kernel.exception.SystemException { 5903 return getPersistence() 5904 .filterFindByG_C_T(groupId, classNameId, templateId, start, 5905 end, orderByComparator); 5906 } 5907 5908 /** 5909 * 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 = ?. 5910 * 5911 * @param id the primary key of the current journal article 5912 * @param groupId the group ID 5913 * @param classNameId the class name ID 5914 * @param templateId the template ID 5915 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5916 * @return the previous, current, and next journal article 5917 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5918 * @throws SystemException if a system exception occurred 5919 */ 5920 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext( 5921 long id, long groupId, long classNameId, java.lang.String templateId, 5922 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5923 throws com.liferay.portal.kernel.exception.SystemException, 5924 com.liferay.portlet.journal.NoSuchArticleException { 5925 return getPersistence() 5926 .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId, 5927 templateId, orderByComparator); 5928 } 5929 5930 /** 5931 * Removes all the journal articles where groupId = ? and classNameId = ? and templateId = ? from the database. 5932 * 5933 * @param groupId the group ID 5934 * @param classNameId the class name ID 5935 * @param templateId the template ID 5936 * @throws SystemException if a system exception occurred 5937 */ 5938 public static void removeByG_C_T(long groupId, long classNameId, 5939 java.lang.String templateId) 5940 throws com.liferay.portal.kernel.exception.SystemException { 5941 getPersistence().removeByG_C_T(groupId, classNameId, templateId); 5942 } 5943 5944 /** 5945 * Returns the number of journal articles where groupId = ? and classNameId = ? and templateId = ?. 5946 * 5947 * @param groupId the group ID 5948 * @param classNameId the class name ID 5949 * @param templateId the template ID 5950 * @return the number of matching journal articles 5951 * @throws SystemException if a system exception occurred 5952 */ 5953 public static int countByG_C_T(long groupId, long classNameId, 5954 java.lang.String templateId) 5955 throws com.liferay.portal.kernel.exception.SystemException { 5956 return getPersistence().countByG_C_T(groupId, classNameId, templateId); 5957 } 5958 5959 /** 5960 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 5961 * 5962 * @param groupId the group ID 5963 * @param classNameId the class name ID 5964 * @param templateId the template ID 5965 * @return the number of matching journal articles that the user has permission to view 5966 * @throws SystemException if a system exception occurred 5967 */ 5968 public static int filterCountByG_C_T(long groupId, long classNameId, 5969 java.lang.String templateId) 5970 throws com.liferay.portal.kernel.exception.SystemException { 5971 return getPersistence() 5972 .filterCountByG_C_T(groupId, classNameId, templateId); 5973 } 5974 5975 /** 5976 * Returns all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 5977 * 5978 * @param groupId the group ID 5979 * @param classNameId the class name ID 5980 * @param layoutUuid the layout uuid 5981 * @return the matching journal articles 5982 * @throws SystemException if a system exception occurred 5983 */ 5984 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 5985 long groupId, long classNameId, java.lang.String layoutUuid) 5986 throws com.liferay.portal.kernel.exception.SystemException { 5987 return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid); 5988 } 5989 5990 /** 5991 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 5992 * 5993 * <p> 5994 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5995 * </p> 5996 * 5997 * @param groupId the group ID 5998 * @param classNameId the class name ID 5999 * @param layoutUuid the layout uuid 6000 * @param start the lower bound of the range of journal articles 6001 * @param end the upper bound of the range of journal articles (not inclusive) 6002 * @return the range of matching journal articles 6003 * @throws SystemException if a system exception occurred 6004 */ 6005 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6006 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6007 int end) throws com.liferay.portal.kernel.exception.SystemException { 6008 return getPersistence() 6009 .findByG_C_L(groupId, classNameId, layoutUuid, start, end); 6010 } 6011 6012 /** 6013 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6014 * 6015 * <p> 6016 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6017 * </p> 6018 * 6019 * @param groupId the group ID 6020 * @param classNameId the class name ID 6021 * @param layoutUuid the layout uuid 6022 * @param start the lower bound of the range of journal articles 6023 * @param end the upper bound of the range of journal articles (not inclusive) 6024 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6025 * @return the ordered range of matching journal articles 6026 * @throws SystemException if a system exception occurred 6027 */ 6028 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 6029 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6030 int end, 6031 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6032 throws com.liferay.portal.kernel.exception.SystemException { 6033 return getPersistence() 6034 .findByG_C_L(groupId, classNameId, layoutUuid, start, end, 6035 orderByComparator); 6036 } 6037 6038 /** 6039 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6040 * 6041 * @param groupId the group ID 6042 * @param classNameId the class name ID 6043 * @param layoutUuid the layout uuid 6044 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6045 * @return the first matching journal article 6046 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6047 * @throws SystemException if a system exception occurred 6048 */ 6049 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First( 6050 long groupId, long classNameId, java.lang.String layoutUuid, 6051 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6052 throws com.liferay.portal.kernel.exception.SystemException, 6053 com.liferay.portlet.journal.NoSuchArticleException { 6054 return getPersistence() 6055 .findByG_C_L_First(groupId, classNameId, layoutUuid, 6056 orderByComparator); 6057 } 6058 6059 /** 6060 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6061 * 6062 * @param groupId the group ID 6063 * @param classNameId the class name ID 6064 * @param layoutUuid the layout uuid 6065 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6066 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6067 * @throws SystemException if a system exception occurred 6068 */ 6069 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First( 6070 long groupId, long classNameId, java.lang.String layoutUuid, 6071 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6072 throws com.liferay.portal.kernel.exception.SystemException { 6073 return getPersistence() 6074 .fetchByG_C_L_First(groupId, classNameId, layoutUuid, 6075 orderByComparator); 6076 } 6077 6078 /** 6079 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6080 * 6081 * @param groupId the group ID 6082 * @param classNameId the class name ID 6083 * @param layoutUuid the layout uuid 6084 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6085 * @return the last matching journal article 6086 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6087 * @throws SystemException if a system exception occurred 6088 */ 6089 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last( 6090 long groupId, long classNameId, java.lang.String layoutUuid, 6091 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6092 throws com.liferay.portal.kernel.exception.SystemException, 6093 com.liferay.portlet.journal.NoSuchArticleException { 6094 return getPersistence() 6095 .findByG_C_L_Last(groupId, classNameId, layoutUuid, 6096 orderByComparator); 6097 } 6098 6099 /** 6100 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6101 * 6102 * @param groupId the group ID 6103 * @param classNameId the class name ID 6104 * @param layoutUuid the layout uuid 6105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6106 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6107 * @throws SystemException if a system exception occurred 6108 */ 6109 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last( 6110 long groupId, long classNameId, java.lang.String layoutUuid, 6111 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6112 throws com.liferay.portal.kernel.exception.SystemException { 6113 return getPersistence() 6114 .fetchByG_C_L_Last(groupId, classNameId, layoutUuid, 6115 orderByComparator); 6116 } 6117 6118 /** 6119 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 6120 * 6121 * @param id the primary key of the current journal article 6122 * @param groupId the group ID 6123 * @param classNameId the class name ID 6124 * @param layoutUuid the layout uuid 6125 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6126 * @return the previous, current, and next journal article 6127 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6128 * @throws SystemException if a system exception occurred 6129 */ 6130 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext( 6131 long id, long groupId, long classNameId, java.lang.String layoutUuid, 6132 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6133 throws com.liferay.portal.kernel.exception.SystemException, 6134 com.liferay.portlet.journal.NoSuchArticleException { 6135 return getPersistence() 6136 .findByG_C_L_PrevAndNext(id, groupId, classNameId, 6137 layoutUuid, orderByComparator); 6138 } 6139 6140 /** 6141 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6142 * 6143 * @param groupId the group ID 6144 * @param classNameId the class name ID 6145 * @param layoutUuid the layout uuid 6146 * @return the matching journal articles that the user has permission to view 6147 * @throws SystemException if a system exception occurred 6148 */ 6149 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6150 long groupId, long classNameId, java.lang.String layoutUuid) 6151 throws com.liferay.portal.kernel.exception.SystemException { 6152 return getPersistence() 6153 .filterFindByG_C_L(groupId, classNameId, layoutUuid); 6154 } 6155 6156 /** 6157 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6158 * 6159 * <p> 6160 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6161 * </p> 6162 * 6163 * @param groupId the group ID 6164 * @param classNameId the class name ID 6165 * @param layoutUuid the layout uuid 6166 * @param start the lower bound of the range of journal articles 6167 * @param end the upper bound of the range of journal articles (not inclusive) 6168 * @return the range of matching journal articles that the user has permission to view 6169 * @throws SystemException if a system exception occurred 6170 */ 6171 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6172 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6173 int end) throws com.liferay.portal.kernel.exception.SystemException { 6174 return getPersistence() 6175 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 6176 end); 6177 } 6178 6179 /** 6180 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6181 * 6182 * <p> 6183 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6184 * </p> 6185 * 6186 * @param groupId the group ID 6187 * @param classNameId the class name ID 6188 * @param layoutUuid the layout uuid 6189 * @param start the lower bound of the range of journal articles 6190 * @param end the upper bound of the range of journal articles (not inclusive) 6191 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6192 * @return the ordered range of matching journal articles that the user has permission to view 6193 * @throws SystemException if a system exception occurred 6194 */ 6195 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 6196 long groupId, long classNameId, java.lang.String layoutUuid, int start, 6197 int end, 6198 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6199 throws com.liferay.portal.kernel.exception.SystemException { 6200 return getPersistence() 6201 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 6202 end, orderByComparator); 6203 } 6204 6205 /** 6206 * 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 = ?. 6207 * 6208 * @param id the primary key of the current journal article 6209 * @param groupId the group ID 6210 * @param classNameId the class name ID 6211 * @param layoutUuid the layout uuid 6212 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6213 * @return the previous, current, and next journal article 6214 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6215 * @throws SystemException if a system exception occurred 6216 */ 6217 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext( 6218 long id, long groupId, long classNameId, java.lang.String layoutUuid, 6219 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6220 throws com.liferay.portal.kernel.exception.SystemException, 6221 com.liferay.portlet.journal.NoSuchArticleException { 6222 return getPersistence() 6223 .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId, 6224 layoutUuid, orderByComparator); 6225 } 6226 6227 /** 6228 * Removes all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ? from the database. 6229 * 6230 * @param groupId the group ID 6231 * @param classNameId the class name ID 6232 * @param layoutUuid the layout uuid 6233 * @throws SystemException if a system exception occurred 6234 */ 6235 public static void removeByG_C_L(long groupId, long classNameId, 6236 java.lang.String layoutUuid) 6237 throws com.liferay.portal.kernel.exception.SystemException { 6238 getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid); 6239 } 6240 6241 /** 6242 * Returns the number of journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 6243 * 6244 * @param groupId the group ID 6245 * @param classNameId the class name ID 6246 * @param layoutUuid the layout uuid 6247 * @return the number of matching journal articles 6248 * @throws SystemException if a system exception occurred 6249 */ 6250 public static int countByG_C_L(long groupId, long classNameId, 6251 java.lang.String layoutUuid) 6252 throws com.liferay.portal.kernel.exception.SystemException { 6253 return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid); 6254 } 6255 6256 /** 6257 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 6258 * 6259 * @param groupId the group ID 6260 * @param classNameId the class name ID 6261 * @param layoutUuid the layout uuid 6262 * @return the number of matching journal articles that the user has permission to view 6263 * @throws SystemException if a system exception occurred 6264 */ 6265 public static int filterCountByG_C_L(long groupId, long classNameId, 6266 java.lang.String layoutUuid) 6267 throws com.liferay.portal.kernel.exception.SystemException { 6268 return getPersistence() 6269 .filterCountByG_C_L(groupId, classNameId, layoutUuid); 6270 } 6271 6272 /** 6273 * Returns all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6274 * 6275 * @param groupId the group ID 6276 * @param userId the user ID 6277 * @param classNameId the class name ID 6278 * @return the matching journal articles 6279 * @throws SystemException if a system exception occurred 6280 */ 6281 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6282 long groupId, long userId, long classNameId) 6283 throws com.liferay.portal.kernel.exception.SystemException { 6284 return getPersistence().findByG_U_C(groupId, userId, classNameId); 6285 } 6286 6287 /** 6288 * Returns a range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6289 * 6290 * <p> 6291 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6292 * </p> 6293 * 6294 * @param groupId the group ID 6295 * @param userId the user ID 6296 * @param classNameId the class name ID 6297 * @param start the lower bound of the range of journal articles 6298 * @param end the upper bound of the range of journal articles (not inclusive) 6299 * @return the range of matching journal articles 6300 * @throws SystemException if a system exception occurred 6301 */ 6302 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6303 long groupId, long userId, long classNameId, int start, int end) 6304 throws com.liferay.portal.kernel.exception.SystemException { 6305 return getPersistence() 6306 .findByG_U_C(groupId, userId, classNameId, start, end); 6307 } 6308 6309 /** 6310 * Returns an ordered range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6311 * 6312 * <p> 6313 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6314 * </p> 6315 * 6316 * @param groupId the group ID 6317 * @param userId the user ID 6318 * @param classNameId the class name ID 6319 * @param start the lower bound of the range of journal articles 6320 * @param end the upper bound of the range of journal articles (not inclusive) 6321 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6322 * @return the ordered range of matching journal articles 6323 * @throws SystemException if a system exception occurred 6324 */ 6325 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6326 long groupId, long userId, long classNameId, int start, int end, 6327 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6328 throws com.liferay.portal.kernel.exception.SystemException { 6329 return getPersistence() 6330 .findByG_U_C(groupId, userId, classNameId, start, end, 6331 orderByComparator); 6332 } 6333 6334 /** 6335 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6336 * 6337 * @param groupId the group ID 6338 * @param userId the user ID 6339 * @param classNameId the class name ID 6340 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6341 * @return the first matching journal article 6342 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6343 * @throws SystemException if a system exception occurred 6344 */ 6345 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First( 6346 long groupId, long userId, long classNameId, 6347 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6348 throws com.liferay.portal.kernel.exception.SystemException, 6349 com.liferay.portlet.journal.NoSuchArticleException { 6350 return getPersistence() 6351 .findByG_U_C_First(groupId, userId, classNameId, 6352 orderByComparator); 6353 } 6354 6355 /** 6356 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6357 * 6358 * @param groupId the group ID 6359 * @param userId the user ID 6360 * @param classNameId the class name ID 6361 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6362 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6363 * @throws SystemException if a system exception occurred 6364 */ 6365 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First( 6366 long groupId, long userId, long classNameId, 6367 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6368 throws com.liferay.portal.kernel.exception.SystemException { 6369 return getPersistence() 6370 .fetchByG_U_C_First(groupId, userId, classNameId, 6371 orderByComparator); 6372 } 6373 6374 /** 6375 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6376 * 6377 * @param groupId the group ID 6378 * @param userId the user ID 6379 * @param classNameId the class name ID 6380 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6381 * @return the last matching journal article 6382 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6383 * @throws SystemException if a system exception occurred 6384 */ 6385 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last( 6386 long groupId, long userId, long classNameId, 6387 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6388 throws com.liferay.portal.kernel.exception.SystemException, 6389 com.liferay.portlet.journal.NoSuchArticleException { 6390 return getPersistence() 6391 .findByG_U_C_Last(groupId, userId, classNameId, 6392 orderByComparator); 6393 } 6394 6395 /** 6396 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6397 * 6398 * @param groupId the group ID 6399 * @param userId the user ID 6400 * @param classNameId the class name ID 6401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6402 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6403 * @throws SystemException if a system exception occurred 6404 */ 6405 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last( 6406 long groupId, long userId, long classNameId, 6407 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6408 throws com.liferay.portal.kernel.exception.SystemException { 6409 return getPersistence() 6410 .fetchByG_U_C_Last(groupId, userId, classNameId, 6411 orderByComparator); 6412 } 6413 6414 /** 6415 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6416 * 6417 * @param id the primary key of the current journal article 6418 * @param groupId the group ID 6419 * @param userId the user ID 6420 * @param classNameId the class name ID 6421 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6422 * @return the previous, current, and next journal article 6423 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6424 * @throws SystemException if a system exception occurred 6425 */ 6426 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext( 6427 long id, long groupId, long userId, long classNameId, 6428 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6429 throws com.liferay.portal.kernel.exception.SystemException, 6430 com.liferay.portlet.journal.NoSuchArticleException { 6431 return getPersistence() 6432 .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId, 6433 orderByComparator); 6434 } 6435 6436 /** 6437 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6438 * 6439 * @param groupId the group ID 6440 * @param userId the user ID 6441 * @param classNameId the class name ID 6442 * @return the matching journal articles that the user has permission to view 6443 * @throws SystemException if a system exception occurred 6444 */ 6445 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6446 long groupId, long userId, long classNameId) 6447 throws com.liferay.portal.kernel.exception.SystemException { 6448 return getPersistence().filterFindByG_U_C(groupId, userId, classNameId); 6449 } 6450 6451 /** 6452 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6453 * 6454 * <p> 6455 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6456 * </p> 6457 * 6458 * @param groupId the group ID 6459 * @param userId the user ID 6460 * @param classNameId the class name ID 6461 * @param start the lower bound of the range of journal articles 6462 * @param end the upper bound of the range of journal articles (not inclusive) 6463 * @return the range of matching journal articles that the user has permission to view 6464 * @throws SystemException if a system exception occurred 6465 */ 6466 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6467 long groupId, long userId, long classNameId, int start, int end) 6468 throws com.liferay.portal.kernel.exception.SystemException { 6469 return getPersistence() 6470 .filterFindByG_U_C(groupId, userId, classNameId, start, end); 6471 } 6472 6473 /** 6474 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ? and classNameId = ?. 6475 * 6476 * <p> 6477 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6478 * </p> 6479 * 6480 * @param groupId the group ID 6481 * @param userId the user ID 6482 * @param classNameId the class name ID 6483 * @param start the lower bound of the range of journal articles 6484 * @param end the upper bound of the range of journal articles (not inclusive) 6485 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6486 * @return the ordered range of matching journal articles that the user has permission to view 6487 * @throws SystemException if a system exception occurred 6488 */ 6489 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6490 long groupId, long userId, long classNameId, int start, int end, 6491 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6492 throws com.liferay.portal.kernel.exception.SystemException { 6493 return getPersistence() 6494 .filterFindByG_U_C(groupId, userId, classNameId, start, end, 6495 orderByComparator); 6496 } 6497 6498 /** 6499 * 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 = ?. 6500 * 6501 * @param id the primary key of the current journal article 6502 * @param groupId the group ID 6503 * @param userId the user ID 6504 * @param classNameId the class name ID 6505 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6506 * @return the previous, current, and next journal article 6507 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6508 * @throws SystemException if a system exception occurred 6509 */ 6510 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext( 6511 long id, long groupId, long userId, long classNameId, 6512 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6513 throws com.liferay.portal.kernel.exception.SystemException, 6514 com.liferay.portlet.journal.NoSuchArticleException { 6515 return getPersistence() 6516 .filterFindByG_U_C_PrevAndNext(id, groupId, userId, 6517 classNameId, orderByComparator); 6518 } 6519 6520 /** 6521 * Removes all the journal articles where groupId = ? and userId = ? and classNameId = ? from the database. 6522 * 6523 * @param groupId the group ID 6524 * @param userId the user ID 6525 * @param classNameId the class name ID 6526 * @throws SystemException if a system exception occurred 6527 */ 6528 public static void removeByG_U_C(long groupId, long userId, long classNameId) 6529 throws com.liferay.portal.kernel.exception.SystemException { 6530 getPersistence().removeByG_U_C(groupId, userId, classNameId); 6531 } 6532 6533 /** 6534 * Returns the number of journal articles where groupId = ? and userId = ? and classNameId = ?. 6535 * 6536 * @param groupId the group ID 6537 * @param userId the user ID 6538 * @param classNameId the class name ID 6539 * @return the number of matching journal articles 6540 * @throws SystemException if a system exception occurred 6541 */ 6542 public static int countByG_U_C(long groupId, long userId, long classNameId) 6543 throws com.liferay.portal.kernel.exception.SystemException { 6544 return getPersistence().countByG_U_C(groupId, userId, classNameId); 6545 } 6546 6547 /** 6548 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6549 * 6550 * @param groupId the group ID 6551 * @param userId the user ID 6552 * @param classNameId the class name ID 6553 * @return the number of matching journal articles that the user has permission to view 6554 * @throws SystemException if a system exception occurred 6555 */ 6556 public static int filterCountByG_U_C(long groupId, long userId, 6557 long classNameId) 6558 throws com.liferay.portal.kernel.exception.SystemException { 6559 return getPersistence().filterCountByG_U_C(groupId, userId, classNameId); 6560 } 6561 6562 /** 6563 * 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. 6564 * 6565 * @param groupId the group ID 6566 * @param articleId the article ID 6567 * @param version the version 6568 * @return the matching journal article 6569 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6570 * @throws SystemException if a system exception occurred 6571 */ 6572 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V( 6573 long groupId, java.lang.String articleId, double version) 6574 throws com.liferay.portal.kernel.exception.SystemException, 6575 com.liferay.portlet.journal.NoSuchArticleException { 6576 return getPersistence().findByG_A_V(groupId, articleId, version); 6577 } 6578 6579 /** 6580 * 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. 6581 * 6582 * @param groupId the group ID 6583 * @param articleId the article ID 6584 * @param version the version 6585 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6586 * @throws SystemException if a system exception occurred 6587 */ 6588 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 6589 long groupId, java.lang.String articleId, double version) 6590 throws com.liferay.portal.kernel.exception.SystemException { 6591 return getPersistence().fetchByG_A_V(groupId, articleId, version); 6592 } 6593 6594 /** 6595 * 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. 6596 * 6597 * @param groupId the group ID 6598 * @param articleId the article ID 6599 * @param version the version 6600 * @param retrieveFromCache whether to use the finder cache 6601 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 6602 * @throws SystemException if a system exception occurred 6603 */ 6604 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 6605 long groupId, java.lang.String articleId, double version, 6606 boolean retrieveFromCache) 6607 throws com.liferay.portal.kernel.exception.SystemException { 6608 return getPersistence() 6609 .fetchByG_A_V(groupId, articleId, version, retrieveFromCache); 6610 } 6611 6612 /** 6613 * Removes the journal article where groupId = ? and articleId = ? and version = ? from the database. 6614 * 6615 * @param groupId the group ID 6616 * @param articleId the article ID 6617 * @param version the version 6618 * @return the journal article that was removed 6619 * @throws SystemException if a system exception occurred 6620 */ 6621 public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V( 6622 long groupId, java.lang.String articleId, double version) 6623 throws com.liferay.portal.kernel.exception.SystemException, 6624 com.liferay.portlet.journal.NoSuchArticleException { 6625 return getPersistence().removeByG_A_V(groupId, articleId, version); 6626 } 6627 6628 /** 6629 * Returns the number of journal articles where groupId = ? and articleId = ? and version = ?. 6630 * 6631 * @param groupId the group ID 6632 * @param articleId the article ID 6633 * @param version the version 6634 * @return the number of matching journal articles 6635 * @throws SystemException if a system exception occurred 6636 */ 6637 public static int countByG_A_V(long groupId, java.lang.String articleId, 6638 double version) 6639 throws com.liferay.portal.kernel.exception.SystemException { 6640 return getPersistence().countByG_A_V(groupId, articleId, version); 6641 } 6642 6643 /** 6644 * Returns all the journal articles where groupId = ? and articleId = ? and status = ?. 6645 * 6646 * @param groupId the group ID 6647 * @param articleId the article ID 6648 * @param status the status 6649 * @return the matching journal articles 6650 * @throws SystemException if a system exception occurred 6651 */ 6652 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6653 long groupId, java.lang.String articleId, int status) 6654 throws com.liferay.portal.kernel.exception.SystemException { 6655 return getPersistence().findByG_A_ST(groupId, articleId, status); 6656 } 6657 6658 /** 6659 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = ?. 6660 * 6661 * <p> 6662 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6663 * </p> 6664 * 6665 * @param groupId the group ID 6666 * @param articleId the article ID 6667 * @param status the status 6668 * @param start the lower bound of the range of journal articles 6669 * @param end the upper bound of the range of journal articles (not inclusive) 6670 * @return the range of matching journal articles 6671 * @throws SystemException if a system exception occurred 6672 */ 6673 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6674 long groupId, java.lang.String articleId, int status, int start, int end) 6675 throws com.liferay.portal.kernel.exception.SystemException { 6676 return getPersistence() 6677 .findByG_A_ST(groupId, articleId, status, start, end); 6678 } 6679 6680 /** 6681 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = ?. 6682 * 6683 * <p> 6684 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6685 * </p> 6686 * 6687 * @param groupId the group ID 6688 * @param articleId the article ID 6689 * @param status the status 6690 * @param start the lower bound of the range of journal articles 6691 * @param end the upper bound of the range of journal articles (not inclusive) 6692 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6693 * @return the ordered range of matching journal articles 6694 * @throws SystemException if a system exception occurred 6695 */ 6696 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6697 long groupId, java.lang.String articleId, int status, int start, 6698 int end, 6699 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6700 throws com.liferay.portal.kernel.exception.SystemException { 6701 return getPersistence() 6702 .findByG_A_ST(groupId, articleId, status, start, end, 6703 orderByComparator); 6704 } 6705 6706 /** 6707 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6708 * 6709 * @param groupId the group ID 6710 * @param articleId the article ID 6711 * @param status the status 6712 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6713 * @return the first matching journal article 6714 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6715 * @throws SystemException if a system exception occurred 6716 */ 6717 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First( 6718 long groupId, java.lang.String articleId, int status, 6719 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6720 throws com.liferay.portal.kernel.exception.SystemException, 6721 com.liferay.portlet.journal.NoSuchArticleException { 6722 return getPersistence() 6723 .findByG_A_ST_First(groupId, articleId, status, 6724 orderByComparator); 6725 } 6726 6727 /** 6728 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6729 * 6730 * @param groupId the group ID 6731 * @param articleId the article ID 6732 * @param status the status 6733 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6734 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6735 * @throws SystemException if a system exception occurred 6736 */ 6737 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First( 6738 long groupId, java.lang.String articleId, int status, 6739 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6740 throws com.liferay.portal.kernel.exception.SystemException { 6741 return getPersistence() 6742 .fetchByG_A_ST_First(groupId, articleId, status, 6743 orderByComparator); 6744 } 6745 6746 /** 6747 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6748 * 6749 * @param groupId the group ID 6750 * @param articleId the article ID 6751 * @param status the status 6752 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6753 * @return the last matching journal article 6754 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6755 * @throws SystemException if a system exception occurred 6756 */ 6757 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last( 6758 long groupId, java.lang.String articleId, int status, 6759 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6760 throws com.liferay.portal.kernel.exception.SystemException, 6761 com.liferay.portlet.journal.NoSuchArticleException { 6762 return getPersistence() 6763 .findByG_A_ST_Last(groupId, articleId, status, 6764 orderByComparator); 6765 } 6766 6767 /** 6768 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6769 * 6770 * @param groupId the group ID 6771 * @param articleId the article ID 6772 * @param status the status 6773 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6774 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6775 * @throws SystemException if a system exception occurred 6776 */ 6777 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last( 6778 long groupId, java.lang.String articleId, int status, 6779 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6780 throws com.liferay.portal.kernel.exception.SystemException { 6781 return getPersistence() 6782 .fetchByG_A_ST_Last(groupId, articleId, status, 6783 orderByComparator); 6784 } 6785 6786 /** 6787 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 6788 * 6789 * @param id the primary key of the current journal article 6790 * @param groupId the group ID 6791 * @param articleId the article ID 6792 * @param status the status 6793 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6794 * @return the previous, current, and next journal article 6795 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6796 * @throws SystemException if a system exception occurred 6797 */ 6798 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext( 6799 long id, long groupId, java.lang.String articleId, int status, 6800 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6801 throws com.liferay.portal.kernel.exception.SystemException, 6802 com.liferay.portlet.journal.NoSuchArticleException { 6803 return getPersistence() 6804 .findByG_A_ST_PrevAndNext(id, groupId, articleId, status, 6805 orderByComparator); 6806 } 6807 6808 /** 6809 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 6810 * 6811 * @param groupId the group ID 6812 * @param articleId the article ID 6813 * @param status the status 6814 * @return the matching journal articles that the user has permission to view 6815 * @throws SystemException if a system exception occurred 6816 */ 6817 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6818 long groupId, java.lang.String articleId, int status) 6819 throws com.liferay.portal.kernel.exception.SystemException { 6820 return getPersistence().filterFindByG_A_ST(groupId, articleId, status); 6821 } 6822 6823 /** 6824 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 6825 * 6826 * <p> 6827 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6828 * </p> 6829 * 6830 * @param groupId the group ID 6831 * @param articleId the article ID 6832 * @param status the status 6833 * @param start the lower bound of the range of journal articles 6834 * @param end the upper bound of the range of journal articles (not inclusive) 6835 * @return the range of matching journal articles that the user has permission to view 6836 * @throws SystemException if a system exception occurred 6837 */ 6838 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6839 long groupId, java.lang.String articleId, int status, int start, int end) 6840 throws com.liferay.portal.kernel.exception.SystemException { 6841 return getPersistence() 6842 .filterFindByG_A_ST(groupId, articleId, status, start, end); 6843 } 6844 6845 /** 6846 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status = ?. 6847 * 6848 * <p> 6849 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6850 * </p> 6851 * 6852 * @param groupId the group ID 6853 * @param articleId the article ID 6854 * @param status the status 6855 * @param start the lower bound of the range of journal articles 6856 * @param end the upper bound of the range of journal articles (not inclusive) 6857 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6858 * @return the ordered range of matching journal articles that the user has permission to view 6859 * @throws SystemException if a system exception occurred 6860 */ 6861 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6862 long groupId, java.lang.String articleId, int status, int start, 6863 int end, 6864 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6865 throws com.liferay.portal.kernel.exception.SystemException { 6866 return getPersistence() 6867 .filterFindByG_A_ST(groupId, articleId, status, start, end, 6868 orderByComparator); 6869 } 6870 6871 /** 6872 * 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 = ?. 6873 * 6874 * @param id the primary key of the current journal article 6875 * @param groupId the group ID 6876 * @param articleId the article ID 6877 * @param status the status 6878 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6879 * @return the previous, current, and next journal article 6880 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6881 * @throws SystemException if a system exception occurred 6882 */ 6883 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext( 6884 long id, long groupId, java.lang.String articleId, int status, 6885 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6886 throws com.liferay.portal.kernel.exception.SystemException, 6887 com.liferay.portlet.journal.NoSuchArticleException { 6888 return getPersistence() 6889 .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId, 6890 status, orderByComparator); 6891 } 6892 6893 /** 6894 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 6895 * 6896 * @param groupId the group ID 6897 * @param articleId the article ID 6898 * @param statuses the statuses 6899 * @return the matching journal articles that the user has permission to view 6900 * @throws SystemException if a system exception occurred 6901 */ 6902 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6903 long groupId, java.lang.String articleId, int[] statuses) 6904 throws com.liferay.portal.kernel.exception.SystemException { 6905 return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses); 6906 } 6907 6908 /** 6909 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 6910 * 6911 * <p> 6912 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6913 * </p> 6914 * 6915 * @param groupId the group ID 6916 * @param articleId the article ID 6917 * @param statuses the statuses 6918 * @param start the lower bound of the range of journal articles 6919 * @param end the upper bound of the range of journal articles (not inclusive) 6920 * @return the range of matching journal articles that the user has permission to view 6921 * @throws SystemException if a system exception occurred 6922 */ 6923 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6924 long groupId, java.lang.String articleId, int[] statuses, int start, 6925 int end) throws com.liferay.portal.kernel.exception.SystemException { 6926 return getPersistence() 6927 .filterFindByG_A_ST(groupId, articleId, statuses, start, end); 6928 } 6929 6930 /** 6931 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 6932 * 6933 * <p> 6934 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6935 * </p> 6936 * 6937 * @param groupId the group ID 6938 * @param articleId the article ID 6939 * @param statuses the statuses 6940 * @param start the lower bound of the range of journal articles 6941 * @param end the upper bound of the range of journal articles (not inclusive) 6942 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6943 * @return the ordered range of matching journal articles that the user has permission to view 6944 * @throws SystemException if a system exception occurred 6945 */ 6946 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 6947 long groupId, java.lang.String articleId, int[] statuses, int start, 6948 int end, 6949 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6950 throws com.liferay.portal.kernel.exception.SystemException { 6951 return getPersistence() 6952 .filterFindByG_A_ST(groupId, articleId, statuses, start, 6953 end, orderByComparator); 6954 } 6955 6956 /** 6957 * Returns all the journal articles where groupId = ? and articleId = ? and status = any ?. 6958 * 6959 * <p> 6960 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6961 * </p> 6962 * 6963 * @param groupId the group ID 6964 * @param articleId the article ID 6965 * @param statuses the statuses 6966 * @return the matching journal articles 6967 * @throws SystemException if a system exception occurred 6968 */ 6969 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6970 long groupId, java.lang.String articleId, int[] statuses) 6971 throws com.liferay.portal.kernel.exception.SystemException { 6972 return getPersistence().findByG_A_ST(groupId, articleId, statuses); 6973 } 6974 6975 /** 6976 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 6977 * 6978 * <p> 6979 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6980 * </p> 6981 * 6982 * @param groupId the group ID 6983 * @param articleId the article ID 6984 * @param statuses the statuses 6985 * @param start the lower bound of the range of journal articles 6986 * @param end the upper bound of the range of journal articles (not inclusive) 6987 * @return the range of matching journal articles 6988 * @throws SystemException if a system exception occurred 6989 */ 6990 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 6991 long groupId, java.lang.String articleId, int[] statuses, int start, 6992 int end) throws com.liferay.portal.kernel.exception.SystemException { 6993 return getPersistence() 6994 .findByG_A_ST(groupId, articleId, statuses, start, end); 6995 } 6996 6997 /** 6998 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 6999 * 7000 * <p> 7001 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7002 * </p> 7003 * 7004 * @param groupId the group ID 7005 * @param articleId the article ID 7006 * @param statuses the statuses 7007 * @param start the lower bound of the range of journal articles 7008 * @param end the upper bound of the range of journal articles (not inclusive) 7009 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7010 * @return the ordered range of matching journal articles 7011 * @throws SystemException if a system exception occurred 7012 */ 7013 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7014 long groupId, java.lang.String articleId, int[] statuses, int start, 7015 int end, 7016 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7017 throws com.liferay.portal.kernel.exception.SystemException { 7018 return getPersistence() 7019 .findByG_A_ST(groupId, articleId, statuses, start, end, 7020 orderByComparator); 7021 } 7022 7023 /** 7024 * Removes all the journal articles where groupId = ? and articleId = ? and status = ? from the database. 7025 * 7026 * @param groupId the group ID 7027 * @param articleId the article ID 7028 * @param status the status 7029 * @throws SystemException if a system exception occurred 7030 */ 7031 public static void removeByG_A_ST(long groupId, java.lang.String articleId, 7032 int status) throws com.liferay.portal.kernel.exception.SystemException { 7033 getPersistence().removeByG_A_ST(groupId, articleId, status); 7034 } 7035 7036 /** 7037 * Returns the number of journal articles where groupId = ? and articleId = ? and status = ?. 7038 * 7039 * @param groupId the group ID 7040 * @param articleId the article ID 7041 * @param status the status 7042 * @return the number of matching journal articles 7043 * @throws SystemException if a system exception occurred 7044 */ 7045 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7046 int status) throws com.liferay.portal.kernel.exception.SystemException { 7047 return getPersistence().countByG_A_ST(groupId, articleId, status); 7048 } 7049 7050 /** 7051 * Returns the number of journal articles where groupId = ? and articleId = ? and status = any ?. 7052 * 7053 * @param groupId the group ID 7054 * @param articleId the article ID 7055 * @param statuses the statuses 7056 * @return the number of matching journal articles 7057 * @throws SystemException if a system exception occurred 7058 */ 7059 public static int countByG_A_ST(long groupId, java.lang.String articleId, 7060 int[] statuses) 7061 throws com.liferay.portal.kernel.exception.SystemException { 7062 return getPersistence().countByG_A_ST(groupId, articleId, statuses); 7063 } 7064 7065 /** 7066 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 7067 * 7068 * @param groupId the group ID 7069 * @param articleId the article ID 7070 * @param status the status 7071 * @return the number of matching journal articles that the user has permission to view 7072 * @throws SystemException if a system exception occurred 7073 */ 7074 public static int filterCountByG_A_ST(long groupId, 7075 java.lang.String articleId, int status) 7076 throws com.liferay.portal.kernel.exception.SystemException { 7077 return getPersistence().filterCountByG_A_ST(groupId, articleId, status); 7078 } 7079 7080 /** 7081 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 7082 * 7083 * @param groupId the group ID 7084 * @param articleId the article ID 7085 * @param statuses the statuses 7086 * @return the number of matching journal articles that the user has permission to view 7087 * @throws SystemException if a system exception occurred 7088 */ 7089 public static int filterCountByG_A_ST(long groupId, 7090 java.lang.String articleId, int[] statuses) 7091 throws com.liferay.portal.kernel.exception.SystemException { 7092 return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses); 7093 } 7094 7095 /** 7096 * Returns all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7097 * 7098 * @param groupId the group ID 7099 * @param urlTitle the url title 7100 * @param status the status 7101 * @return the matching journal articles 7102 * @throws SystemException if a system exception occurred 7103 */ 7104 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7105 long groupId, java.lang.String urlTitle, int status) 7106 throws com.liferay.portal.kernel.exception.SystemException { 7107 return getPersistence().findByG_UT_ST(groupId, urlTitle, status); 7108 } 7109 7110 /** 7111 * Returns a range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7112 * 7113 * <p> 7114 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7115 * </p> 7116 * 7117 * @param groupId the group ID 7118 * @param urlTitle the url title 7119 * @param status the status 7120 * @param start the lower bound of the range of journal articles 7121 * @param end the upper bound of the range of journal articles (not inclusive) 7122 * @return the range of matching journal articles 7123 * @throws SystemException if a system exception occurred 7124 */ 7125 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7126 long groupId, java.lang.String urlTitle, int status, int start, int end) 7127 throws com.liferay.portal.kernel.exception.SystemException { 7128 return getPersistence() 7129 .findByG_UT_ST(groupId, urlTitle, status, start, end); 7130 } 7131 7132 /** 7133 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 7134 * 7135 * <p> 7136 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7137 * </p> 7138 * 7139 * @param groupId the group ID 7140 * @param urlTitle the url title 7141 * @param status the status 7142 * @param start the lower bound of the range of journal articles 7143 * @param end the upper bound of the range of journal articles (not inclusive) 7144 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7145 * @return the ordered range of matching journal articles 7146 * @throws SystemException if a system exception occurred 7147 */ 7148 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 7149 long groupId, java.lang.String urlTitle, int status, int start, 7150 int end, 7151 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7152 throws com.liferay.portal.kernel.exception.SystemException { 7153 return getPersistence() 7154 .findByG_UT_ST(groupId, urlTitle, status, start, end, 7155 orderByComparator); 7156 } 7157 7158 /** 7159 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7160 * 7161 * @param groupId the group ID 7162 * @param urlTitle the url title 7163 * @param status the status 7164 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7165 * @return the first matching journal article 7166 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7167 * @throws SystemException if a system exception occurred 7168 */ 7169 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First( 7170 long groupId, java.lang.String urlTitle, int status, 7171 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7172 throws com.liferay.portal.kernel.exception.SystemException, 7173 com.liferay.portlet.journal.NoSuchArticleException { 7174 return getPersistence() 7175 .findByG_UT_ST_First(groupId, urlTitle, status, 7176 orderByComparator); 7177 } 7178 7179 /** 7180 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7181 * 7182 * @param groupId the group ID 7183 * @param urlTitle the url title 7184 * @param status the status 7185 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7186 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7187 * @throws SystemException if a system exception occurred 7188 */ 7189 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First( 7190 long groupId, java.lang.String urlTitle, int status, 7191 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7192 throws com.liferay.portal.kernel.exception.SystemException { 7193 return getPersistence() 7194 .fetchByG_UT_ST_First(groupId, urlTitle, status, 7195 orderByComparator); 7196 } 7197 7198 /** 7199 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7200 * 7201 * @param groupId the group ID 7202 * @param urlTitle the url title 7203 * @param status the status 7204 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7205 * @return the last matching journal article 7206 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7207 * @throws SystemException if a system exception occurred 7208 */ 7209 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last( 7210 long groupId, java.lang.String urlTitle, int status, 7211 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7212 throws com.liferay.portal.kernel.exception.SystemException, 7213 com.liferay.portlet.journal.NoSuchArticleException { 7214 return getPersistence() 7215 .findByG_UT_ST_Last(groupId, urlTitle, status, 7216 orderByComparator); 7217 } 7218 7219 /** 7220 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7221 * 7222 * @param groupId the group ID 7223 * @param urlTitle the url title 7224 * @param status the status 7225 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7226 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7227 * @throws SystemException if a system exception occurred 7228 */ 7229 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last( 7230 long groupId, java.lang.String urlTitle, int status, 7231 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7232 throws com.liferay.portal.kernel.exception.SystemException { 7233 return getPersistence() 7234 .fetchByG_UT_ST_Last(groupId, urlTitle, status, 7235 orderByComparator); 7236 } 7237 7238 /** 7239 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 7240 * 7241 * @param id the primary key of the current journal article 7242 * @param groupId the group ID 7243 * @param urlTitle the url title 7244 * @param status the status 7245 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7246 * @return the previous, current, and next journal article 7247 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7248 * @throws SystemException if a system exception occurred 7249 */ 7250 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext( 7251 long id, long groupId, java.lang.String urlTitle, int status, 7252 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7253 throws com.liferay.portal.kernel.exception.SystemException, 7254 com.liferay.portlet.journal.NoSuchArticleException { 7255 return getPersistence() 7256 .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status, 7257 orderByComparator); 7258 } 7259 7260 /** 7261 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7262 * 7263 * @param groupId the group ID 7264 * @param urlTitle the url title 7265 * @param status the status 7266 * @return the matching journal articles that the user has permission to view 7267 * @throws SystemException if a system exception occurred 7268 */ 7269 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7270 long groupId, java.lang.String urlTitle, int status) 7271 throws com.liferay.portal.kernel.exception.SystemException { 7272 return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status); 7273 } 7274 7275 /** 7276 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7277 * 7278 * <p> 7279 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7280 * </p> 7281 * 7282 * @param groupId the group ID 7283 * @param urlTitle the url title 7284 * @param status the status 7285 * @param start the lower bound of the range of journal articles 7286 * @param end the upper bound of the range of journal articles (not inclusive) 7287 * @return the range of matching journal articles that the user has permission to view 7288 * @throws SystemException if a system exception occurred 7289 */ 7290 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7291 long groupId, java.lang.String urlTitle, int status, int start, int end) 7292 throws com.liferay.portal.kernel.exception.SystemException { 7293 return getPersistence() 7294 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end); 7295 } 7296 7297 /** 7298 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ? and status = ?. 7299 * 7300 * <p> 7301 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7302 * </p> 7303 * 7304 * @param groupId the group ID 7305 * @param urlTitle the url title 7306 * @param status the status 7307 * @param start the lower bound of the range of journal articles 7308 * @param end the upper bound of the range of journal articles (not inclusive) 7309 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7310 * @return the ordered range of matching journal articles that the user has permission to view 7311 * @throws SystemException if a system exception occurred 7312 */ 7313 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 7314 long groupId, java.lang.String urlTitle, int status, int start, 7315 int end, 7316 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7317 throws com.liferay.portal.kernel.exception.SystemException { 7318 return getPersistence() 7319 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end, 7320 orderByComparator); 7321 } 7322 7323 /** 7324 * 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 = ?. 7325 * 7326 * @param id the primary key of the current journal article 7327 * @param groupId the group ID 7328 * @param urlTitle the url title 7329 * @param status the status 7330 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7331 * @return the previous, current, and next journal article 7332 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7333 * @throws SystemException if a system exception occurred 7334 */ 7335 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext( 7336 long id, long groupId, java.lang.String urlTitle, int status, 7337 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7338 throws com.liferay.portal.kernel.exception.SystemException, 7339 com.liferay.portlet.journal.NoSuchArticleException { 7340 return getPersistence() 7341 .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle, 7342 status, orderByComparator); 7343 } 7344 7345 /** 7346 * Removes all the journal articles where groupId = ? and urlTitle = ? and status = ? from the database. 7347 * 7348 * @param groupId the group ID 7349 * @param urlTitle the url title 7350 * @param status the status 7351 * @throws SystemException if a system exception occurred 7352 */ 7353 public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle, 7354 int status) throws com.liferay.portal.kernel.exception.SystemException { 7355 getPersistence().removeByG_UT_ST(groupId, urlTitle, status); 7356 } 7357 7358 /** 7359 * Returns the number of journal articles where groupId = ? and urlTitle = ? and status = ?. 7360 * 7361 * @param groupId the group ID 7362 * @param urlTitle the url title 7363 * @param status the status 7364 * @return the number of matching journal articles 7365 * @throws SystemException if a system exception occurred 7366 */ 7367 public static int countByG_UT_ST(long groupId, java.lang.String urlTitle, 7368 int status) throws com.liferay.portal.kernel.exception.SystemException { 7369 return getPersistence().countByG_UT_ST(groupId, urlTitle, status); 7370 } 7371 7372 /** 7373 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 7374 * 7375 * @param groupId the group ID 7376 * @param urlTitle the url title 7377 * @param status the status 7378 * @return the number of matching journal articles that the user has permission to view 7379 * @throws SystemException if a system exception occurred 7380 */ 7381 public static int filterCountByG_UT_ST(long groupId, 7382 java.lang.String urlTitle, int status) 7383 throws com.liferay.portal.kernel.exception.SystemException { 7384 return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status); 7385 } 7386 7387 /** 7388 * Returns all the journal articles where companyId = ? and version = ? and status = ?. 7389 * 7390 * @param companyId the company ID 7391 * @param version the version 7392 * @param status the status 7393 * @return the matching journal articles 7394 * @throws SystemException if a system exception occurred 7395 */ 7396 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7397 long companyId, double version, int status) 7398 throws com.liferay.portal.kernel.exception.SystemException { 7399 return getPersistence().findByC_V_ST(companyId, version, status); 7400 } 7401 7402 /** 7403 * Returns a range of all the journal articles where companyId = ? and version = ? and status = ?. 7404 * 7405 * <p> 7406 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7407 * </p> 7408 * 7409 * @param companyId the company ID 7410 * @param version the version 7411 * @param status the status 7412 * @param start the lower bound of the range of journal articles 7413 * @param end the upper bound of the range of journal articles (not inclusive) 7414 * @return the range of matching journal articles 7415 * @throws SystemException if a system exception occurred 7416 */ 7417 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7418 long companyId, double version, int status, int start, int end) 7419 throws com.liferay.portal.kernel.exception.SystemException { 7420 return getPersistence() 7421 .findByC_V_ST(companyId, version, status, start, end); 7422 } 7423 7424 /** 7425 * Returns an ordered range of all the journal articles where companyId = ? and version = ? and status = ?. 7426 * 7427 * <p> 7428 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7429 * </p> 7430 * 7431 * @param companyId the company ID 7432 * @param version the version 7433 * @param status the status 7434 * @param start the lower bound of the range of journal articles 7435 * @param end the upper bound of the range of journal articles (not inclusive) 7436 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7437 * @return the ordered range of matching journal articles 7438 * @throws SystemException if a system exception occurred 7439 */ 7440 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 7441 long companyId, double version, int status, int start, int end, 7442 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7443 throws com.liferay.portal.kernel.exception.SystemException { 7444 return getPersistence() 7445 .findByC_V_ST(companyId, version, status, start, end, 7446 orderByComparator); 7447 } 7448 7449 /** 7450 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 7451 * 7452 * @param companyId the company ID 7453 * @param version the version 7454 * @param status the status 7455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7456 * @return the first matching journal article 7457 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7458 * @throws SystemException if a system exception occurred 7459 */ 7460 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First( 7461 long companyId, double version, int status, 7462 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7463 throws com.liferay.portal.kernel.exception.SystemException, 7464 com.liferay.portlet.journal.NoSuchArticleException { 7465 return getPersistence() 7466 .findByC_V_ST_First(companyId, version, status, 7467 orderByComparator); 7468 } 7469 7470 /** 7471 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 7472 * 7473 * @param companyId the company ID 7474 * @param version the version 7475 * @param status the status 7476 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7477 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7478 * @throws SystemException if a system exception occurred 7479 */ 7480 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First( 7481 long companyId, double version, int status, 7482 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7483 throws com.liferay.portal.kernel.exception.SystemException { 7484 return getPersistence() 7485 .fetchByC_V_ST_First(companyId, version, status, 7486 orderByComparator); 7487 } 7488 7489 /** 7490 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 7491 * 7492 * @param companyId the company ID 7493 * @param version the version 7494 * @param status the status 7495 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7496 * @return the last matching journal article 7497 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7498 * @throws SystemException if a system exception occurred 7499 */ 7500 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last( 7501 long companyId, double version, int status, 7502 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7503 throws com.liferay.portal.kernel.exception.SystemException, 7504 com.liferay.portlet.journal.NoSuchArticleException { 7505 return getPersistence() 7506 .findByC_V_ST_Last(companyId, version, status, 7507 orderByComparator); 7508 } 7509 7510 /** 7511 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 7512 * 7513 * @param companyId the company ID 7514 * @param version the version 7515 * @param status the status 7516 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7517 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7518 * @throws SystemException if a system exception occurred 7519 */ 7520 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last( 7521 long companyId, double version, int status, 7522 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7523 throws com.liferay.portal.kernel.exception.SystemException { 7524 return getPersistence() 7525 .fetchByC_V_ST_Last(companyId, version, status, 7526 orderByComparator); 7527 } 7528 7529 /** 7530 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ? and status = ?. 7531 * 7532 * @param id the primary key of the current journal article 7533 * @param companyId the company ID 7534 * @param version the version 7535 * @param status the status 7536 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7537 * @return the previous, current, and next journal article 7538 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7539 * @throws SystemException if a system exception occurred 7540 */ 7541 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext( 7542 long id, long companyId, double version, int status, 7543 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7544 throws com.liferay.portal.kernel.exception.SystemException, 7545 com.liferay.portlet.journal.NoSuchArticleException { 7546 return getPersistence() 7547 .findByC_V_ST_PrevAndNext(id, companyId, version, status, 7548 orderByComparator); 7549 } 7550 7551 /** 7552 * Removes all the journal articles where companyId = ? and version = ? and status = ? from the database. 7553 * 7554 * @param companyId the company ID 7555 * @param version the version 7556 * @param status the status 7557 * @throws SystemException if a system exception occurred 7558 */ 7559 public static void removeByC_V_ST(long companyId, double version, int status) 7560 throws com.liferay.portal.kernel.exception.SystemException { 7561 getPersistence().removeByC_V_ST(companyId, version, status); 7562 } 7563 7564 /** 7565 * Returns the number of journal articles where companyId = ? and version = ? and status = ?. 7566 * 7567 * @param companyId the company ID 7568 * @param version the version 7569 * @param status the status 7570 * @return the number of matching journal articles 7571 * @throws SystemException if a system exception occurred 7572 */ 7573 public static int countByC_V_ST(long companyId, double version, int status) 7574 throws com.liferay.portal.kernel.exception.SystemException { 7575 return getPersistence().countByC_V_ST(companyId, version, status); 7576 } 7577 7578 /** 7579 * Caches the journal article in the entity cache if it is enabled. 7580 * 7581 * @param journalArticle the journal article 7582 */ 7583 public static void cacheResult( 7584 com.liferay.portlet.journal.model.JournalArticle journalArticle) { 7585 getPersistence().cacheResult(journalArticle); 7586 } 7587 7588 /** 7589 * Caches the journal articles in the entity cache if it is enabled. 7590 * 7591 * @param journalArticles the journal articles 7592 */ 7593 public static void cacheResult( 7594 java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) { 7595 getPersistence().cacheResult(journalArticles); 7596 } 7597 7598 /** 7599 * Creates a new journal article with the primary key. Does not add the journal article to the database. 7600 * 7601 * @param id the primary key for the new journal article 7602 * @return the new journal article 7603 */ 7604 public static com.liferay.portlet.journal.model.JournalArticle create( 7605 long id) { 7606 return getPersistence().create(id); 7607 } 7608 7609 /** 7610 * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners. 7611 * 7612 * @param id the primary key of the journal article 7613 * @return the journal article that was removed 7614 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7615 * @throws SystemException if a system exception occurred 7616 */ 7617 public static com.liferay.portlet.journal.model.JournalArticle remove( 7618 long id) 7619 throws com.liferay.portal.kernel.exception.SystemException, 7620 com.liferay.portlet.journal.NoSuchArticleException { 7621 return getPersistence().remove(id); 7622 } 7623 7624 public static com.liferay.portlet.journal.model.JournalArticle updateImpl( 7625 com.liferay.portlet.journal.model.JournalArticle journalArticle) 7626 throws com.liferay.portal.kernel.exception.SystemException { 7627 return getPersistence().updateImpl(journalArticle); 7628 } 7629 7630 /** 7631 * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 7632 * 7633 * @param id the primary key of the journal article 7634 * @return the journal article 7635 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7636 * @throws SystemException if a system exception occurred 7637 */ 7638 public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey( 7639 long id) 7640 throws com.liferay.portal.kernel.exception.SystemException, 7641 com.liferay.portlet.journal.NoSuchArticleException { 7642 return getPersistence().findByPrimaryKey(id); 7643 } 7644 7645 /** 7646 * Returns the journal article with the primary key or returns <code>null</code> if it could not be found. 7647 * 7648 * @param id the primary key of the journal article 7649 * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found 7650 * @throws SystemException if a system exception occurred 7651 */ 7652 public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey( 7653 long id) throws com.liferay.portal.kernel.exception.SystemException { 7654 return getPersistence().fetchByPrimaryKey(id); 7655 } 7656 7657 /** 7658 * Returns all the journal articles. 7659 * 7660 * @return the journal articles 7661 * @throws SystemException if a system exception occurred 7662 */ 7663 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll() 7664 throws com.liferay.portal.kernel.exception.SystemException { 7665 return getPersistence().findAll(); 7666 } 7667 7668 /** 7669 * Returns a range of all the journal articles. 7670 * 7671 * <p> 7672 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7673 * </p> 7674 * 7675 * @param start the lower bound of the range of journal articles 7676 * @param end the upper bound of the range of journal articles (not inclusive) 7677 * @return the range of journal articles 7678 * @throws SystemException if a system exception occurred 7679 */ 7680 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 7681 int start, int end) 7682 throws com.liferay.portal.kernel.exception.SystemException { 7683 return getPersistence().findAll(start, end); 7684 } 7685 7686 /** 7687 * Returns an ordered range of all the journal articles. 7688 * 7689 * <p> 7690 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7691 * </p> 7692 * 7693 * @param start the lower bound of the range of journal articles 7694 * @param end the upper bound of the range of journal articles (not inclusive) 7695 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7696 * @return the ordered range of journal articles 7697 * @throws SystemException if a system exception occurred 7698 */ 7699 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 7700 int start, int end, 7701 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7702 throws com.liferay.portal.kernel.exception.SystemException { 7703 return getPersistence().findAll(start, end, orderByComparator); 7704 } 7705 7706 /** 7707 * Removes all the journal articles from the database. 7708 * 7709 * @throws SystemException if a system exception occurred 7710 */ 7711 public static void removeAll() 7712 throws com.liferay.portal.kernel.exception.SystemException { 7713 getPersistence().removeAll(); 7714 } 7715 7716 /** 7717 * Returns the number of journal articles. 7718 * 7719 * @return the number of journal articles 7720 * @throws SystemException if a system exception occurred 7721 */ 7722 public static int countAll() 7723 throws com.liferay.portal.kernel.exception.SystemException { 7724 return getPersistence().countAll(); 7725 } 7726 7727 public static JournalArticlePersistence getPersistence() { 7728 if (_persistence == null) { 7729 _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName()); 7730 7731 ReferenceRegistry.registerReference(JournalArticleUtil.class, 7732 "_persistence"); 7733 } 7734 7735 return _persistence; 7736 } 7737 7738 /** 7739 * @deprecated 7740 */ 7741 public void setPersistence(JournalArticlePersistence persistence) { 7742 } 7743 7744 private static JournalArticlePersistence _persistence; 7745 }