001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * The contents of this file are subject to the terms of the Liferay Enterprise 005 * Subscription License ("License"). You may not use this file except in 006 * compliance with the License. You can obtain a copy of the License by 007 * contacting Liferay, Inc. See the License for the specific language governing 008 * permissions and limitations under the License, including but not limited to 009 * distribution rights of the Software. 010 * 011 * 012 * 013 */ 014 015 package com.liferay.portlet.journal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.exception.SystemException; 022 import com.liferay.portal.kernel.util.OrderByComparator; 023 import com.liferay.portal.kernel.util.ReferenceRegistry; 024 import com.liferay.portal.service.ServiceContext; 025 026 import com.liferay.portlet.journal.model.JournalArticle; 027 028 import java.util.List; 029 030 /** 031 * The persistence utility for the journal article service. This utility wraps {@link JournalArticlePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 032 * 033 * <p> 034 * Caching information and settings can be found in <code>portal.properties</code> 035 * </p> 036 * 037 * @author Brian Wing Shun Chan 038 * @see JournalArticlePersistence 039 * @see JournalArticlePersistenceImpl 040 * @generated 041 */ 042 @ProviderType 043 public class JournalArticleUtil { 044 /* 045 * NOTE FOR DEVELOPERS: 046 * 047 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 048 */ 049 050 /** 051 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 052 */ 053 public static void clearCache() { 054 getPersistence().clearCache(); 055 } 056 057 /** 058 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 059 */ 060 public static void clearCache(JournalArticle journalArticle) { 061 getPersistence().clearCache(journalArticle); 062 } 063 064 /** 065 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 066 */ 067 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) 068 throws SystemException { 069 return getPersistence().countWithDynamicQuery(dynamicQuery); 070 } 071 072 /** 073 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 074 */ 075 public static List<JournalArticle> findWithDynamicQuery( 076 DynamicQuery dynamicQuery) throws SystemException { 077 return getPersistence().findWithDynamicQuery(dynamicQuery); 078 } 079 080 /** 081 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 082 */ 083 public static List<JournalArticle> findWithDynamicQuery( 084 DynamicQuery dynamicQuery, int start, int end) 085 throws SystemException { 086 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 087 } 088 089 /** 090 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 091 */ 092 public static List<JournalArticle> findWithDynamicQuery( 093 DynamicQuery dynamicQuery, int start, int end, 094 OrderByComparator orderByComparator) throws SystemException { 095 return getPersistence() 096 .findWithDynamicQuery(dynamicQuery, start, end, 097 orderByComparator); 098 } 099 100 /** 101 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 102 */ 103 public static JournalArticle update(JournalArticle journalArticle) 104 throws SystemException { 105 return getPersistence().update(journalArticle); 106 } 107 108 /** 109 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 110 */ 111 public static JournalArticle update(JournalArticle journalArticle, 112 ServiceContext serviceContext) throws SystemException { 113 return getPersistence().update(journalArticle, serviceContext); 114 } 115 116 /** 117 * Returns all the journal articles where uuid = ?. 118 * 119 * @param uuid the uuid 120 * @return the matching journal articles 121 * @throws SystemException if a system exception occurred 122 */ 123 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 124 java.lang.String uuid) 125 throws com.liferay.portal.kernel.exception.SystemException { 126 return getPersistence().findByUuid(uuid); 127 } 128 129 /** 130 * Returns a range of all the journal articles where uuid = ?. 131 * 132 * <p> 133 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 134 * </p> 135 * 136 * @param uuid the uuid 137 * @param start the lower bound of the range of journal articles 138 * @param end the upper bound of the range of journal articles (not inclusive) 139 * @return the range of matching journal articles 140 * @throws SystemException if a system exception occurred 141 */ 142 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 143 java.lang.String uuid, int start, int end) 144 throws com.liferay.portal.kernel.exception.SystemException { 145 return getPersistence().findByUuid(uuid, start, end); 146 } 147 148 /** 149 * Returns an ordered range of all the journal articles where uuid = ?. 150 * 151 * <p> 152 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 153 * </p> 154 * 155 * @param uuid the uuid 156 * @param start the lower bound of the range of journal articles 157 * @param end the upper bound of the range of journal articles (not inclusive) 158 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 159 * @return the ordered range of matching journal articles 160 * @throws SystemException if a system exception occurred 161 */ 162 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid( 163 java.lang.String uuid, int start, int end, 164 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 165 throws com.liferay.portal.kernel.exception.SystemException { 166 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 167 } 168 169 /** 170 * Returns the first journal article in the ordered set where uuid = ?. 171 * 172 * @param uuid the uuid 173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 174 * @return the first matching journal article 175 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 176 * @throws SystemException if a system exception occurred 177 */ 178 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_First( 179 java.lang.String uuid, 180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 181 throws com.liferay.portal.kernel.exception.SystemException, 182 com.liferay.portlet.journal.NoSuchArticleException { 183 return getPersistence().findByUuid_First(uuid, orderByComparator); 184 } 185 186 /** 187 * Returns the first journal article in the ordered set where uuid = ?. 188 * 189 * @param uuid the uuid 190 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 191 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 192 * @throws SystemException if a system exception occurred 193 */ 194 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_First( 195 java.lang.String uuid, 196 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 197 throws com.liferay.portal.kernel.exception.SystemException { 198 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 199 } 200 201 /** 202 * Returns the last journal article in the ordered set where uuid = ?. 203 * 204 * @param uuid the uuid 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the last matching journal article 207 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 208 * @throws SystemException if a system exception occurred 209 */ 210 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_Last( 211 java.lang.String uuid, 212 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 213 throws com.liferay.portal.kernel.exception.SystemException, 214 com.liferay.portlet.journal.NoSuchArticleException { 215 return getPersistence().findByUuid_Last(uuid, orderByComparator); 216 } 217 218 /** 219 * Returns the last journal article in the ordered set where uuid = ?. 220 * 221 * @param uuid the uuid 222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 223 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 224 * @throws SystemException if a system exception occurred 225 */ 226 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_Last( 227 java.lang.String uuid, 228 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 229 throws com.liferay.portal.kernel.exception.SystemException { 230 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 231 } 232 233 /** 234 * Returns the journal articles before and after the current journal article in the ordered set where uuid = ?. 235 * 236 * @param id the primary key of the current journal article 237 * @param uuid the uuid 238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 239 * @return the previous, current, and next journal article 240 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 241 * @throws SystemException if a system exception occurred 242 */ 243 public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_PrevAndNext( 244 long id, java.lang.String uuid, 245 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 246 throws com.liferay.portal.kernel.exception.SystemException, 247 com.liferay.portlet.journal.NoSuchArticleException { 248 return getPersistence() 249 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 250 } 251 252 /** 253 * Removes all the journal articles where uuid = ? from the database. 254 * 255 * @param uuid the uuid 256 * @throws SystemException if a system exception occurred 257 */ 258 public static void removeByUuid(java.lang.String uuid) 259 throws com.liferay.portal.kernel.exception.SystemException { 260 getPersistence().removeByUuid(uuid); 261 } 262 263 /** 264 * Returns the number of journal articles where uuid = ?. 265 * 266 * @param uuid the uuid 267 * @return the number of matching journal articles 268 * @throws SystemException if a system exception occurred 269 */ 270 public static int countByUuid(java.lang.String uuid) 271 throws com.liferay.portal.kernel.exception.SystemException { 272 return getPersistence().countByUuid(uuid); 273 } 274 275 /** 276 * Returns the journal article where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 277 * 278 * @param uuid the uuid 279 * @param groupId the group ID 280 * @return the matching journal article 281 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 282 * @throws SystemException if a system exception occurred 283 */ 284 public static com.liferay.portlet.journal.model.JournalArticle findByUUID_G( 285 java.lang.String uuid, long groupId) 286 throws com.liferay.portal.kernel.exception.SystemException, 287 com.liferay.portlet.journal.NoSuchArticleException { 288 return getPersistence().findByUUID_G(uuid, groupId); 289 } 290 291 /** 292 * Returns the journal article where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 293 * 294 * @param uuid the uuid 295 * @param groupId the group ID 296 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 297 * @throws SystemException if a system exception occurred 298 */ 299 public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G( 300 java.lang.String uuid, long groupId) 301 throws com.liferay.portal.kernel.exception.SystemException { 302 return getPersistence().fetchByUUID_G(uuid, groupId); 303 } 304 305 /** 306 * Returns the journal article where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 307 * 308 * @param uuid the uuid 309 * @param groupId the group ID 310 * @param retrieveFromCache whether to use the finder cache 311 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 312 * @throws SystemException if a system exception occurred 313 */ 314 public static com.liferay.portlet.journal.model.JournalArticle fetchByUUID_G( 315 java.lang.String uuid, long groupId, boolean retrieveFromCache) 316 throws com.liferay.portal.kernel.exception.SystemException { 317 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 318 } 319 320 /** 321 * Removes the journal article where uuid = ? and groupId = ? from the database. 322 * 323 * @param uuid the uuid 324 * @param groupId the group ID 325 * @return the journal article that was removed 326 * @throws SystemException if a system exception occurred 327 */ 328 public static com.liferay.portlet.journal.model.JournalArticle removeByUUID_G( 329 java.lang.String uuid, long groupId) 330 throws com.liferay.portal.kernel.exception.SystemException, 331 com.liferay.portlet.journal.NoSuchArticleException { 332 return getPersistence().removeByUUID_G(uuid, groupId); 333 } 334 335 /** 336 * Returns the number of journal articles where uuid = ? and groupId = ?. 337 * 338 * @param uuid the uuid 339 * @param groupId the group ID 340 * @return the number of matching journal articles 341 * @throws SystemException if a system exception occurred 342 */ 343 public static int countByUUID_G(java.lang.String uuid, long groupId) 344 throws com.liferay.portal.kernel.exception.SystemException { 345 return getPersistence().countByUUID_G(uuid, groupId); 346 } 347 348 /** 349 * Returns all the journal articles where uuid = ? and companyId = ?. 350 * 351 * @param uuid the uuid 352 * @param companyId the company ID 353 * @return the matching journal articles 354 * @throws SystemException if a system exception occurred 355 */ 356 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 357 java.lang.String uuid, long companyId) 358 throws com.liferay.portal.kernel.exception.SystemException { 359 return getPersistence().findByUuid_C(uuid, companyId); 360 } 361 362 /** 363 * Returns a range of all the journal articles where uuid = ? and companyId = ?. 364 * 365 * <p> 366 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 367 * </p> 368 * 369 * @param uuid the uuid 370 * @param companyId the company ID 371 * @param start the lower bound of the range of journal articles 372 * @param end the upper bound of the range of journal articles (not inclusive) 373 * @return the range of matching journal articles 374 * @throws SystemException if a system exception occurred 375 */ 376 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 377 java.lang.String uuid, long companyId, int start, int end) 378 throws com.liferay.portal.kernel.exception.SystemException { 379 return getPersistence().findByUuid_C(uuid, companyId, start, end); 380 } 381 382 /** 383 * Returns an ordered range of all the journal articles where uuid = ? and companyId = ?. 384 * 385 * <p> 386 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 387 * </p> 388 * 389 * @param uuid the uuid 390 * @param companyId the company ID 391 * @param start the lower bound of the range of journal articles 392 * @param end the upper bound of the range of journal articles (not inclusive) 393 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 394 * @return the ordered range of matching journal articles 395 * @throws SystemException if a system exception occurred 396 */ 397 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByUuid_C( 398 java.lang.String uuid, long companyId, int start, int end, 399 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 400 throws com.liferay.portal.kernel.exception.SystemException { 401 return getPersistence() 402 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 403 } 404 405 /** 406 * Returns the first journal article in the ordered set where uuid = ? and companyId = ?. 407 * 408 * @param uuid the uuid 409 * @param companyId the company ID 410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 411 * @return the first matching journal article 412 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 413 * @throws SystemException if a system exception occurred 414 */ 415 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_First( 416 java.lang.String uuid, long companyId, 417 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 418 throws com.liferay.portal.kernel.exception.SystemException, 419 com.liferay.portlet.journal.NoSuchArticleException { 420 return getPersistence() 421 .findByUuid_C_First(uuid, companyId, orderByComparator); 422 } 423 424 /** 425 * Returns the first journal article in the ordered set where uuid = ? and companyId = ?. 426 * 427 * @param uuid the uuid 428 * @param companyId the company ID 429 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 430 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 431 * @throws SystemException if a system exception occurred 432 */ 433 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_First( 434 java.lang.String uuid, long companyId, 435 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 436 throws com.liferay.portal.kernel.exception.SystemException { 437 return getPersistence() 438 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 439 } 440 441 /** 442 * Returns the last journal article in the ordered set where uuid = ? and companyId = ?. 443 * 444 * @param uuid the uuid 445 * @param companyId the company ID 446 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 447 * @return the last matching journal article 448 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 449 * @throws SystemException if a system exception occurred 450 */ 451 public static com.liferay.portlet.journal.model.JournalArticle findByUuid_C_Last( 452 java.lang.String uuid, long companyId, 453 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 454 throws com.liferay.portal.kernel.exception.SystemException, 455 com.liferay.portlet.journal.NoSuchArticleException { 456 return getPersistence() 457 .findByUuid_C_Last(uuid, companyId, orderByComparator); 458 } 459 460 /** 461 * Returns the last journal article in the ordered set where uuid = ? and companyId = ?. 462 * 463 * @param uuid the uuid 464 * @param companyId the company ID 465 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 466 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 467 * @throws SystemException if a system exception occurred 468 */ 469 public static com.liferay.portlet.journal.model.JournalArticle fetchByUuid_C_Last( 470 java.lang.String uuid, long companyId, 471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 472 throws com.liferay.portal.kernel.exception.SystemException { 473 return getPersistence() 474 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 475 } 476 477 /** 478 * Returns the journal articles before and after the current journal article in the ordered set where uuid = ? and companyId = ?. 479 * 480 * @param id the primary key of the current journal article 481 * @param uuid the uuid 482 * @param companyId the company ID 483 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 484 * @return the previous, current, and next journal article 485 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 486 * @throws SystemException if a system exception occurred 487 */ 488 public static com.liferay.portlet.journal.model.JournalArticle[] findByUuid_C_PrevAndNext( 489 long id, java.lang.String uuid, long companyId, 490 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 491 throws com.liferay.portal.kernel.exception.SystemException, 492 com.liferay.portlet.journal.NoSuchArticleException { 493 return getPersistence() 494 .findByUuid_C_PrevAndNext(id, uuid, companyId, 495 orderByComparator); 496 } 497 498 /** 499 * Removes all the journal articles where uuid = ? and companyId = ? from the database. 500 * 501 * @param uuid the uuid 502 * @param companyId the company ID 503 * @throws SystemException if a system exception occurred 504 */ 505 public static void removeByUuid_C(java.lang.String uuid, long companyId) 506 throws com.liferay.portal.kernel.exception.SystemException { 507 getPersistence().removeByUuid_C(uuid, companyId); 508 } 509 510 /** 511 * Returns the number of journal articles where uuid = ? and companyId = ?. 512 * 513 * @param uuid the uuid 514 * @param companyId the company ID 515 * @return the number of matching journal articles 516 * @throws SystemException if a system exception occurred 517 */ 518 public static int countByUuid_C(java.lang.String uuid, long companyId) 519 throws com.liferay.portal.kernel.exception.SystemException { 520 return getPersistence().countByUuid_C(uuid, companyId); 521 } 522 523 /** 524 * Returns all the journal articles where resourcePrimKey = ?. 525 * 526 * @param resourcePrimKey the resource prim key 527 * @return the matching journal articles 528 * @throws SystemException if a system exception occurred 529 */ 530 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 531 long resourcePrimKey) 532 throws com.liferay.portal.kernel.exception.SystemException { 533 return getPersistence().findByResourcePrimKey(resourcePrimKey); 534 } 535 536 /** 537 * Returns a range of all the journal articles where resourcePrimKey = ?. 538 * 539 * <p> 540 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 541 * </p> 542 * 543 * @param resourcePrimKey the resource prim key 544 * @param start the lower bound of the range of journal articles 545 * @param end the upper bound of the range of journal articles (not inclusive) 546 * @return the range of matching journal articles 547 * @throws SystemException if a system exception occurred 548 */ 549 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 550 long resourcePrimKey, int start, int end) 551 throws com.liferay.portal.kernel.exception.SystemException { 552 return getPersistence() 553 .findByResourcePrimKey(resourcePrimKey, start, end); 554 } 555 556 /** 557 * Returns an ordered range of all the journal articles where resourcePrimKey = ?. 558 * 559 * <p> 560 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 561 * </p> 562 * 563 * @param resourcePrimKey the resource prim key 564 * @param start the lower bound of the range of journal articles 565 * @param end the upper bound of the range of journal articles (not inclusive) 566 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 567 * @return the ordered range of matching journal articles 568 * @throws SystemException if a system exception occurred 569 */ 570 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByResourcePrimKey( 571 long resourcePrimKey, int start, int end, 572 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 573 throws com.liferay.portal.kernel.exception.SystemException { 574 return getPersistence() 575 .findByResourcePrimKey(resourcePrimKey, start, end, 576 orderByComparator); 577 } 578 579 /** 580 * Returns the first journal article in the ordered set where resourcePrimKey = ?. 581 * 582 * @param resourcePrimKey the resource prim key 583 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 584 * @return the first matching journal article 585 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 586 * @throws SystemException if a system exception occurred 587 */ 588 public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_First( 589 long resourcePrimKey, 590 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 591 throws com.liferay.portal.kernel.exception.SystemException, 592 com.liferay.portlet.journal.NoSuchArticleException { 593 return getPersistence() 594 .findByResourcePrimKey_First(resourcePrimKey, 595 orderByComparator); 596 } 597 598 /** 599 * Returns the first journal article in the ordered set where resourcePrimKey = ?. 600 * 601 * @param resourcePrimKey the resource prim key 602 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 603 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 604 * @throws SystemException if a system exception occurred 605 */ 606 public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_First( 607 long resourcePrimKey, 608 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 609 throws com.liferay.portal.kernel.exception.SystemException { 610 return getPersistence() 611 .fetchByResourcePrimKey_First(resourcePrimKey, 612 orderByComparator); 613 } 614 615 /** 616 * Returns the last journal article in the ordered set where resourcePrimKey = ?. 617 * 618 * @param resourcePrimKey the resource prim key 619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 620 * @return the last matching journal article 621 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 622 * @throws SystemException if a system exception occurred 623 */ 624 public static com.liferay.portlet.journal.model.JournalArticle findByResourcePrimKey_Last( 625 long resourcePrimKey, 626 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 627 throws com.liferay.portal.kernel.exception.SystemException, 628 com.liferay.portlet.journal.NoSuchArticleException { 629 return getPersistence() 630 .findByResourcePrimKey_Last(resourcePrimKey, 631 orderByComparator); 632 } 633 634 /** 635 * Returns the last journal article in the ordered set where resourcePrimKey = ?. 636 * 637 * @param resourcePrimKey the resource prim key 638 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 639 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 640 * @throws SystemException if a system exception occurred 641 */ 642 public static com.liferay.portlet.journal.model.JournalArticle fetchByResourcePrimKey_Last( 643 long resourcePrimKey, 644 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 645 throws com.liferay.portal.kernel.exception.SystemException { 646 return getPersistence() 647 .fetchByResourcePrimKey_Last(resourcePrimKey, 648 orderByComparator); 649 } 650 651 /** 652 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ?. 653 * 654 * @param id the primary key of the current journal article 655 * @param resourcePrimKey the resource prim key 656 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 657 * @return the previous, current, and next journal article 658 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 659 * @throws SystemException if a system exception occurred 660 */ 661 public static com.liferay.portlet.journal.model.JournalArticle[] findByResourcePrimKey_PrevAndNext( 662 long id, long resourcePrimKey, 663 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 664 throws com.liferay.portal.kernel.exception.SystemException, 665 com.liferay.portlet.journal.NoSuchArticleException { 666 return getPersistence() 667 .findByResourcePrimKey_PrevAndNext(id, resourcePrimKey, 668 orderByComparator); 669 } 670 671 /** 672 * Removes all the journal articles where resourcePrimKey = ? from the database. 673 * 674 * @param resourcePrimKey the resource prim key 675 * @throws SystemException if a system exception occurred 676 */ 677 public static void removeByResourcePrimKey(long resourcePrimKey) 678 throws com.liferay.portal.kernel.exception.SystemException { 679 getPersistence().removeByResourcePrimKey(resourcePrimKey); 680 } 681 682 /** 683 * Returns the number of journal articles where resourcePrimKey = ?. 684 * 685 * @param resourcePrimKey the resource prim key 686 * @return the number of matching journal articles 687 * @throws SystemException if a system exception occurred 688 */ 689 public static int countByResourcePrimKey(long resourcePrimKey) 690 throws com.liferay.portal.kernel.exception.SystemException { 691 return getPersistence().countByResourcePrimKey(resourcePrimKey); 692 } 693 694 /** 695 * Returns all the journal articles where groupId = ?. 696 * 697 * @param groupId the group ID 698 * @return the matching journal articles 699 * @throws SystemException if a system exception occurred 700 */ 701 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 702 long groupId) 703 throws com.liferay.portal.kernel.exception.SystemException { 704 return getPersistence().findByGroupId(groupId); 705 } 706 707 /** 708 * Returns a range of all the journal articles where groupId = ?. 709 * 710 * <p> 711 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 712 * </p> 713 * 714 * @param groupId the group ID 715 * @param start the lower bound of the range of journal articles 716 * @param end the upper bound of the range of journal articles (not inclusive) 717 * @return the range of matching journal articles 718 * @throws SystemException if a system exception occurred 719 */ 720 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 721 long groupId, int start, int end) 722 throws com.liferay.portal.kernel.exception.SystemException { 723 return getPersistence().findByGroupId(groupId, start, end); 724 } 725 726 /** 727 * Returns an ordered range of all the journal articles where groupId = ?. 728 * 729 * <p> 730 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 731 * </p> 732 * 733 * @param groupId the group ID 734 * @param start the lower bound of the range of journal articles 735 * @param end the upper bound of the range of journal articles (not inclusive) 736 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 737 * @return the ordered range of matching journal articles 738 * @throws SystemException if a system exception occurred 739 */ 740 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByGroupId( 741 long groupId, int start, int end, 742 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 743 throws com.liferay.portal.kernel.exception.SystemException { 744 return getPersistence() 745 .findByGroupId(groupId, start, end, orderByComparator); 746 } 747 748 /** 749 * Returns the first journal article in the ordered set where groupId = ?. 750 * 751 * @param groupId the group ID 752 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 753 * @return the first matching journal article 754 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 755 * @throws SystemException if a system exception occurred 756 */ 757 public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_First( 758 long groupId, 759 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 760 throws com.liferay.portal.kernel.exception.SystemException, 761 com.liferay.portlet.journal.NoSuchArticleException { 762 return getPersistence().findByGroupId_First(groupId, orderByComparator); 763 } 764 765 /** 766 * Returns the first journal article in the ordered set where groupId = ?. 767 * 768 * @param groupId the group ID 769 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 770 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 771 * @throws SystemException if a system exception occurred 772 */ 773 public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_First( 774 long groupId, 775 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 776 throws com.liferay.portal.kernel.exception.SystemException { 777 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 778 } 779 780 /** 781 * Returns the last journal article in the ordered set where groupId = ?. 782 * 783 * @param groupId the group ID 784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 785 * @return the last matching journal article 786 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 787 * @throws SystemException if a system exception occurred 788 */ 789 public static com.liferay.portlet.journal.model.JournalArticle findByGroupId_Last( 790 long groupId, 791 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 792 throws com.liferay.portal.kernel.exception.SystemException, 793 com.liferay.portlet.journal.NoSuchArticleException { 794 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 795 } 796 797 /** 798 * Returns the last journal article in the ordered set where groupId = ?. 799 * 800 * @param groupId the group ID 801 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 802 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 803 * @throws SystemException if a system exception occurred 804 */ 805 public static com.liferay.portlet.journal.model.JournalArticle fetchByGroupId_Last( 806 long groupId, 807 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 808 throws com.liferay.portal.kernel.exception.SystemException { 809 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 810 } 811 812 /** 813 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ?. 814 * 815 * @param id the primary key of the current journal article 816 * @param groupId the group ID 817 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 818 * @return the previous, current, and next journal article 819 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 820 * @throws SystemException if a system exception occurred 821 */ 822 public static com.liferay.portlet.journal.model.JournalArticle[] findByGroupId_PrevAndNext( 823 long id, long groupId, 824 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 825 throws com.liferay.portal.kernel.exception.SystemException, 826 com.liferay.portlet.journal.NoSuchArticleException { 827 return getPersistence() 828 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 829 } 830 831 /** 832 * Returns all the journal articles that the user has permission to view where groupId = ?. 833 * 834 * @param groupId the group ID 835 * @return the matching journal articles that the user has permission to view 836 * @throws SystemException if a system exception occurred 837 */ 838 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 839 long groupId) 840 throws com.liferay.portal.kernel.exception.SystemException { 841 return getPersistence().filterFindByGroupId(groupId); 842 } 843 844 /** 845 * Returns a range of all the journal articles that the user has permission to view where groupId = ?. 846 * 847 * <p> 848 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 849 * </p> 850 * 851 * @param groupId the group ID 852 * @param start the lower bound of the range of journal articles 853 * @param end the upper bound of the range of journal articles (not inclusive) 854 * @return the range of matching journal articles that the user has permission to view 855 * @throws SystemException if a system exception occurred 856 */ 857 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 858 long groupId, int start, int end) 859 throws com.liferay.portal.kernel.exception.SystemException { 860 return getPersistence().filterFindByGroupId(groupId, start, end); 861 } 862 863 /** 864 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ?. 865 * 866 * <p> 867 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 868 * </p> 869 * 870 * @param groupId the group ID 871 * @param start the lower bound of the range of journal articles 872 * @param end the upper bound of the range of journal articles (not inclusive) 873 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 874 * @return the ordered range of matching journal articles that the user has permission to view 875 * @throws SystemException if a system exception occurred 876 */ 877 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByGroupId( 878 long groupId, int start, int end, 879 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 880 throws com.liferay.portal.kernel.exception.SystemException { 881 return getPersistence() 882 .filterFindByGroupId(groupId, start, end, orderByComparator); 883 } 884 885 /** 886 * Returns the journal articles before and after the current journal article in the ordered set of journal articles that the user has permission to view where groupId = ?. 887 * 888 * @param id the primary key of the current journal article 889 * @param groupId the group ID 890 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 891 * @return the previous, current, and next journal article 892 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 893 * @throws SystemException if a system exception occurred 894 */ 895 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByGroupId_PrevAndNext( 896 long id, long groupId, 897 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 898 throws com.liferay.portal.kernel.exception.SystemException, 899 com.liferay.portlet.journal.NoSuchArticleException { 900 return getPersistence() 901 .filterFindByGroupId_PrevAndNext(id, groupId, 902 orderByComparator); 903 } 904 905 /** 906 * Removes all the journal articles where groupId = ? from the database. 907 * 908 * @param groupId the group ID 909 * @throws SystemException if a system exception occurred 910 */ 911 public static void removeByGroupId(long groupId) 912 throws com.liferay.portal.kernel.exception.SystemException { 913 getPersistence().removeByGroupId(groupId); 914 } 915 916 /** 917 * Returns the number of journal articles where groupId = ?. 918 * 919 * @param groupId the group ID 920 * @return the number of matching journal articles 921 * @throws SystemException if a system exception occurred 922 */ 923 public static int countByGroupId(long groupId) 924 throws com.liferay.portal.kernel.exception.SystemException { 925 return getPersistence().countByGroupId(groupId); 926 } 927 928 /** 929 * Returns the number of journal articles that the user has permission to view where groupId = ?. 930 * 931 * @param groupId the group ID 932 * @return the number of matching journal articles that the user has permission to view 933 * @throws SystemException if a system exception occurred 934 */ 935 public static int filterCountByGroupId(long groupId) 936 throws com.liferay.portal.kernel.exception.SystemException { 937 return getPersistence().filterCountByGroupId(groupId); 938 } 939 940 /** 941 * Returns all the journal articles where companyId = ?. 942 * 943 * @param companyId the company ID 944 * @return the matching journal articles 945 * @throws SystemException if a system exception occurred 946 */ 947 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 948 long companyId) 949 throws com.liferay.portal.kernel.exception.SystemException { 950 return getPersistence().findByCompanyId(companyId); 951 } 952 953 /** 954 * Returns a range of all the journal articles where companyId = ?. 955 * 956 * <p> 957 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 958 * </p> 959 * 960 * @param companyId the company ID 961 * @param start the lower bound of the range of journal articles 962 * @param end the upper bound of the range of journal articles (not inclusive) 963 * @return the range of matching journal articles 964 * @throws SystemException if a system exception occurred 965 */ 966 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 967 long companyId, int start, int end) 968 throws com.liferay.portal.kernel.exception.SystemException { 969 return getPersistence().findByCompanyId(companyId, start, end); 970 } 971 972 /** 973 * Returns an ordered range of all the journal articles where companyId = ?. 974 * 975 * <p> 976 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 977 * </p> 978 * 979 * @param companyId the company ID 980 * @param start the lower bound of the range of journal articles 981 * @param end the upper bound of the range of journal articles (not inclusive) 982 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 983 * @return the ordered range of matching journal articles 984 * @throws SystemException if a system exception occurred 985 */ 986 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByCompanyId( 987 long companyId, int start, int end, 988 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 989 throws com.liferay.portal.kernel.exception.SystemException { 990 return getPersistence() 991 .findByCompanyId(companyId, start, end, orderByComparator); 992 } 993 994 /** 995 * Returns the first journal article in the ordered set where companyId = ?. 996 * 997 * @param companyId the company ID 998 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 999 * @return the first matching journal article 1000 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1001 * @throws SystemException if a system exception occurred 1002 */ 1003 public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_First( 1004 long companyId, 1005 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1006 throws com.liferay.portal.kernel.exception.SystemException, 1007 com.liferay.portlet.journal.NoSuchArticleException { 1008 return getPersistence() 1009 .findByCompanyId_First(companyId, orderByComparator); 1010 } 1011 1012 /** 1013 * Returns the first journal article in the ordered set where companyId = ?. 1014 * 1015 * @param companyId the company ID 1016 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1017 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1018 * @throws SystemException if a system exception occurred 1019 */ 1020 public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_First( 1021 long companyId, 1022 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1023 throws com.liferay.portal.kernel.exception.SystemException { 1024 return getPersistence() 1025 .fetchByCompanyId_First(companyId, orderByComparator); 1026 } 1027 1028 /** 1029 * Returns the last journal article in the ordered set where companyId = ?. 1030 * 1031 * @param companyId the company ID 1032 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1033 * @return the last matching journal article 1034 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1035 * @throws SystemException if a system exception occurred 1036 */ 1037 public static com.liferay.portlet.journal.model.JournalArticle findByCompanyId_Last( 1038 long companyId, 1039 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1040 throws com.liferay.portal.kernel.exception.SystemException, 1041 com.liferay.portlet.journal.NoSuchArticleException { 1042 return getPersistence() 1043 .findByCompanyId_Last(companyId, orderByComparator); 1044 } 1045 1046 /** 1047 * Returns the last journal article in the ordered set where companyId = ?. 1048 * 1049 * @param companyId the company ID 1050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1051 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1052 * @throws SystemException if a system exception occurred 1053 */ 1054 public static com.liferay.portlet.journal.model.JournalArticle fetchByCompanyId_Last( 1055 long companyId, 1056 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1057 throws com.liferay.portal.kernel.exception.SystemException { 1058 return getPersistence() 1059 .fetchByCompanyId_Last(companyId, orderByComparator); 1060 } 1061 1062 /** 1063 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ?. 1064 * 1065 * @param id the primary key of the current journal article 1066 * @param companyId the company ID 1067 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1068 * @return the previous, current, and next journal article 1069 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1070 * @throws SystemException if a system exception occurred 1071 */ 1072 public static com.liferay.portlet.journal.model.JournalArticle[] findByCompanyId_PrevAndNext( 1073 long id, long companyId, 1074 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1075 throws com.liferay.portal.kernel.exception.SystemException, 1076 com.liferay.portlet.journal.NoSuchArticleException { 1077 return getPersistence() 1078 .findByCompanyId_PrevAndNext(id, companyId, orderByComparator); 1079 } 1080 1081 /** 1082 * Removes all the journal articles where companyId = ? from the database. 1083 * 1084 * @param companyId the company ID 1085 * @throws SystemException if a system exception occurred 1086 */ 1087 public static void removeByCompanyId(long companyId) 1088 throws com.liferay.portal.kernel.exception.SystemException { 1089 getPersistence().removeByCompanyId(companyId); 1090 } 1091 1092 /** 1093 * Returns the number of journal articles where companyId = ?. 1094 * 1095 * @param companyId the company ID 1096 * @return the number of matching journal articles 1097 * @throws SystemException if a system exception occurred 1098 */ 1099 public static int countByCompanyId(long companyId) 1100 throws com.liferay.portal.kernel.exception.SystemException { 1101 return getPersistence().countByCompanyId(companyId); 1102 } 1103 1104 /** 1105 * Returns all the journal articles where structureId = ?. 1106 * 1107 * @param structureId the structure ID 1108 * @return the matching journal articles 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1112 java.lang.String structureId) 1113 throws com.liferay.portal.kernel.exception.SystemException { 1114 return getPersistence().findByStructureId(structureId); 1115 } 1116 1117 /** 1118 * Returns a range of all the journal articles where structureId = ?. 1119 * 1120 * <p> 1121 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1122 * </p> 1123 * 1124 * @param structureId the structure ID 1125 * @param start the lower bound of the range of journal articles 1126 * @param end the upper bound of the range of journal articles (not inclusive) 1127 * @return the range of matching journal articles 1128 * @throws SystemException if a system exception occurred 1129 */ 1130 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1131 java.lang.String structureId, int start, int end) 1132 throws com.liferay.portal.kernel.exception.SystemException { 1133 return getPersistence().findByStructureId(structureId, start, end); 1134 } 1135 1136 /** 1137 * Returns an ordered range of all the journal articles where structureId = ?. 1138 * 1139 * <p> 1140 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1141 * </p> 1142 * 1143 * @param structureId the structure ID 1144 * @param start the lower bound of the range of journal articles 1145 * @param end the upper bound of the range of journal articles (not inclusive) 1146 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1147 * @return the ordered range of matching journal articles 1148 * @throws SystemException if a system exception occurred 1149 */ 1150 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1151 java.lang.String structureId, int start, int end, 1152 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1153 throws com.liferay.portal.kernel.exception.SystemException { 1154 return getPersistence() 1155 .findByStructureId(structureId, start, end, orderByComparator); 1156 } 1157 1158 /** 1159 * Returns the first journal article in the ordered set where structureId = ?. 1160 * 1161 * @param structureId the structure ID 1162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1163 * @return the first matching journal article 1164 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1165 * @throws SystemException if a system exception occurred 1166 */ 1167 public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_First( 1168 java.lang.String structureId, 1169 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1170 throws com.liferay.portal.kernel.exception.SystemException, 1171 com.liferay.portlet.journal.NoSuchArticleException { 1172 return getPersistence() 1173 .findByStructureId_First(structureId, orderByComparator); 1174 } 1175 1176 /** 1177 * Returns the first journal article in the ordered set where structureId = ?. 1178 * 1179 * @param structureId the structure ID 1180 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1181 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1182 * @throws SystemException if a system exception occurred 1183 */ 1184 public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_First( 1185 java.lang.String structureId, 1186 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1187 throws com.liferay.portal.kernel.exception.SystemException { 1188 return getPersistence() 1189 .fetchByStructureId_First(structureId, orderByComparator); 1190 } 1191 1192 /** 1193 * Returns the last journal article in the ordered set where structureId = ?. 1194 * 1195 * @param structureId the structure ID 1196 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1197 * @return the last matching journal article 1198 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1199 * @throws SystemException if a system exception occurred 1200 */ 1201 public static com.liferay.portlet.journal.model.JournalArticle findByStructureId_Last( 1202 java.lang.String structureId, 1203 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1204 throws com.liferay.portal.kernel.exception.SystemException, 1205 com.liferay.portlet.journal.NoSuchArticleException { 1206 return getPersistence() 1207 .findByStructureId_Last(structureId, orderByComparator); 1208 } 1209 1210 /** 1211 * Returns the last journal article in the ordered set where structureId = ?. 1212 * 1213 * @param structureId the structure ID 1214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1215 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1216 * @throws SystemException if a system exception occurred 1217 */ 1218 public static com.liferay.portlet.journal.model.JournalArticle fetchByStructureId_Last( 1219 java.lang.String structureId, 1220 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1221 throws com.liferay.portal.kernel.exception.SystemException { 1222 return getPersistence() 1223 .fetchByStructureId_Last(structureId, orderByComparator); 1224 } 1225 1226 /** 1227 * Returns the journal articles before and after the current journal article in the ordered set where structureId = ?. 1228 * 1229 * @param id the primary key of the current journal article 1230 * @param structureId the structure ID 1231 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1232 * @return the previous, current, and next journal article 1233 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1234 * @throws SystemException if a system exception occurred 1235 */ 1236 public static com.liferay.portlet.journal.model.JournalArticle[] findByStructureId_PrevAndNext( 1237 long id, java.lang.String structureId, 1238 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1239 throws com.liferay.portal.kernel.exception.SystemException, 1240 com.liferay.portlet.journal.NoSuchArticleException { 1241 return getPersistence() 1242 .findByStructureId_PrevAndNext(id, structureId, 1243 orderByComparator); 1244 } 1245 1246 /** 1247 * Returns all the journal articles where structureId = any ?. 1248 * 1249 * <p> 1250 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1251 * </p> 1252 * 1253 * @param structureIds the structure IDs 1254 * @return the matching journal articles 1255 * @throws SystemException if a system exception occurred 1256 */ 1257 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1258 java.lang.String[] structureIds) 1259 throws com.liferay.portal.kernel.exception.SystemException { 1260 return getPersistence().findByStructureId(structureIds); 1261 } 1262 1263 /** 1264 * Returns a range of all the journal articles where structureId = any ?. 1265 * 1266 * <p> 1267 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1268 * </p> 1269 * 1270 * @param structureIds the structure IDs 1271 * @param start the lower bound of the range of journal articles 1272 * @param end the upper bound of the range of journal articles (not inclusive) 1273 * @return the range of matching journal articles 1274 * @throws SystemException if a system exception occurred 1275 */ 1276 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1277 java.lang.String[] structureIds, int start, int end) 1278 throws com.liferay.portal.kernel.exception.SystemException { 1279 return getPersistence().findByStructureId(structureIds, start, end); 1280 } 1281 1282 /** 1283 * Returns an ordered range of all the journal articles where structureId = any ?. 1284 * 1285 * <p> 1286 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1287 * </p> 1288 * 1289 * @param structureIds the structure IDs 1290 * @param start the lower bound of the range of journal articles 1291 * @param end the upper bound of the range of journal articles (not inclusive) 1292 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1293 * @return the ordered range of matching journal articles 1294 * @throws SystemException if a system exception occurred 1295 */ 1296 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByStructureId( 1297 java.lang.String[] structureIds, int start, int end, 1298 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1299 throws com.liferay.portal.kernel.exception.SystemException { 1300 return getPersistence() 1301 .findByStructureId(structureIds, start, end, 1302 orderByComparator); 1303 } 1304 1305 /** 1306 * Removes all the journal articles where structureId = ? from the database. 1307 * 1308 * @param structureId the structure ID 1309 * @throws SystemException if a system exception occurred 1310 */ 1311 public static void removeByStructureId(java.lang.String structureId) 1312 throws com.liferay.portal.kernel.exception.SystemException { 1313 getPersistence().removeByStructureId(structureId); 1314 } 1315 1316 /** 1317 * Returns the number of journal articles where structureId = ?. 1318 * 1319 * @param structureId the structure ID 1320 * @return the number of matching journal articles 1321 * @throws SystemException if a system exception occurred 1322 */ 1323 public static int countByStructureId(java.lang.String structureId) 1324 throws com.liferay.portal.kernel.exception.SystemException { 1325 return getPersistence().countByStructureId(structureId); 1326 } 1327 1328 /** 1329 * Returns the number of journal articles where structureId = any ?. 1330 * 1331 * @param structureIds the structure IDs 1332 * @return the number of matching journal articles 1333 * @throws SystemException if a system exception occurred 1334 */ 1335 public static int countByStructureId(java.lang.String[] structureIds) 1336 throws com.liferay.portal.kernel.exception.SystemException { 1337 return getPersistence().countByStructureId(structureIds); 1338 } 1339 1340 /** 1341 * Returns all the journal articles where templateId = ?. 1342 * 1343 * @param templateId the template ID 1344 * @return the matching journal articles 1345 * @throws SystemException if a system exception occurred 1346 */ 1347 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1348 java.lang.String templateId) 1349 throws com.liferay.portal.kernel.exception.SystemException { 1350 return getPersistence().findByTemplateId(templateId); 1351 } 1352 1353 /** 1354 * Returns a range of all the journal articles where templateId = ?. 1355 * 1356 * <p> 1357 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1358 * </p> 1359 * 1360 * @param templateId the template ID 1361 * @param start the lower bound of the range of journal articles 1362 * @param end the upper bound of the range of journal articles (not inclusive) 1363 * @return the range of matching journal articles 1364 * @throws SystemException if a system exception occurred 1365 */ 1366 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1367 java.lang.String templateId, int start, int end) 1368 throws com.liferay.portal.kernel.exception.SystemException { 1369 return getPersistence().findByTemplateId(templateId, start, end); 1370 } 1371 1372 /** 1373 * Returns an ordered range of all the journal articles where templateId = ?. 1374 * 1375 * <p> 1376 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1377 * </p> 1378 * 1379 * @param templateId the template ID 1380 * @param start the lower bound of the range of journal articles 1381 * @param end the upper bound of the range of journal articles (not inclusive) 1382 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1383 * @return the ordered range of matching journal articles 1384 * @throws SystemException if a system exception occurred 1385 */ 1386 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByTemplateId( 1387 java.lang.String templateId, int start, int end, 1388 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1389 throws com.liferay.portal.kernel.exception.SystemException { 1390 return getPersistence() 1391 .findByTemplateId(templateId, start, end, orderByComparator); 1392 } 1393 1394 /** 1395 * Returns the first journal article in the ordered set where templateId = ?. 1396 * 1397 * @param templateId the template ID 1398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1399 * @return the first matching journal article 1400 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1401 * @throws SystemException if a system exception occurred 1402 */ 1403 public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_First( 1404 java.lang.String templateId, 1405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1406 throws com.liferay.portal.kernel.exception.SystemException, 1407 com.liferay.portlet.journal.NoSuchArticleException { 1408 return getPersistence() 1409 .findByTemplateId_First(templateId, orderByComparator); 1410 } 1411 1412 /** 1413 * Returns the first journal article in the ordered set where templateId = ?. 1414 * 1415 * @param templateId the template ID 1416 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1417 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1418 * @throws SystemException if a system exception occurred 1419 */ 1420 public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_First( 1421 java.lang.String templateId, 1422 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1423 throws com.liferay.portal.kernel.exception.SystemException { 1424 return getPersistence() 1425 .fetchByTemplateId_First(templateId, orderByComparator); 1426 } 1427 1428 /** 1429 * Returns the last journal article in the ordered set where templateId = ?. 1430 * 1431 * @param templateId the template ID 1432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1433 * @return the last matching journal article 1434 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1435 * @throws SystemException if a system exception occurred 1436 */ 1437 public static com.liferay.portlet.journal.model.JournalArticle findByTemplateId_Last( 1438 java.lang.String templateId, 1439 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1440 throws com.liferay.portal.kernel.exception.SystemException, 1441 com.liferay.portlet.journal.NoSuchArticleException { 1442 return getPersistence() 1443 .findByTemplateId_Last(templateId, orderByComparator); 1444 } 1445 1446 /** 1447 * Returns the last journal article in the ordered set where templateId = ?. 1448 * 1449 * @param templateId the template ID 1450 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1451 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1452 * @throws SystemException if a system exception occurred 1453 */ 1454 public static com.liferay.portlet.journal.model.JournalArticle fetchByTemplateId_Last( 1455 java.lang.String templateId, 1456 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1457 throws com.liferay.portal.kernel.exception.SystemException { 1458 return getPersistence() 1459 .fetchByTemplateId_Last(templateId, orderByComparator); 1460 } 1461 1462 /** 1463 * Returns the journal articles before and after the current journal article in the ordered set where templateId = ?. 1464 * 1465 * @param id the primary key of the current journal article 1466 * @param templateId the template ID 1467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1468 * @return the previous, current, and next journal article 1469 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1470 * @throws SystemException if a system exception occurred 1471 */ 1472 public static com.liferay.portlet.journal.model.JournalArticle[] findByTemplateId_PrevAndNext( 1473 long id, java.lang.String templateId, 1474 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1475 throws com.liferay.portal.kernel.exception.SystemException, 1476 com.liferay.portlet.journal.NoSuchArticleException { 1477 return getPersistence() 1478 .findByTemplateId_PrevAndNext(id, templateId, 1479 orderByComparator); 1480 } 1481 1482 /** 1483 * Removes all the journal articles where templateId = ? from the database. 1484 * 1485 * @param templateId the template ID 1486 * @throws SystemException if a system exception occurred 1487 */ 1488 public static void removeByTemplateId(java.lang.String templateId) 1489 throws com.liferay.portal.kernel.exception.SystemException { 1490 getPersistence().removeByTemplateId(templateId); 1491 } 1492 1493 /** 1494 * Returns the number of journal articles where templateId = ?. 1495 * 1496 * @param templateId the template ID 1497 * @return the number of matching journal articles 1498 * @throws SystemException if a system exception occurred 1499 */ 1500 public static int countByTemplateId(java.lang.String templateId) 1501 throws com.liferay.portal.kernel.exception.SystemException { 1502 return getPersistence().countByTemplateId(templateId); 1503 } 1504 1505 /** 1506 * Returns all the journal articles where layoutUuid = ?. 1507 * 1508 * @param layoutUuid the layout uuid 1509 * @return the matching journal articles 1510 * @throws SystemException if a system exception occurred 1511 */ 1512 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1513 java.lang.String layoutUuid) 1514 throws com.liferay.portal.kernel.exception.SystemException { 1515 return getPersistence().findByLayoutUuid(layoutUuid); 1516 } 1517 1518 /** 1519 * Returns a range of all the journal articles where layoutUuid = ?. 1520 * 1521 * <p> 1522 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1523 * </p> 1524 * 1525 * @param layoutUuid the layout uuid 1526 * @param start the lower bound of the range of journal articles 1527 * @param end the upper bound of the range of journal articles (not inclusive) 1528 * @return the range of matching journal articles 1529 * @throws SystemException if a system exception occurred 1530 */ 1531 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1532 java.lang.String layoutUuid, int start, int end) 1533 throws com.liferay.portal.kernel.exception.SystemException { 1534 return getPersistence().findByLayoutUuid(layoutUuid, start, end); 1535 } 1536 1537 /** 1538 * Returns an ordered range of all the journal articles where layoutUuid = ?. 1539 * 1540 * <p> 1541 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1542 * </p> 1543 * 1544 * @param layoutUuid the layout uuid 1545 * @param start the lower bound of the range of journal articles 1546 * @param end the upper bound of the range of journal articles (not inclusive) 1547 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1548 * @return the ordered range of matching journal articles 1549 * @throws SystemException if a system exception occurred 1550 */ 1551 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLayoutUuid( 1552 java.lang.String layoutUuid, int start, int end, 1553 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1554 throws com.liferay.portal.kernel.exception.SystemException { 1555 return getPersistence() 1556 .findByLayoutUuid(layoutUuid, start, end, orderByComparator); 1557 } 1558 1559 /** 1560 * Returns the first journal article in the ordered set where layoutUuid = ?. 1561 * 1562 * @param layoutUuid the layout uuid 1563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1564 * @return the first matching journal article 1565 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1566 * @throws SystemException if a system exception occurred 1567 */ 1568 public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_First( 1569 java.lang.String layoutUuid, 1570 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1571 throws com.liferay.portal.kernel.exception.SystemException, 1572 com.liferay.portlet.journal.NoSuchArticleException { 1573 return getPersistence() 1574 .findByLayoutUuid_First(layoutUuid, orderByComparator); 1575 } 1576 1577 /** 1578 * Returns the first journal article in the ordered set where layoutUuid = ?. 1579 * 1580 * @param layoutUuid the layout uuid 1581 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1582 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1583 * @throws SystemException if a system exception occurred 1584 */ 1585 public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_First( 1586 java.lang.String layoutUuid, 1587 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1588 throws com.liferay.portal.kernel.exception.SystemException { 1589 return getPersistence() 1590 .fetchByLayoutUuid_First(layoutUuid, orderByComparator); 1591 } 1592 1593 /** 1594 * Returns the last journal article in the ordered set where layoutUuid = ?. 1595 * 1596 * @param layoutUuid the layout uuid 1597 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1598 * @return the last matching journal article 1599 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1600 * @throws SystemException if a system exception occurred 1601 */ 1602 public static com.liferay.portlet.journal.model.JournalArticle findByLayoutUuid_Last( 1603 java.lang.String layoutUuid, 1604 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1605 throws com.liferay.portal.kernel.exception.SystemException, 1606 com.liferay.portlet.journal.NoSuchArticleException { 1607 return getPersistence() 1608 .findByLayoutUuid_Last(layoutUuid, orderByComparator); 1609 } 1610 1611 /** 1612 * Returns the last journal article in the ordered set where layoutUuid = ?. 1613 * 1614 * @param layoutUuid the layout uuid 1615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1616 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1617 * @throws SystemException if a system exception occurred 1618 */ 1619 public static com.liferay.portlet.journal.model.JournalArticle fetchByLayoutUuid_Last( 1620 java.lang.String layoutUuid, 1621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1622 throws com.liferay.portal.kernel.exception.SystemException { 1623 return getPersistence() 1624 .fetchByLayoutUuid_Last(layoutUuid, orderByComparator); 1625 } 1626 1627 /** 1628 * Returns the journal articles before and after the current journal article in the ordered set where layoutUuid = ?. 1629 * 1630 * @param id the primary key of the current journal article 1631 * @param layoutUuid the layout uuid 1632 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1633 * @return the previous, current, and next journal article 1634 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1635 * @throws SystemException if a system exception occurred 1636 */ 1637 public static com.liferay.portlet.journal.model.JournalArticle[] findByLayoutUuid_PrevAndNext( 1638 long id, java.lang.String layoutUuid, 1639 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1640 throws com.liferay.portal.kernel.exception.SystemException, 1641 com.liferay.portlet.journal.NoSuchArticleException { 1642 return getPersistence() 1643 .findByLayoutUuid_PrevAndNext(id, layoutUuid, 1644 orderByComparator); 1645 } 1646 1647 /** 1648 * Removes all the journal articles where layoutUuid = ? from the database. 1649 * 1650 * @param layoutUuid the layout uuid 1651 * @throws SystemException if a system exception occurred 1652 */ 1653 public static void removeByLayoutUuid(java.lang.String layoutUuid) 1654 throws com.liferay.portal.kernel.exception.SystemException { 1655 getPersistence().removeByLayoutUuid(layoutUuid); 1656 } 1657 1658 /** 1659 * Returns the number of journal articles where layoutUuid = ?. 1660 * 1661 * @param layoutUuid the layout uuid 1662 * @return the number of matching journal articles 1663 * @throws SystemException if a system exception occurred 1664 */ 1665 public static int countByLayoutUuid(java.lang.String layoutUuid) 1666 throws com.liferay.portal.kernel.exception.SystemException { 1667 return getPersistence().countByLayoutUuid(layoutUuid); 1668 } 1669 1670 /** 1671 * Returns all the journal articles where smallImageId = ?. 1672 * 1673 * @param smallImageId the small image ID 1674 * @return the matching journal articles 1675 * @throws SystemException if a system exception occurred 1676 */ 1677 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1678 long smallImageId) 1679 throws com.liferay.portal.kernel.exception.SystemException { 1680 return getPersistence().findBySmallImageId(smallImageId); 1681 } 1682 1683 /** 1684 * Returns a range of all the journal articles where smallImageId = ?. 1685 * 1686 * <p> 1687 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1688 * </p> 1689 * 1690 * @param smallImageId the small image ID 1691 * @param start the lower bound of the range of journal articles 1692 * @param end the upper bound of the range of journal articles (not inclusive) 1693 * @return the range of matching journal articles 1694 * @throws SystemException if a system exception occurred 1695 */ 1696 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1697 long smallImageId, int start, int end) 1698 throws com.liferay.portal.kernel.exception.SystemException { 1699 return getPersistence().findBySmallImageId(smallImageId, start, end); 1700 } 1701 1702 /** 1703 * Returns an ordered range of all the journal articles where smallImageId = ?. 1704 * 1705 * <p> 1706 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1707 * </p> 1708 * 1709 * @param smallImageId the small image ID 1710 * @param start the lower bound of the range of journal articles 1711 * @param end the upper bound of the range of journal articles (not inclusive) 1712 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1713 * @return the ordered range of matching journal articles 1714 * @throws SystemException if a system exception occurred 1715 */ 1716 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findBySmallImageId( 1717 long smallImageId, int start, int end, 1718 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1719 throws com.liferay.portal.kernel.exception.SystemException { 1720 return getPersistence() 1721 .findBySmallImageId(smallImageId, start, end, 1722 orderByComparator); 1723 } 1724 1725 /** 1726 * Returns the first journal article in the ordered set where smallImageId = ?. 1727 * 1728 * @param smallImageId the small image ID 1729 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1730 * @return the first matching journal article 1731 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1732 * @throws SystemException if a system exception occurred 1733 */ 1734 public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_First( 1735 long smallImageId, 1736 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1737 throws com.liferay.portal.kernel.exception.SystemException, 1738 com.liferay.portlet.journal.NoSuchArticleException { 1739 return getPersistence() 1740 .findBySmallImageId_First(smallImageId, orderByComparator); 1741 } 1742 1743 /** 1744 * Returns the first journal article in the ordered set where smallImageId = ?. 1745 * 1746 * @param smallImageId the small image ID 1747 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1748 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1749 * @throws SystemException if a system exception occurred 1750 */ 1751 public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_First( 1752 long smallImageId, 1753 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1754 throws com.liferay.portal.kernel.exception.SystemException { 1755 return getPersistence() 1756 .fetchBySmallImageId_First(smallImageId, orderByComparator); 1757 } 1758 1759 /** 1760 * Returns the last journal article in the ordered set where smallImageId = ?. 1761 * 1762 * @param smallImageId the small image ID 1763 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1764 * @return the last matching journal article 1765 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1766 * @throws SystemException if a system exception occurred 1767 */ 1768 public static com.liferay.portlet.journal.model.JournalArticle findBySmallImageId_Last( 1769 long smallImageId, 1770 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1771 throws com.liferay.portal.kernel.exception.SystemException, 1772 com.liferay.portlet.journal.NoSuchArticleException { 1773 return getPersistence() 1774 .findBySmallImageId_Last(smallImageId, orderByComparator); 1775 } 1776 1777 /** 1778 * Returns the last journal article in the ordered set where smallImageId = ?. 1779 * 1780 * @param smallImageId the small image ID 1781 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1782 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1783 * @throws SystemException if a system exception occurred 1784 */ 1785 public static com.liferay.portlet.journal.model.JournalArticle fetchBySmallImageId_Last( 1786 long smallImageId, 1787 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1788 throws com.liferay.portal.kernel.exception.SystemException { 1789 return getPersistence() 1790 .fetchBySmallImageId_Last(smallImageId, orderByComparator); 1791 } 1792 1793 /** 1794 * Returns the journal articles before and after the current journal article in the ordered set where smallImageId = ?. 1795 * 1796 * @param id the primary key of the current journal article 1797 * @param smallImageId the small image ID 1798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1799 * @return the previous, current, and next journal article 1800 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1801 * @throws SystemException if a system exception occurred 1802 */ 1803 public static com.liferay.portlet.journal.model.JournalArticle[] findBySmallImageId_PrevAndNext( 1804 long id, long smallImageId, 1805 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1806 throws com.liferay.portal.kernel.exception.SystemException, 1807 com.liferay.portlet.journal.NoSuchArticleException { 1808 return getPersistence() 1809 .findBySmallImageId_PrevAndNext(id, smallImageId, 1810 orderByComparator); 1811 } 1812 1813 /** 1814 * Removes all the journal articles where smallImageId = ? from the database. 1815 * 1816 * @param smallImageId the small image ID 1817 * @throws SystemException if a system exception occurred 1818 */ 1819 public static void removeBySmallImageId(long smallImageId) 1820 throws com.liferay.portal.kernel.exception.SystemException { 1821 getPersistence().removeBySmallImageId(smallImageId); 1822 } 1823 1824 /** 1825 * Returns the number of journal articles where smallImageId = ?. 1826 * 1827 * @param smallImageId the small image ID 1828 * @return the number of matching journal articles 1829 * @throws SystemException if a system exception occurred 1830 */ 1831 public static int countBySmallImageId(long smallImageId) 1832 throws com.liferay.portal.kernel.exception.SystemException { 1833 return getPersistence().countBySmallImageId(smallImageId); 1834 } 1835 1836 /** 1837 * Returns all the journal articles where resourcePrimKey = ? and indexable = ?. 1838 * 1839 * @param resourcePrimKey the resource prim key 1840 * @param indexable the indexable 1841 * @return the matching journal articles 1842 * @throws SystemException if a system exception occurred 1843 */ 1844 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I( 1845 long resourcePrimKey, boolean indexable) 1846 throws com.liferay.portal.kernel.exception.SystemException { 1847 return getPersistence().findByR_I(resourcePrimKey, indexable); 1848 } 1849 1850 /** 1851 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ?. 1852 * 1853 * <p> 1854 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1855 * </p> 1856 * 1857 * @param resourcePrimKey the resource prim key 1858 * @param indexable the indexable 1859 * @param start the lower bound of the range of journal articles 1860 * @param end the upper bound of the range of journal articles (not inclusive) 1861 * @return the range of matching journal articles 1862 * @throws SystemException if a system exception occurred 1863 */ 1864 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I( 1865 long resourcePrimKey, boolean indexable, int start, int end) 1866 throws com.liferay.portal.kernel.exception.SystemException { 1867 return getPersistence().findByR_I(resourcePrimKey, indexable, start, end); 1868 } 1869 1870 /** 1871 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ?. 1872 * 1873 * <p> 1874 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1875 * </p> 1876 * 1877 * @param resourcePrimKey the resource prim key 1878 * @param indexable the indexable 1879 * @param start the lower bound of the range of journal articles 1880 * @param end the upper bound of the range of journal articles (not inclusive) 1881 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1882 * @return the ordered range of matching journal articles 1883 * @throws SystemException if a system exception occurred 1884 */ 1885 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I( 1886 long resourcePrimKey, boolean indexable, int start, int end, 1887 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1888 throws com.liferay.portal.kernel.exception.SystemException { 1889 return getPersistence() 1890 .findByR_I(resourcePrimKey, indexable, start, end, 1891 orderByComparator); 1892 } 1893 1894 /** 1895 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1896 * 1897 * @param resourcePrimKey the resource prim key 1898 * @param indexable the indexable 1899 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1900 * @return the first matching journal article 1901 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1902 * @throws SystemException if a system exception occurred 1903 */ 1904 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_First( 1905 long resourcePrimKey, boolean indexable, 1906 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1907 throws com.liferay.portal.kernel.exception.SystemException, 1908 com.liferay.portlet.journal.NoSuchArticleException { 1909 return getPersistence() 1910 .findByR_I_First(resourcePrimKey, indexable, 1911 orderByComparator); 1912 } 1913 1914 /** 1915 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1916 * 1917 * @param resourcePrimKey the resource prim key 1918 * @param indexable the indexable 1919 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1920 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 1921 * @throws SystemException if a system exception occurred 1922 */ 1923 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_First( 1924 long resourcePrimKey, boolean indexable, 1925 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1926 throws com.liferay.portal.kernel.exception.SystemException { 1927 return getPersistence() 1928 .fetchByR_I_First(resourcePrimKey, indexable, 1929 orderByComparator); 1930 } 1931 1932 /** 1933 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1934 * 1935 * @param resourcePrimKey the resource prim key 1936 * @param indexable the indexable 1937 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1938 * @return the last matching journal article 1939 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 1940 * @throws SystemException if a system exception occurred 1941 */ 1942 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_Last( 1943 long resourcePrimKey, boolean indexable, 1944 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1945 throws com.liferay.portal.kernel.exception.SystemException, 1946 com.liferay.portlet.journal.NoSuchArticleException { 1947 return getPersistence() 1948 .findByR_I_Last(resourcePrimKey, indexable, orderByComparator); 1949 } 1950 1951 /** 1952 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1953 * 1954 * @param resourcePrimKey the resource prim key 1955 * @param indexable the indexable 1956 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1957 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 1958 * @throws SystemException if a system exception occurred 1959 */ 1960 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_Last( 1961 long resourcePrimKey, boolean indexable, 1962 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1963 throws com.liferay.portal.kernel.exception.SystemException { 1964 return getPersistence() 1965 .fetchByR_I_Last(resourcePrimKey, indexable, 1966 orderByComparator); 1967 } 1968 1969 /** 1970 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and indexable = ?. 1971 * 1972 * @param id the primary key of the current journal article 1973 * @param resourcePrimKey the resource prim key 1974 * @param indexable the indexable 1975 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1976 * @return the previous, current, and next journal article 1977 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 1978 * @throws SystemException if a system exception occurred 1979 */ 1980 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_PrevAndNext( 1981 long id, long resourcePrimKey, boolean indexable, 1982 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1983 throws com.liferay.portal.kernel.exception.SystemException, 1984 com.liferay.portlet.journal.NoSuchArticleException { 1985 return getPersistence() 1986 .findByR_I_PrevAndNext(id, resourcePrimKey, indexable, 1987 orderByComparator); 1988 } 1989 1990 /** 1991 * Removes all the journal articles where resourcePrimKey = ? and indexable = ? from the database. 1992 * 1993 * @param resourcePrimKey the resource prim key 1994 * @param indexable the indexable 1995 * @throws SystemException if a system exception occurred 1996 */ 1997 public static void removeByR_I(long resourcePrimKey, boolean indexable) 1998 throws com.liferay.portal.kernel.exception.SystemException { 1999 getPersistence().removeByR_I(resourcePrimKey, indexable); 2000 } 2001 2002 /** 2003 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ?. 2004 * 2005 * @param resourcePrimKey the resource prim key 2006 * @param indexable the indexable 2007 * @return the number of matching journal articles 2008 * @throws SystemException if a system exception occurred 2009 */ 2010 public static int countByR_I(long resourcePrimKey, boolean indexable) 2011 throws com.liferay.portal.kernel.exception.SystemException { 2012 return getPersistence().countByR_I(resourcePrimKey, indexable); 2013 } 2014 2015 /** 2016 * Returns all the journal articles where resourcePrimKey = ? and status = ?. 2017 * 2018 * @param resourcePrimKey the resource prim key 2019 * @param status the status 2020 * @return the matching journal articles 2021 * @throws SystemException if a system exception occurred 2022 */ 2023 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2024 long resourcePrimKey, int status) 2025 throws com.liferay.portal.kernel.exception.SystemException { 2026 return getPersistence().findByR_ST(resourcePrimKey, status); 2027 } 2028 2029 /** 2030 * Returns a range of all the journal articles where resourcePrimKey = ? and status = ?. 2031 * 2032 * <p> 2033 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2034 * </p> 2035 * 2036 * @param resourcePrimKey the resource prim key 2037 * @param status the status 2038 * @param start the lower bound of the range of journal articles 2039 * @param end the upper bound of the range of journal articles (not inclusive) 2040 * @return the range of matching journal articles 2041 * @throws SystemException if a system exception occurred 2042 */ 2043 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2044 long resourcePrimKey, int status, int start, int end) 2045 throws com.liferay.portal.kernel.exception.SystemException { 2046 return getPersistence().findByR_ST(resourcePrimKey, status, start, end); 2047 } 2048 2049 /** 2050 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and status = ?. 2051 * 2052 * <p> 2053 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2054 * </p> 2055 * 2056 * @param resourcePrimKey the resource prim key 2057 * @param status the status 2058 * @param start the lower bound of the range of journal articles 2059 * @param end the upper bound of the range of journal articles (not inclusive) 2060 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2061 * @return the ordered range of matching journal articles 2062 * @throws SystemException if a system exception occurred 2063 */ 2064 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2065 long resourcePrimKey, int status, int start, int end, 2066 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2067 throws com.liferay.portal.kernel.exception.SystemException { 2068 return getPersistence() 2069 .findByR_ST(resourcePrimKey, status, start, end, 2070 orderByComparator); 2071 } 2072 2073 /** 2074 * Returns the first journal article in the ordered set where resourcePrimKey = ? and status = ?. 2075 * 2076 * @param resourcePrimKey the resource prim key 2077 * @param status the status 2078 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2079 * @return the first matching journal article 2080 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2081 * @throws SystemException if a system exception occurred 2082 */ 2083 public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_First( 2084 long resourcePrimKey, int status, 2085 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2086 throws com.liferay.portal.kernel.exception.SystemException, 2087 com.liferay.portlet.journal.NoSuchArticleException { 2088 return getPersistence() 2089 .findByR_ST_First(resourcePrimKey, status, orderByComparator); 2090 } 2091 2092 /** 2093 * Returns the first journal article in the ordered set where resourcePrimKey = ? and status = ?. 2094 * 2095 * @param resourcePrimKey the resource prim key 2096 * @param status the status 2097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2098 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2099 * @throws SystemException if a system exception occurred 2100 */ 2101 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_First( 2102 long resourcePrimKey, int status, 2103 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2104 throws com.liferay.portal.kernel.exception.SystemException { 2105 return getPersistence() 2106 .fetchByR_ST_First(resourcePrimKey, status, orderByComparator); 2107 } 2108 2109 /** 2110 * Returns the last journal article in the ordered set where resourcePrimKey = ? and status = ?. 2111 * 2112 * @param resourcePrimKey the resource prim key 2113 * @param status the status 2114 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2115 * @return the last matching journal article 2116 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2117 * @throws SystemException if a system exception occurred 2118 */ 2119 public static com.liferay.portlet.journal.model.JournalArticle findByR_ST_Last( 2120 long resourcePrimKey, int status, 2121 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2122 throws com.liferay.portal.kernel.exception.SystemException, 2123 com.liferay.portlet.journal.NoSuchArticleException { 2124 return getPersistence() 2125 .findByR_ST_Last(resourcePrimKey, status, orderByComparator); 2126 } 2127 2128 /** 2129 * Returns the last journal article in the ordered set where resourcePrimKey = ? and status = ?. 2130 * 2131 * @param resourcePrimKey the resource prim key 2132 * @param status the status 2133 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2134 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2135 * @throws SystemException if a system exception occurred 2136 */ 2137 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_ST_Last( 2138 long resourcePrimKey, int status, 2139 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2140 throws com.liferay.portal.kernel.exception.SystemException { 2141 return getPersistence() 2142 .fetchByR_ST_Last(resourcePrimKey, status, orderByComparator); 2143 } 2144 2145 /** 2146 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and status = ?. 2147 * 2148 * @param id the primary key of the current journal article 2149 * @param resourcePrimKey the resource prim key 2150 * @param status the status 2151 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2152 * @return the previous, current, and next journal article 2153 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2154 * @throws SystemException if a system exception occurred 2155 */ 2156 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_ST_PrevAndNext( 2157 long id, long resourcePrimKey, int status, 2158 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2159 throws com.liferay.portal.kernel.exception.SystemException, 2160 com.liferay.portlet.journal.NoSuchArticleException { 2161 return getPersistence() 2162 .findByR_ST_PrevAndNext(id, resourcePrimKey, status, 2163 orderByComparator); 2164 } 2165 2166 /** 2167 * Returns all the journal articles where resourcePrimKey = ? and status = any ?. 2168 * 2169 * <p> 2170 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2171 * </p> 2172 * 2173 * @param resourcePrimKey the resource prim key 2174 * @param statuses the statuses 2175 * @return the matching journal articles 2176 * @throws SystemException if a system exception occurred 2177 */ 2178 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2179 long resourcePrimKey, int[] statuses) 2180 throws com.liferay.portal.kernel.exception.SystemException { 2181 return getPersistence().findByR_ST(resourcePrimKey, statuses); 2182 } 2183 2184 /** 2185 * Returns a range of all the journal articles where resourcePrimKey = ? and status = any ?. 2186 * 2187 * <p> 2188 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2189 * </p> 2190 * 2191 * @param resourcePrimKey the resource prim key 2192 * @param statuses the statuses 2193 * @param start the lower bound of the range of journal articles 2194 * @param end the upper bound of the range of journal articles (not inclusive) 2195 * @return the range of matching journal articles 2196 * @throws SystemException if a system exception occurred 2197 */ 2198 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2199 long resourcePrimKey, int[] statuses, int start, int end) 2200 throws com.liferay.portal.kernel.exception.SystemException { 2201 return getPersistence().findByR_ST(resourcePrimKey, statuses, start, end); 2202 } 2203 2204 /** 2205 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and status = any ?. 2206 * 2207 * <p> 2208 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2209 * </p> 2210 * 2211 * @param resourcePrimKey the resource prim key 2212 * @param statuses the statuses 2213 * @param start the lower bound of the range of journal articles 2214 * @param end the upper bound of the range of journal articles (not inclusive) 2215 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2216 * @return the ordered range of matching journal articles 2217 * @throws SystemException if a system exception occurred 2218 */ 2219 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_ST( 2220 long resourcePrimKey, int[] statuses, int start, int end, 2221 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2222 throws com.liferay.portal.kernel.exception.SystemException { 2223 return getPersistence() 2224 .findByR_ST(resourcePrimKey, statuses, start, end, 2225 orderByComparator); 2226 } 2227 2228 /** 2229 * Removes all the journal articles where resourcePrimKey = ? and status = ? from the database. 2230 * 2231 * @param resourcePrimKey the resource prim key 2232 * @param status the status 2233 * @throws SystemException if a system exception occurred 2234 */ 2235 public static void removeByR_ST(long resourcePrimKey, int status) 2236 throws com.liferay.portal.kernel.exception.SystemException { 2237 getPersistence().removeByR_ST(resourcePrimKey, status); 2238 } 2239 2240 /** 2241 * Returns the number of journal articles where resourcePrimKey = ? and status = ?. 2242 * 2243 * @param resourcePrimKey the resource prim key 2244 * @param status the status 2245 * @return the number of matching journal articles 2246 * @throws SystemException if a system exception occurred 2247 */ 2248 public static int countByR_ST(long resourcePrimKey, int status) 2249 throws com.liferay.portal.kernel.exception.SystemException { 2250 return getPersistence().countByR_ST(resourcePrimKey, status); 2251 } 2252 2253 /** 2254 * Returns the number of journal articles where resourcePrimKey = ? and status = any ?. 2255 * 2256 * @param resourcePrimKey the resource prim key 2257 * @param statuses the statuses 2258 * @return the number of matching journal articles 2259 * @throws SystemException if a system exception occurred 2260 */ 2261 public static int countByR_ST(long resourcePrimKey, int[] statuses) 2262 throws com.liferay.portal.kernel.exception.SystemException { 2263 return getPersistence().countByR_ST(resourcePrimKey, statuses); 2264 } 2265 2266 /** 2267 * Returns all the journal articles where groupId = ? and userId = ?. 2268 * 2269 * @param groupId the group ID 2270 * @param userId the user ID 2271 * @return the matching journal articles 2272 * @throws SystemException if a system exception occurred 2273 */ 2274 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2275 long groupId, long userId) 2276 throws com.liferay.portal.kernel.exception.SystemException { 2277 return getPersistence().findByG_U(groupId, userId); 2278 } 2279 2280 /** 2281 * Returns a range of all the journal articles where groupId = ? and userId = ?. 2282 * 2283 * <p> 2284 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2285 * </p> 2286 * 2287 * @param groupId the group ID 2288 * @param userId the user ID 2289 * @param start the lower bound of the range of journal articles 2290 * @param end the upper bound of the range of journal articles (not inclusive) 2291 * @return the range of matching journal articles 2292 * @throws SystemException if a system exception occurred 2293 */ 2294 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2295 long groupId, long userId, int start, int end) 2296 throws com.liferay.portal.kernel.exception.SystemException { 2297 return getPersistence().findByG_U(groupId, userId, start, end); 2298 } 2299 2300 /** 2301 * Returns an ordered range of all the journal articles where groupId = ? and userId = ?. 2302 * 2303 * <p> 2304 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2305 * </p> 2306 * 2307 * @param groupId the group ID 2308 * @param userId the user ID 2309 * @param start the lower bound of the range of journal articles 2310 * @param end the upper bound of the range of journal articles (not inclusive) 2311 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2312 * @return the ordered range of matching journal articles 2313 * @throws SystemException if a system exception occurred 2314 */ 2315 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U( 2316 long groupId, long userId, int start, int end, 2317 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2318 throws com.liferay.portal.kernel.exception.SystemException { 2319 return getPersistence() 2320 .findByG_U(groupId, userId, start, end, orderByComparator); 2321 } 2322 2323 /** 2324 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2325 * 2326 * @param groupId the group ID 2327 * @param userId the user ID 2328 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2329 * @return the first matching journal article 2330 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2331 * @throws SystemException if a system exception occurred 2332 */ 2333 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_First( 2334 long groupId, long userId, 2335 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2336 throws com.liferay.portal.kernel.exception.SystemException, 2337 com.liferay.portlet.journal.NoSuchArticleException { 2338 return getPersistence() 2339 .findByG_U_First(groupId, userId, orderByComparator); 2340 } 2341 2342 /** 2343 * Returns the first journal article in the ordered set where groupId = ? and userId = ?. 2344 * 2345 * @param groupId the group ID 2346 * @param userId the user ID 2347 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2348 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2349 * @throws SystemException if a system exception occurred 2350 */ 2351 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_First( 2352 long groupId, long userId, 2353 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2354 throws com.liferay.portal.kernel.exception.SystemException { 2355 return getPersistence() 2356 .fetchByG_U_First(groupId, userId, orderByComparator); 2357 } 2358 2359 /** 2360 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2361 * 2362 * @param groupId the group ID 2363 * @param userId the user ID 2364 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2365 * @return the last matching journal article 2366 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2367 * @throws SystemException if a system exception occurred 2368 */ 2369 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_Last( 2370 long groupId, long userId, 2371 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2372 throws com.liferay.portal.kernel.exception.SystemException, 2373 com.liferay.portlet.journal.NoSuchArticleException { 2374 return getPersistence() 2375 .findByG_U_Last(groupId, userId, orderByComparator); 2376 } 2377 2378 /** 2379 * Returns the last journal article in the ordered set where groupId = ? and userId = ?. 2380 * 2381 * @param groupId the group ID 2382 * @param userId the user ID 2383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2384 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2385 * @throws SystemException if a system exception occurred 2386 */ 2387 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_Last( 2388 long groupId, long userId, 2389 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2390 throws com.liferay.portal.kernel.exception.SystemException { 2391 return getPersistence() 2392 .fetchByG_U_Last(groupId, userId, orderByComparator); 2393 } 2394 2395 /** 2396 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ?. 2397 * 2398 * @param id the primary key of the current journal article 2399 * @param groupId the group ID 2400 * @param userId the user ID 2401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2402 * @return the previous, current, and next journal article 2403 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2404 * @throws SystemException if a system exception occurred 2405 */ 2406 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_PrevAndNext( 2407 long id, long groupId, long userId, 2408 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2409 throws com.liferay.portal.kernel.exception.SystemException, 2410 com.liferay.portlet.journal.NoSuchArticleException { 2411 return getPersistence() 2412 .findByG_U_PrevAndNext(id, groupId, userId, orderByComparator); 2413 } 2414 2415 /** 2416 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2417 * 2418 * @param groupId the group ID 2419 * @param userId the user ID 2420 * @return the matching journal articles that the user has permission to view 2421 * @throws SystemException if a system exception occurred 2422 */ 2423 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2424 long groupId, long userId) 2425 throws com.liferay.portal.kernel.exception.SystemException { 2426 return getPersistence().filterFindByG_U(groupId, userId); 2427 } 2428 2429 /** 2430 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ?. 2431 * 2432 * <p> 2433 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2434 * </p> 2435 * 2436 * @param groupId the group ID 2437 * @param userId the user ID 2438 * @param start the lower bound of the range of journal articles 2439 * @param end the upper bound of the range of journal articles (not inclusive) 2440 * @return the range of matching journal articles that the user has permission to view 2441 * @throws SystemException if a system exception occurred 2442 */ 2443 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2444 long groupId, long userId, int start, int end) 2445 throws com.liferay.portal.kernel.exception.SystemException { 2446 return getPersistence().filterFindByG_U(groupId, userId, start, end); 2447 } 2448 2449 /** 2450 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ?. 2451 * 2452 * <p> 2453 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2454 * </p> 2455 * 2456 * @param groupId the group ID 2457 * @param userId the user ID 2458 * @param start the lower bound of the range of journal articles 2459 * @param end the upper bound of the range of journal articles (not inclusive) 2460 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2461 * @return the ordered range of matching journal articles that the user has permission to view 2462 * @throws SystemException if a system exception occurred 2463 */ 2464 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U( 2465 long groupId, long userId, int start, int end, 2466 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2467 throws com.liferay.portal.kernel.exception.SystemException { 2468 return getPersistence() 2469 .filterFindByG_U(groupId, userId, start, end, 2470 orderByComparator); 2471 } 2472 2473 /** 2474 * 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 = ?. 2475 * 2476 * @param id the primary key of the current journal article 2477 * @param groupId the group ID 2478 * @param userId the user ID 2479 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2480 * @return the previous, current, and next journal article 2481 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2482 * @throws SystemException if a system exception occurred 2483 */ 2484 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_PrevAndNext( 2485 long id, long groupId, long userId, 2486 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2487 throws com.liferay.portal.kernel.exception.SystemException, 2488 com.liferay.portlet.journal.NoSuchArticleException { 2489 return getPersistence() 2490 .filterFindByG_U_PrevAndNext(id, groupId, userId, 2491 orderByComparator); 2492 } 2493 2494 /** 2495 * Removes all the journal articles where groupId = ? and userId = ? from the database. 2496 * 2497 * @param groupId the group ID 2498 * @param userId the user ID 2499 * @throws SystemException if a system exception occurred 2500 */ 2501 public static void removeByG_U(long groupId, long userId) 2502 throws com.liferay.portal.kernel.exception.SystemException { 2503 getPersistence().removeByG_U(groupId, userId); 2504 } 2505 2506 /** 2507 * Returns the number of journal articles where groupId = ? and userId = ?. 2508 * 2509 * @param groupId the group ID 2510 * @param userId the user ID 2511 * @return the number of matching journal articles 2512 * @throws SystemException if a system exception occurred 2513 */ 2514 public static int countByG_U(long groupId, long userId) 2515 throws com.liferay.portal.kernel.exception.SystemException { 2516 return getPersistence().countByG_U(groupId, userId); 2517 } 2518 2519 /** 2520 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ?. 2521 * 2522 * @param groupId the group ID 2523 * @param userId the user ID 2524 * @return the number of matching journal articles that the user has permission to view 2525 * @throws SystemException if a system exception occurred 2526 */ 2527 public static int filterCountByG_U(long groupId, long userId) 2528 throws com.liferay.portal.kernel.exception.SystemException { 2529 return getPersistence().filterCountByG_U(groupId, userId); 2530 } 2531 2532 /** 2533 * Returns all the journal articles where groupId = ? and folderId = ?. 2534 * 2535 * @param groupId the group ID 2536 * @param folderId the folder ID 2537 * @return the matching journal articles 2538 * @throws SystemException if a system exception occurred 2539 */ 2540 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2541 long groupId, long folderId) 2542 throws com.liferay.portal.kernel.exception.SystemException { 2543 return getPersistence().findByG_F(groupId, folderId); 2544 } 2545 2546 /** 2547 * Returns a range of all the journal articles where groupId = ? and folderId = ?. 2548 * 2549 * <p> 2550 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2551 * </p> 2552 * 2553 * @param groupId the group ID 2554 * @param folderId the folder ID 2555 * @param start the lower bound of the range of journal articles 2556 * @param end the upper bound of the range of journal articles (not inclusive) 2557 * @return the range of matching journal articles 2558 * @throws SystemException if a system exception occurred 2559 */ 2560 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2561 long groupId, long folderId, int start, int end) 2562 throws com.liferay.portal.kernel.exception.SystemException { 2563 return getPersistence().findByG_F(groupId, folderId, start, end); 2564 } 2565 2566 /** 2567 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ?. 2568 * 2569 * <p> 2570 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2571 * </p> 2572 * 2573 * @param groupId the group ID 2574 * @param folderId the folder ID 2575 * @param start the lower bound of the range of journal articles 2576 * @param end the upper bound of the range of journal articles (not inclusive) 2577 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2578 * @return the ordered range of matching journal articles 2579 * @throws SystemException if a system exception occurred 2580 */ 2581 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2582 long groupId, long folderId, int start, int end, 2583 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2584 throws com.liferay.portal.kernel.exception.SystemException { 2585 return getPersistence() 2586 .findByG_F(groupId, folderId, start, end, orderByComparator); 2587 } 2588 2589 /** 2590 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2591 * 2592 * @param groupId the group ID 2593 * @param folderId the folder ID 2594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2595 * @return the first matching journal article 2596 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2597 * @throws SystemException if a system exception occurred 2598 */ 2599 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_First( 2600 long groupId, long folderId, 2601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2602 throws com.liferay.portal.kernel.exception.SystemException, 2603 com.liferay.portlet.journal.NoSuchArticleException { 2604 return getPersistence() 2605 .findByG_F_First(groupId, folderId, orderByComparator); 2606 } 2607 2608 /** 2609 * Returns the first journal article in the ordered set where groupId = ? and folderId = ?. 2610 * 2611 * @param groupId the group ID 2612 * @param folderId the folder ID 2613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2614 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 2615 * @throws SystemException if a system exception occurred 2616 */ 2617 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_First( 2618 long groupId, long folderId, 2619 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2620 throws com.liferay.portal.kernel.exception.SystemException { 2621 return getPersistence() 2622 .fetchByG_F_First(groupId, folderId, orderByComparator); 2623 } 2624 2625 /** 2626 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2627 * 2628 * @param groupId the group ID 2629 * @param folderId the folder ID 2630 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2631 * @return the last matching journal article 2632 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 2633 * @throws SystemException if a system exception occurred 2634 */ 2635 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_Last( 2636 long groupId, long folderId, 2637 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2638 throws com.liferay.portal.kernel.exception.SystemException, 2639 com.liferay.portlet.journal.NoSuchArticleException { 2640 return getPersistence() 2641 .findByG_F_Last(groupId, folderId, orderByComparator); 2642 } 2643 2644 /** 2645 * Returns the last journal article in the ordered set where groupId = ? and folderId = ?. 2646 * 2647 * @param groupId the group ID 2648 * @param folderId the folder ID 2649 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2650 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 2651 * @throws SystemException if a system exception occurred 2652 */ 2653 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_Last( 2654 long groupId, long folderId, 2655 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2656 throws com.liferay.portal.kernel.exception.SystemException { 2657 return getPersistence() 2658 .fetchByG_F_Last(groupId, folderId, orderByComparator); 2659 } 2660 2661 /** 2662 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ?. 2663 * 2664 * @param id the primary key of the current journal article 2665 * @param groupId the group ID 2666 * @param folderId the folder ID 2667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2668 * @return the previous, current, and next journal article 2669 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2670 * @throws SystemException if a system exception occurred 2671 */ 2672 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_PrevAndNext( 2673 long id, long groupId, long folderId, 2674 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2675 throws com.liferay.portal.kernel.exception.SystemException, 2676 com.liferay.portlet.journal.NoSuchArticleException { 2677 return getPersistence() 2678 .findByG_F_PrevAndNext(id, groupId, folderId, 2679 orderByComparator); 2680 } 2681 2682 /** 2683 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2684 * 2685 * @param groupId the group ID 2686 * @param folderId the folder ID 2687 * @return the matching journal articles that the user has permission to view 2688 * @throws SystemException if a system exception occurred 2689 */ 2690 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2691 long groupId, long folderId) 2692 throws com.liferay.portal.kernel.exception.SystemException { 2693 return getPersistence().filterFindByG_F(groupId, folderId); 2694 } 2695 2696 /** 2697 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ?. 2698 * 2699 * <p> 2700 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2701 * </p> 2702 * 2703 * @param groupId the group ID 2704 * @param folderId the folder ID 2705 * @param start the lower bound of the range of journal articles 2706 * @param end the upper bound of the range of journal articles (not inclusive) 2707 * @return the range of matching journal articles that the user has permission to view 2708 * @throws SystemException if a system exception occurred 2709 */ 2710 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2711 long groupId, long folderId, int start, int end) 2712 throws com.liferay.portal.kernel.exception.SystemException { 2713 return getPersistence().filterFindByG_F(groupId, folderId, start, end); 2714 } 2715 2716 /** 2717 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ?. 2718 * 2719 * <p> 2720 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2721 * </p> 2722 * 2723 * @param groupId the group ID 2724 * @param folderId the folder ID 2725 * @param start the lower bound of the range of journal articles 2726 * @param end the upper bound of the range of journal articles (not inclusive) 2727 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2728 * @return the ordered range of matching journal articles that the user has permission to view 2729 * @throws SystemException if a system exception occurred 2730 */ 2731 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2732 long groupId, long folderId, int start, int end, 2733 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2734 throws com.liferay.portal.kernel.exception.SystemException { 2735 return getPersistence() 2736 .filterFindByG_F(groupId, folderId, start, end, 2737 orderByComparator); 2738 } 2739 2740 /** 2741 * 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 = ?. 2742 * 2743 * @param id the primary key of the current journal article 2744 * @param groupId the group ID 2745 * @param folderId the folder ID 2746 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2747 * @return the previous, current, and next journal article 2748 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 2749 * @throws SystemException if a system exception occurred 2750 */ 2751 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_PrevAndNext( 2752 long id, long groupId, long folderId, 2753 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2754 throws com.liferay.portal.kernel.exception.SystemException, 2755 com.liferay.portlet.journal.NoSuchArticleException { 2756 return getPersistence() 2757 .filterFindByG_F_PrevAndNext(id, groupId, folderId, 2758 orderByComparator); 2759 } 2760 2761 /** 2762 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2763 * 2764 * @param groupId the group ID 2765 * @param folderIds the folder IDs 2766 * @return the matching journal articles that the user has permission to view 2767 * @throws SystemException if a system exception occurred 2768 */ 2769 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2770 long groupId, long[] folderIds) 2771 throws com.liferay.portal.kernel.exception.SystemException { 2772 return getPersistence().filterFindByG_F(groupId, folderIds); 2773 } 2774 2775 /** 2776 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2777 * 2778 * <p> 2779 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2780 * </p> 2781 * 2782 * @param groupId the group ID 2783 * @param folderIds the folder IDs 2784 * @param start the lower bound of the range of journal articles 2785 * @param end the upper bound of the range of journal articles (not inclusive) 2786 * @return the range of matching journal articles that the user has permission to view 2787 * @throws SystemException if a system exception occurred 2788 */ 2789 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2790 long groupId, long[] folderIds, int start, int end) 2791 throws com.liferay.portal.kernel.exception.SystemException { 2792 return getPersistence().filterFindByG_F(groupId, folderIds, start, end); 2793 } 2794 2795 /** 2796 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2797 * 2798 * <p> 2799 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2800 * </p> 2801 * 2802 * @param groupId the group ID 2803 * @param folderIds the folder IDs 2804 * @param start the lower bound of the range of journal articles 2805 * @param end the upper bound of the range of journal articles (not inclusive) 2806 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2807 * @return the ordered range of matching journal articles that the user has permission to view 2808 * @throws SystemException if a system exception occurred 2809 */ 2810 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F( 2811 long groupId, long[] folderIds, int start, int end, 2812 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2813 throws com.liferay.portal.kernel.exception.SystemException { 2814 return getPersistence() 2815 .filterFindByG_F(groupId, folderIds, start, end, 2816 orderByComparator); 2817 } 2818 2819 /** 2820 * Returns all the journal articles where groupId = ? and folderId = any ?. 2821 * 2822 * <p> 2823 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2824 * </p> 2825 * 2826 * @param groupId the group ID 2827 * @param folderIds the folder IDs 2828 * @return the matching journal articles 2829 * @throws SystemException if a system exception occurred 2830 */ 2831 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2832 long groupId, long[] folderIds) 2833 throws com.liferay.portal.kernel.exception.SystemException { 2834 return getPersistence().findByG_F(groupId, folderIds); 2835 } 2836 2837 /** 2838 * Returns a range of all the journal articles where groupId = ? and folderId = any ?. 2839 * 2840 * <p> 2841 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2842 * </p> 2843 * 2844 * @param groupId the group ID 2845 * @param folderIds the folder IDs 2846 * @param start the lower bound of the range of journal articles 2847 * @param end the upper bound of the range of journal articles (not inclusive) 2848 * @return the range of matching journal articles 2849 * @throws SystemException if a system exception occurred 2850 */ 2851 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2852 long groupId, long[] folderIds, int start, int end) 2853 throws com.liferay.portal.kernel.exception.SystemException { 2854 return getPersistence().findByG_F(groupId, folderIds, start, end); 2855 } 2856 2857 /** 2858 * Returns an ordered range of all the journal articles where groupId = ? and folderId = any ?. 2859 * 2860 * <p> 2861 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2862 * </p> 2863 * 2864 * @param groupId the group ID 2865 * @param folderIds the folder IDs 2866 * @param start the lower bound of the range of journal articles 2867 * @param end the upper bound of the range of journal articles (not inclusive) 2868 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2869 * @return the ordered range of matching journal articles 2870 * @throws SystemException if a system exception occurred 2871 */ 2872 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F( 2873 long groupId, long[] folderIds, int start, int end, 2874 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2875 throws com.liferay.portal.kernel.exception.SystemException { 2876 return getPersistence() 2877 .findByG_F(groupId, folderIds, start, end, orderByComparator); 2878 } 2879 2880 /** 2881 * Removes all the journal articles where groupId = ? and folderId = ? from the database. 2882 * 2883 * @param groupId the group ID 2884 * @param folderId the folder ID 2885 * @throws SystemException if a system exception occurred 2886 */ 2887 public static void removeByG_F(long groupId, long folderId) 2888 throws com.liferay.portal.kernel.exception.SystemException { 2889 getPersistence().removeByG_F(groupId, folderId); 2890 } 2891 2892 /** 2893 * Returns the number of journal articles where groupId = ? and folderId = ?. 2894 * 2895 * @param groupId the group ID 2896 * @param folderId the folder ID 2897 * @return the number of matching journal articles 2898 * @throws SystemException if a system exception occurred 2899 */ 2900 public static int countByG_F(long groupId, long folderId) 2901 throws com.liferay.portal.kernel.exception.SystemException { 2902 return getPersistence().countByG_F(groupId, folderId); 2903 } 2904 2905 /** 2906 * Returns the number of journal articles where groupId = ? and folderId = any ?. 2907 * 2908 * @param groupId the group ID 2909 * @param folderIds the folder IDs 2910 * @return the number of matching journal articles 2911 * @throws SystemException if a system exception occurred 2912 */ 2913 public static int countByG_F(long groupId, long[] folderIds) 2914 throws com.liferay.portal.kernel.exception.SystemException { 2915 return getPersistence().countByG_F(groupId, folderIds); 2916 } 2917 2918 /** 2919 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ?. 2920 * 2921 * @param groupId the group ID 2922 * @param folderId the folder ID 2923 * @return the number of matching journal articles that the user has permission to view 2924 * @throws SystemException if a system exception occurred 2925 */ 2926 public static int filterCountByG_F(long groupId, long folderId) 2927 throws com.liferay.portal.kernel.exception.SystemException { 2928 return getPersistence().filterCountByG_F(groupId, folderId); 2929 } 2930 2931 /** 2932 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = any ?. 2933 * 2934 * @param groupId the group ID 2935 * @param folderIds the folder IDs 2936 * @return the number of matching journal articles that the user has permission to view 2937 * @throws SystemException if a system exception occurred 2938 */ 2939 public static int filterCountByG_F(long groupId, long[] folderIds) 2940 throws com.liferay.portal.kernel.exception.SystemException { 2941 return getPersistence().filterCountByG_F(groupId, folderIds); 2942 } 2943 2944 /** 2945 * Returns all the journal articles where groupId = ? and articleId = ?. 2946 * 2947 * @param groupId the group ID 2948 * @param articleId the article ID 2949 * @return the matching journal articles 2950 * @throws SystemException if a system exception occurred 2951 */ 2952 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2953 long groupId, java.lang.String articleId) 2954 throws com.liferay.portal.kernel.exception.SystemException { 2955 return getPersistence().findByG_A(groupId, articleId); 2956 } 2957 2958 /** 2959 * Returns a range of all the journal articles where groupId = ? and articleId = ?. 2960 * 2961 * <p> 2962 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2963 * </p> 2964 * 2965 * @param groupId the group ID 2966 * @param articleId the article ID 2967 * @param start the lower bound of the range of journal articles 2968 * @param end the upper bound of the range of journal articles (not inclusive) 2969 * @return the range of matching journal articles 2970 * @throws SystemException if a system exception occurred 2971 */ 2972 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2973 long groupId, java.lang.String articleId, int start, int end) 2974 throws com.liferay.portal.kernel.exception.SystemException { 2975 return getPersistence().findByG_A(groupId, articleId, start, end); 2976 } 2977 2978 /** 2979 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ?. 2980 * 2981 * <p> 2982 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2983 * </p> 2984 * 2985 * @param groupId the group ID 2986 * @param articleId the article ID 2987 * @param start the lower bound of the range of journal articles 2988 * @param end the upper bound of the range of journal articles (not inclusive) 2989 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2990 * @return the ordered range of matching journal articles 2991 * @throws SystemException if a system exception occurred 2992 */ 2993 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A( 2994 long groupId, java.lang.String articleId, int start, int end, 2995 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2996 throws com.liferay.portal.kernel.exception.SystemException { 2997 return getPersistence() 2998 .findByG_A(groupId, articleId, start, end, orderByComparator); 2999 } 3000 3001 /** 3002 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 3003 * 3004 * @param groupId the group ID 3005 * @param articleId the article ID 3006 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3007 * @return the first matching journal article 3008 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3009 * @throws SystemException if a system exception occurred 3010 */ 3011 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_First( 3012 long groupId, java.lang.String articleId, 3013 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3014 throws com.liferay.portal.kernel.exception.SystemException, 3015 com.liferay.portlet.journal.NoSuchArticleException { 3016 return getPersistence() 3017 .findByG_A_First(groupId, articleId, orderByComparator); 3018 } 3019 3020 /** 3021 * Returns the first journal article in the ordered set where groupId = ? and articleId = ?. 3022 * 3023 * @param groupId the group ID 3024 * @param articleId the article ID 3025 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3026 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3027 * @throws SystemException if a system exception occurred 3028 */ 3029 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_First( 3030 long groupId, java.lang.String articleId, 3031 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3032 throws com.liferay.portal.kernel.exception.SystemException { 3033 return getPersistence() 3034 .fetchByG_A_First(groupId, articleId, orderByComparator); 3035 } 3036 3037 /** 3038 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 3039 * 3040 * @param groupId the group ID 3041 * @param articleId the article ID 3042 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3043 * @return the last matching journal article 3044 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3045 * @throws SystemException if a system exception occurred 3046 */ 3047 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_Last( 3048 long groupId, java.lang.String articleId, 3049 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3050 throws com.liferay.portal.kernel.exception.SystemException, 3051 com.liferay.portlet.journal.NoSuchArticleException { 3052 return getPersistence() 3053 .findByG_A_Last(groupId, articleId, orderByComparator); 3054 } 3055 3056 /** 3057 * Returns the last journal article in the ordered set where groupId = ? and articleId = ?. 3058 * 3059 * @param groupId the group ID 3060 * @param articleId the article ID 3061 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3062 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3063 * @throws SystemException if a system exception occurred 3064 */ 3065 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_Last( 3066 long groupId, java.lang.String articleId, 3067 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3068 throws com.liferay.portal.kernel.exception.SystemException { 3069 return getPersistence() 3070 .fetchByG_A_Last(groupId, articleId, orderByComparator); 3071 } 3072 3073 /** 3074 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ?. 3075 * 3076 * @param id the primary key of the current journal article 3077 * @param groupId the group ID 3078 * @param articleId the article ID 3079 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3080 * @return the previous, current, and next journal article 3081 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3082 * @throws SystemException if a system exception occurred 3083 */ 3084 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_PrevAndNext( 3085 long id, long groupId, java.lang.String articleId, 3086 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3087 throws com.liferay.portal.kernel.exception.SystemException, 3088 com.liferay.portlet.journal.NoSuchArticleException { 3089 return getPersistence() 3090 .findByG_A_PrevAndNext(id, groupId, articleId, 3091 orderByComparator); 3092 } 3093 3094 /** 3095 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 3096 * 3097 * @param groupId the group ID 3098 * @param articleId the article ID 3099 * @return the matching journal articles that the user has permission to view 3100 * @throws SystemException if a system exception occurred 3101 */ 3102 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3103 long groupId, java.lang.String articleId) 3104 throws com.liferay.portal.kernel.exception.SystemException { 3105 return getPersistence().filterFindByG_A(groupId, articleId); 3106 } 3107 3108 /** 3109 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ?. 3110 * 3111 * <p> 3112 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3113 * </p> 3114 * 3115 * @param groupId the group ID 3116 * @param articleId the article ID 3117 * @param start the lower bound of the range of journal articles 3118 * @param end the upper bound of the range of journal articles (not inclusive) 3119 * @return the range of matching journal articles that the user has permission to view 3120 * @throws SystemException if a system exception occurred 3121 */ 3122 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3123 long groupId, java.lang.String articleId, int start, int end) 3124 throws com.liferay.portal.kernel.exception.SystemException { 3125 return getPersistence().filterFindByG_A(groupId, articleId, start, end); 3126 } 3127 3128 /** 3129 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ?. 3130 * 3131 * <p> 3132 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3133 * </p> 3134 * 3135 * @param groupId the group ID 3136 * @param articleId the article ID 3137 * @param start the lower bound of the range of journal articles 3138 * @param end the upper bound of the range of journal articles (not inclusive) 3139 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3140 * @return the ordered range of matching journal articles that the user has permission to view 3141 * @throws SystemException if a system exception occurred 3142 */ 3143 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A( 3144 long groupId, java.lang.String articleId, int start, int end, 3145 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3146 throws com.liferay.portal.kernel.exception.SystemException { 3147 return getPersistence() 3148 .filterFindByG_A(groupId, articleId, start, end, 3149 orderByComparator); 3150 } 3151 3152 /** 3153 * 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 = ?. 3154 * 3155 * @param id the primary key of the current journal article 3156 * @param groupId the group ID 3157 * @param articleId the article ID 3158 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3159 * @return the previous, current, and next journal article 3160 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3161 * @throws SystemException if a system exception occurred 3162 */ 3163 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_PrevAndNext( 3164 long id, long groupId, java.lang.String articleId, 3165 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3166 throws com.liferay.portal.kernel.exception.SystemException, 3167 com.liferay.portlet.journal.NoSuchArticleException { 3168 return getPersistence() 3169 .filterFindByG_A_PrevAndNext(id, groupId, articleId, 3170 orderByComparator); 3171 } 3172 3173 /** 3174 * Removes all the journal articles where groupId = ? and articleId = ? from the database. 3175 * 3176 * @param groupId the group ID 3177 * @param articleId the article ID 3178 * @throws SystemException if a system exception occurred 3179 */ 3180 public static void removeByG_A(long groupId, java.lang.String articleId) 3181 throws com.liferay.portal.kernel.exception.SystemException { 3182 getPersistence().removeByG_A(groupId, articleId); 3183 } 3184 3185 /** 3186 * Returns the number of journal articles where groupId = ? and articleId = ?. 3187 * 3188 * @param groupId the group ID 3189 * @param articleId the article ID 3190 * @return the number of matching journal articles 3191 * @throws SystemException if a system exception occurred 3192 */ 3193 public static int countByG_A(long groupId, java.lang.String articleId) 3194 throws com.liferay.portal.kernel.exception.SystemException { 3195 return getPersistence().countByG_A(groupId, articleId); 3196 } 3197 3198 /** 3199 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ?. 3200 * 3201 * @param groupId the group ID 3202 * @param articleId the article ID 3203 * @return the number of matching journal articles that the user has permission to view 3204 * @throws SystemException if a system exception occurred 3205 */ 3206 public static int filterCountByG_A(long groupId, java.lang.String articleId) 3207 throws com.liferay.portal.kernel.exception.SystemException { 3208 return getPersistence().filterCountByG_A(groupId, articleId); 3209 } 3210 3211 /** 3212 * Returns all the journal articles where groupId = ? and urlTitle = ?. 3213 * 3214 * @param groupId the group ID 3215 * @param urlTitle the url title 3216 * @return the matching journal articles 3217 * @throws SystemException if a system exception occurred 3218 */ 3219 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3220 long groupId, java.lang.String urlTitle) 3221 throws com.liferay.portal.kernel.exception.SystemException { 3222 return getPersistence().findByG_UT(groupId, urlTitle); 3223 } 3224 3225 /** 3226 * Returns a range of all the journal articles where groupId = ? and urlTitle = ?. 3227 * 3228 * <p> 3229 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3230 * </p> 3231 * 3232 * @param groupId the group ID 3233 * @param urlTitle the url title 3234 * @param start the lower bound of the range of journal articles 3235 * @param end the upper bound of the range of journal articles (not inclusive) 3236 * @return the range of matching journal articles 3237 * @throws SystemException if a system exception occurred 3238 */ 3239 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3240 long groupId, java.lang.String urlTitle, int start, int end) 3241 throws com.liferay.portal.kernel.exception.SystemException { 3242 return getPersistence().findByG_UT(groupId, urlTitle, start, end); 3243 } 3244 3245 /** 3246 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ?. 3247 * 3248 * <p> 3249 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3250 * </p> 3251 * 3252 * @param groupId the group ID 3253 * @param urlTitle the url title 3254 * @param start the lower bound of the range of journal articles 3255 * @param end the upper bound of the range of journal articles (not inclusive) 3256 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3257 * @return the ordered range of matching journal articles 3258 * @throws SystemException if a system exception occurred 3259 */ 3260 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT( 3261 long groupId, java.lang.String urlTitle, int start, int end, 3262 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3263 throws com.liferay.portal.kernel.exception.SystemException { 3264 return getPersistence() 3265 .findByG_UT(groupId, urlTitle, start, end, orderByComparator); 3266 } 3267 3268 /** 3269 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3270 * 3271 * @param groupId the group ID 3272 * @param urlTitle the url title 3273 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3274 * @return the first matching journal article 3275 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3276 * @throws SystemException if a system exception occurred 3277 */ 3278 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_First( 3279 long groupId, java.lang.String urlTitle, 3280 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3281 throws com.liferay.portal.kernel.exception.SystemException, 3282 com.liferay.portlet.journal.NoSuchArticleException { 3283 return getPersistence() 3284 .findByG_UT_First(groupId, urlTitle, orderByComparator); 3285 } 3286 3287 /** 3288 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ?. 3289 * 3290 * @param groupId the group ID 3291 * @param urlTitle the url title 3292 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3293 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3294 * @throws SystemException if a system exception occurred 3295 */ 3296 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_First( 3297 long groupId, java.lang.String urlTitle, 3298 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3299 throws com.liferay.portal.kernel.exception.SystemException { 3300 return getPersistence() 3301 .fetchByG_UT_First(groupId, urlTitle, orderByComparator); 3302 } 3303 3304 /** 3305 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3306 * 3307 * @param groupId the group ID 3308 * @param urlTitle the url title 3309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3310 * @return the last matching journal article 3311 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3312 * @throws SystemException if a system exception occurred 3313 */ 3314 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_Last( 3315 long groupId, java.lang.String urlTitle, 3316 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3317 throws com.liferay.portal.kernel.exception.SystemException, 3318 com.liferay.portlet.journal.NoSuchArticleException { 3319 return getPersistence() 3320 .findByG_UT_Last(groupId, urlTitle, orderByComparator); 3321 } 3322 3323 /** 3324 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ?. 3325 * 3326 * @param groupId the group ID 3327 * @param urlTitle the url title 3328 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3329 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3330 * @throws SystemException if a system exception occurred 3331 */ 3332 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_Last( 3333 long groupId, java.lang.String urlTitle, 3334 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3335 throws com.liferay.portal.kernel.exception.SystemException { 3336 return getPersistence() 3337 .fetchByG_UT_Last(groupId, urlTitle, orderByComparator); 3338 } 3339 3340 /** 3341 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ?. 3342 * 3343 * @param id the primary key of the current journal article 3344 * @param groupId the group ID 3345 * @param urlTitle the url title 3346 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3347 * @return the previous, current, and next journal article 3348 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3349 * @throws SystemException if a system exception occurred 3350 */ 3351 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_PrevAndNext( 3352 long id, long groupId, java.lang.String urlTitle, 3353 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3354 throws com.liferay.portal.kernel.exception.SystemException, 3355 com.liferay.portlet.journal.NoSuchArticleException { 3356 return getPersistence() 3357 .findByG_UT_PrevAndNext(id, groupId, urlTitle, 3358 orderByComparator); 3359 } 3360 3361 /** 3362 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3363 * 3364 * @param groupId the group ID 3365 * @param urlTitle the url title 3366 * @return the matching journal articles that the user has permission to view 3367 * @throws SystemException if a system exception occurred 3368 */ 3369 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3370 long groupId, java.lang.String urlTitle) 3371 throws com.liferay.portal.kernel.exception.SystemException { 3372 return getPersistence().filterFindByG_UT(groupId, urlTitle); 3373 } 3374 3375 /** 3376 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3377 * 3378 * <p> 3379 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3380 * </p> 3381 * 3382 * @param groupId the group ID 3383 * @param urlTitle the url title 3384 * @param start the lower bound of the range of journal articles 3385 * @param end the upper bound of the range of journal articles (not inclusive) 3386 * @return the range of matching journal articles that the user has permission to view 3387 * @throws SystemException if a system exception occurred 3388 */ 3389 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3390 long groupId, java.lang.String urlTitle, int start, int end) 3391 throws com.liferay.portal.kernel.exception.SystemException { 3392 return getPersistence().filterFindByG_UT(groupId, urlTitle, start, end); 3393 } 3394 3395 /** 3396 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ?. 3397 * 3398 * <p> 3399 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3400 * </p> 3401 * 3402 * @param groupId the group ID 3403 * @param urlTitle the url title 3404 * @param start the lower bound of the range of journal articles 3405 * @param end the upper bound of the range of journal articles (not inclusive) 3406 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3407 * @return the ordered range of matching journal articles that the user has permission to view 3408 * @throws SystemException if a system exception occurred 3409 */ 3410 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT( 3411 long groupId, java.lang.String urlTitle, int start, int end, 3412 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3413 throws com.liferay.portal.kernel.exception.SystemException { 3414 return getPersistence() 3415 .filterFindByG_UT(groupId, urlTitle, start, end, 3416 orderByComparator); 3417 } 3418 3419 /** 3420 * 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 = ?. 3421 * 3422 * @param id the primary key of the current journal article 3423 * @param groupId the group ID 3424 * @param urlTitle the url title 3425 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3426 * @return the previous, current, and next journal article 3427 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3428 * @throws SystemException if a system exception occurred 3429 */ 3430 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_PrevAndNext( 3431 long id, long groupId, java.lang.String urlTitle, 3432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3433 throws com.liferay.portal.kernel.exception.SystemException, 3434 com.liferay.portlet.journal.NoSuchArticleException { 3435 return getPersistence() 3436 .filterFindByG_UT_PrevAndNext(id, groupId, urlTitle, 3437 orderByComparator); 3438 } 3439 3440 /** 3441 * Removes all the journal articles where groupId = ? and urlTitle = ? from the database. 3442 * 3443 * @param groupId the group ID 3444 * @param urlTitle the url title 3445 * @throws SystemException if a system exception occurred 3446 */ 3447 public static void removeByG_UT(long groupId, java.lang.String urlTitle) 3448 throws com.liferay.portal.kernel.exception.SystemException { 3449 getPersistence().removeByG_UT(groupId, urlTitle); 3450 } 3451 3452 /** 3453 * Returns the number of journal articles where groupId = ? and urlTitle = ?. 3454 * 3455 * @param groupId the group ID 3456 * @param urlTitle the url title 3457 * @return the number of matching journal articles 3458 * @throws SystemException if a system exception occurred 3459 */ 3460 public static int countByG_UT(long groupId, java.lang.String urlTitle) 3461 throws com.liferay.portal.kernel.exception.SystemException { 3462 return getPersistence().countByG_UT(groupId, urlTitle); 3463 } 3464 3465 /** 3466 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ?. 3467 * 3468 * @param groupId the group ID 3469 * @param urlTitle the url title 3470 * @return the number of matching journal articles that the user has permission to view 3471 * @throws SystemException if a system exception occurred 3472 */ 3473 public static int filterCountByG_UT(long groupId, java.lang.String urlTitle) 3474 throws com.liferay.portal.kernel.exception.SystemException { 3475 return getPersistence().filterCountByG_UT(groupId, urlTitle); 3476 } 3477 3478 /** 3479 * Returns all the journal articles where groupId = ? and structureId = ?. 3480 * 3481 * @param groupId the group ID 3482 * @param structureId the structure ID 3483 * @return the matching journal articles 3484 * @throws SystemException if a system exception occurred 3485 */ 3486 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3487 long groupId, java.lang.String structureId) 3488 throws com.liferay.portal.kernel.exception.SystemException { 3489 return getPersistence().findByG_S(groupId, structureId); 3490 } 3491 3492 /** 3493 * Returns a range of all the journal articles where groupId = ? and structureId = ?. 3494 * 3495 * <p> 3496 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3497 * </p> 3498 * 3499 * @param groupId the group ID 3500 * @param structureId the structure ID 3501 * @param start the lower bound of the range of journal articles 3502 * @param end the upper bound of the range of journal articles (not inclusive) 3503 * @return the range of matching journal articles 3504 * @throws SystemException if a system exception occurred 3505 */ 3506 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3507 long groupId, java.lang.String structureId, int start, int end) 3508 throws com.liferay.portal.kernel.exception.SystemException { 3509 return getPersistence().findByG_S(groupId, structureId, start, end); 3510 } 3511 3512 /** 3513 * Returns an ordered range of all the journal articles where groupId = ? and structureId = ?. 3514 * 3515 * <p> 3516 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3517 * </p> 3518 * 3519 * @param groupId the group ID 3520 * @param structureId the structure ID 3521 * @param start the lower bound of the range of journal articles 3522 * @param end the upper bound of the range of journal articles (not inclusive) 3523 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3524 * @return the ordered range of matching journal articles 3525 * @throws SystemException if a system exception occurred 3526 */ 3527 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_S( 3528 long groupId, java.lang.String structureId, int start, int end, 3529 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3530 throws com.liferay.portal.kernel.exception.SystemException { 3531 return getPersistence() 3532 .findByG_S(groupId, structureId, start, end, 3533 orderByComparator); 3534 } 3535 3536 /** 3537 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3538 * 3539 * @param groupId the group ID 3540 * @param structureId the structure ID 3541 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3542 * @return the first matching journal article 3543 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3544 * @throws SystemException if a system exception occurred 3545 */ 3546 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_First( 3547 long groupId, java.lang.String structureId, 3548 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3549 throws com.liferay.portal.kernel.exception.SystemException, 3550 com.liferay.portlet.journal.NoSuchArticleException { 3551 return getPersistence() 3552 .findByG_S_First(groupId, structureId, orderByComparator); 3553 } 3554 3555 /** 3556 * Returns the first journal article in the ordered set where groupId = ? and structureId = ?. 3557 * 3558 * @param groupId the group ID 3559 * @param structureId the structure ID 3560 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3561 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3562 * @throws SystemException if a system exception occurred 3563 */ 3564 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_First( 3565 long groupId, java.lang.String structureId, 3566 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3567 throws com.liferay.portal.kernel.exception.SystemException { 3568 return getPersistence() 3569 .fetchByG_S_First(groupId, structureId, orderByComparator); 3570 } 3571 3572 /** 3573 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3574 * 3575 * @param groupId the group ID 3576 * @param structureId the structure ID 3577 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3578 * @return the last matching journal article 3579 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3580 * @throws SystemException if a system exception occurred 3581 */ 3582 public static com.liferay.portlet.journal.model.JournalArticle findByG_S_Last( 3583 long groupId, java.lang.String structureId, 3584 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3585 throws com.liferay.portal.kernel.exception.SystemException, 3586 com.liferay.portlet.journal.NoSuchArticleException { 3587 return getPersistence() 3588 .findByG_S_Last(groupId, structureId, orderByComparator); 3589 } 3590 3591 /** 3592 * Returns the last journal article in the ordered set where groupId = ? and structureId = ?. 3593 * 3594 * @param groupId the group ID 3595 * @param structureId the structure ID 3596 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3597 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3598 * @throws SystemException if a system exception occurred 3599 */ 3600 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_S_Last( 3601 long groupId, java.lang.String structureId, 3602 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3603 throws com.liferay.portal.kernel.exception.SystemException { 3604 return getPersistence() 3605 .fetchByG_S_Last(groupId, structureId, orderByComparator); 3606 } 3607 3608 /** 3609 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and structureId = ?. 3610 * 3611 * @param id the primary key of the current journal article 3612 * @param groupId the group ID 3613 * @param structureId the structure ID 3614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3615 * @return the previous, current, and next journal article 3616 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3617 * @throws SystemException if a system exception occurred 3618 */ 3619 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_S_PrevAndNext( 3620 long id, long groupId, java.lang.String structureId, 3621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3622 throws com.liferay.portal.kernel.exception.SystemException, 3623 com.liferay.portlet.journal.NoSuchArticleException { 3624 return getPersistence() 3625 .findByG_S_PrevAndNext(id, groupId, structureId, 3626 orderByComparator); 3627 } 3628 3629 /** 3630 * Returns all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3631 * 3632 * @param groupId the group ID 3633 * @param structureId the structure ID 3634 * @return the matching journal articles that the user has permission to view 3635 * @throws SystemException if a system exception occurred 3636 */ 3637 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3638 long groupId, java.lang.String structureId) 3639 throws com.liferay.portal.kernel.exception.SystemException { 3640 return getPersistence().filterFindByG_S(groupId, structureId); 3641 } 3642 3643 /** 3644 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and structureId = ?. 3645 * 3646 * <p> 3647 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3648 * </p> 3649 * 3650 * @param groupId the group ID 3651 * @param structureId the structure ID 3652 * @param start the lower bound of the range of journal articles 3653 * @param end the upper bound of the range of journal articles (not inclusive) 3654 * @return the range of matching journal articles that the user has permission to view 3655 * @throws SystemException if a system exception occurred 3656 */ 3657 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3658 long groupId, java.lang.String structureId, int start, int end) 3659 throws com.liferay.portal.kernel.exception.SystemException { 3660 return getPersistence().filterFindByG_S(groupId, structureId, start, end); 3661 } 3662 3663 /** 3664 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and structureId = ?. 3665 * 3666 * <p> 3667 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3668 * </p> 3669 * 3670 * @param groupId the group ID 3671 * @param structureId the structure ID 3672 * @param start the lower bound of the range of journal articles 3673 * @param end the upper bound of the range of journal articles (not inclusive) 3674 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3675 * @return the ordered range of matching journal articles that the user has permission to view 3676 * @throws SystemException if a system exception occurred 3677 */ 3678 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_S( 3679 long groupId, java.lang.String structureId, int start, int end, 3680 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3681 throws com.liferay.portal.kernel.exception.SystemException { 3682 return getPersistence() 3683 .filterFindByG_S(groupId, structureId, start, end, 3684 orderByComparator); 3685 } 3686 3687 /** 3688 * 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 = ?. 3689 * 3690 * @param id the primary key of the current journal article 3691 * @param groupId the group ID 3692 * @param structureId the structure ID 3693 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3694 * @return the previous, current, and next journal article 3695 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3696 * @throws SystemException if a system exception occurred 3697 */ 3698 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_S_PrevAndNext( 3699 long id, long groupId, java.lang.String structureId, 3700 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3701 throws com.liferay.portal.kernel.exception.SystemException, 3702 com.liferay.portlet.journal.NoSuchArticleException { 3703 return getPersistence() 3704 .filterFindByG_S_PrevAndNext(id, groupId, structureId, 3705 orderByComparator); 3706 } 3707 3708 /** 3709 * Removes all the journal articles where groupId = ? and structureId = ? from the database. 3710 * 3711 * @param groupId the group ID 3712 * @param structureId the structure ID 3713 * @throws SystemException if a system exception occurred 3714 */ 3715 public static void removeByG_S(long groupId, java.lang.String structureId) 3716 throws com.liferay.portal.kernel.exception.SystemException { 3717 getPersistence().removeByG_S(groupId, structureId); 3718 } 3719 3720 /** 3721 * Returns the number of journal articles where groupId = ? and structureId = ?. 3722 * 3723 * @param groupId the group ID 3724 * @param structureId the structure ID 3725 * @return the number of matching journal articles 3726 * @throws SystemException if a system exception occurred 3727 */ 3728 public static int countByG_S(long groupId, java.lang.String structureId) 3729 throws com.liferay.portal.kernel.exception.SystemException { 3730 return getPersistence().countByG_S(groupId, structureId); 3731 } 3732 3733 /** 3734 * Returns the number of journal articles that the user has permission to view where groupId = ? and structureId = ?. 3735 * 3736 * @param groupId the group ID 3737 * @param structureId the structure ID 3738 * @return the number of matching journal articles that the user has permission to view 3739 * @throws SystemException if a system exception occurred 3740 */ 3741 public static int filterCountByG_S(long groupId, 3742 java.lang.String structureId) 3743 throws com.liferay.portal.kernel.exception.SystemException { 3744 return getPersistence().filterCountByG_S(groupId, structureId); 3745 } 3746 3747 /** 3748 * Returns all the journal articles where groupId = ? and templateId = ?. 3749 * 3750 * @param groupId the group ID 3751 * @param templateId the template ID 3752 * @return the matching journal articles 3753 * @throws SystemException if a system exception occurred 3754 */ 3755 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3756 long groupId, java.lang.String templateId) 3757 throws com.liferay.portal.kernel.exception.SystemException { 3758 return getPersistence().findByG_T(groupId, templateId); 3759 } 3760 3761 /** 3762 * Returns a range of all the journal articles where groupId = ? and templateId = ?. 3763 * 3764 * <p> 3765 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3766 * </p> 3767 * 3768 * @param groupId the group ID 3769 * @param templateId the template ID 3770 * @param start the lower bound of the range of journal articles 3771 * @param end the upper bound of the range of journal articles (not inclusive) 3772 * @return the range of matching journal articles 3773 * @throws SystemException if a system exception occurred 3774 */ 3775 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3776 long groupId, java.lang.String templateId, int start, int end) 3777 throws com.liferay.portal.kernel.exception.SystemException { 3778 return getPersistence().findByG_T(groupId, templateId, start, end); 3779 } 3780 3781 /** 3782 * Returns an ordered range of all the journal articles where groupId = ? and templateId = ?. 3783 * 3784 * <p> 3785 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3786 * </p> 3787 * 3788 * @param groupId the group ID 3789 * @param templateId the template ID 3790 * @param start the lower bound of the range of journal articles 3791 * @param end the upper bound of the range of journal articles (not inclusive) 3792 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3793 * @return the ordered range of matching journal articles 3794 * @throws SystemException if a system exception occurred 3795 */ 3796 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_T( 3797 long groupId, java.lang.String templateId, int start, int end, 3798 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3799 throws com.liferay.portal.kernel.exception.SystemException { 3800 return getPersistence() 3801 .findByG_T(groupId, templateId, start, end, orderByComparator); 3802 } 3803 3804 /** 3805 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3806 * 3807 * @param groupId the group ID 3808 * @param templateId the template ID 3809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3810 * @return the first matching journal article 3811 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3812 * @throws SystemException if a system exception occurred 3813 */ 3814 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_First( 3815 long groupId, java.lang.String templateId, 3816 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3817 throws com.liferay.portal.kernel.exception.SystemException, 3818 com.liferay.portlet.journal.NoSuchArticleException { 3819 return getPersistence() 3820 .findByG_T_First(groupId, templateId, orderByComparator); 3821 } 3822 3823 /** 3824 * Returns the first journal article in the ordered set where groupId = ? and templateId = ?. 3825 * 3826 * @param groupId the group ID 3827 * @param templateId the template ID 3828 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3829 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 3830 * @throws SystemException if a system exception occurred 3831 */ 3832 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_First( 3833 long groupId, java.lang.String templateId, 3834 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3835 throws com.liferay.portal.kernel.exception.SystemException { 3836 return getPersistence() 3837 .fetchByG_T_First(groupId, templateId, orderByComparator); 3838 } 3839 3840 /** 3841 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3842 * 3843 * @param groupId the group ID 3844 * @param templateId the template ID 3845 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3846 * @return the last matching journal article 3847 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 3848 * @throws SystemException if a system exception occurred 3849 */ 3850 public static com.liferay.portlet.journal.model.JournalArticle findByG_T_Last( 3851 long groupId, java.lang.String templateId, 3852 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3853 throws com.liferay.portal.kernel.exception.SystemException, 3854 com.liferay.portlet.journal.NoSuchArticleException { 3855 return getPersistence() 3856 .findByG_T_Last(groupId, templateId, orderByComparator); 3857 } 3858 3859 /** 3860 * Returns the last journal article in the ordered set where groupId = ? and templateId = ?. 3861 * 3862 * @param groupId the group ID 3863 * @param templateId the template ID 3864 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3865 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 3866 * @throws SystemException if a system exception occurred 3867 */ 3868 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_T_Last( 3869 long groupId, java.lang.String templateId, 3870 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3871 throws com.liferay.portal.kernel.exception.SystemException { 3872 return getPersistence() 3873 .fetchByG_T_Last(groupId, templateId, orderByComparator); 3874 } 3875 3876 /** 3877 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and templateId = ?. 3878 * 3879 * @param id the primary key of the current journal article 3880 * @param groupId the group ID 3881 * @param templateId the template ID 3882 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3883 * @return the previous, current, and next journal article 3884 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3885 * @throws SystemException if a system exception occurred 3886 */ 3887 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_T_PrevAndNext( 3888 long id, long groupId, java.lang.String templateId, 3889 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3890 throws com.liferay.portal.kernel.exception.SystemException, 3891 com.liferay.portlet.journal.NoSuchArticleException { 3892 return getPersistence() 3893 .findByG_T_PrevAndNext(id, groupId, templateId, 3894 orderByComparator); 3895 } 3896 3897 /** 3898 * Returns all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3899 * 3900 * @param groupId the group ID 3901 * @param templateId the template ID 3902 * @return the matching journal articles that the user has permission to view 3903 * @throws SystemException if a system exception occurred 3904 */ 3905 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3906 long groupId, java.lang.String templateId) 3907 throws com.liferay.portal.kernel.exception.SystemException { 3908 return getPersistence().filterFindByG_T(groupId, templateId); 3909 } 3910 3911 /** 3912 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and templateId = ?. 3913 * 3914 * <p> 3915 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3916 * </p> 3917 * 3918 * @param groupId the group ID 3919 * @param templateId the template ID 3920 * @param start the lower bound of the range of journal articles 3921 * @param end the upper bound of the range of journal articles (not inclusive) 3922 * @return the range of matching journal articles that the user has permission to view 3923 * @throws SystemException if a system exception occurred 3924 */ 3925 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3926 long groupId, java.lang.String templateId, int start, int end) 3927 throws com.liferay.portal.kernel.exception.SystemException { 3928 return getPersistence().filterFindByG_T(groupId, templateId, start, end); 3929 } 3930 3931 /** 3932 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and templateId = ?. 3933 * 3934 * <p> 3935 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3936 * </p> 3937 * 3938 * @param groupId the group ID 3939 * @param templateId the template ID 3940 * @param start the lower bound of the range of journal articles 3941 * @param end the upper bound of the range of journal articles (not inclusive) 3942 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3943 * @return the ordered range of matching journal articles that the user has permission to view 3944 * @throws SystemException if a system exception occurred 3945 */ 3946 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_T( 3947 long groupId, java.lang.String templateId, int start, int end, 3948 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3949 throws com.liferay.portal.kernel.exception.SystemException { 3950 return getPersistence() 3951 .filterFindByG_T(groupId, templateId, start, end, 3952 orderByComparator); 3953 } 3954 3955 /** 3956 * 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 = ?. 3957 * 3958 * @param id the primary key of the current journal article 3959 * @param groupId the group ID 3960 * @param templateId the template ID 3961 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3962 * @return the previous, current, and next journal article 3963 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 3964 * @throws SystemException if a system exception occurred 3965 */ 3966 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_T_PrevAndNext( 3967 long id, long groupId, java.lang.String templateId, 3968 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 3969 throws com.liferay.portal.kernel.exception.SystemException, 3970 com.liferay.portlet.journal.NoSuchArticleException { 3971 return getPersistence() 3972 .filterFindByG_T_PrevAndNext(id, groupId, templateId, 3973 orderByComparator); 3974 } 3975 3976 /** 3977 * Removes all the journal articles where groupId = ? and templateId = ? from the database. 3978 * 3979 * @param groupId the group ID 3980 * @param templateId the template ID 3981 * @throws SystemException if a system exception occurred 3982 */ 3983 public static void removeByG_T(long groupId, java.lang.String templateId) 3984 throws com.liferay.portal.kernel.exception.SystemException { 3985 getPersistence().removeByG_T(groupId, templateId); 3986 } 3987 3988 /** 3989 * Returns the number of journal articles where groupId = ? and templateId = ?. 3990 * 3991 * @param groupId the group ID 3992 * @param templateId the template ID 3993 * @return the number of matching journal articles 3994 * @throws SystemException if a system exception occurred 3995 */ 3996 public static int countByG_T(long groupId, java.lang.String templateId) 3997 throws com.liferay.portal.kernel.exception.SystemException { 3998 return getPersistence().countByG_T(groupId, templateId); 3999 } 4000 4001 /** 4002 * Returns the number of journal articles that the user has permission to view where groupId = ? and templateId = ?. 4003 * 4004 * @param groupId the group ID 4005 * @param templateId the template ID 4006 * @return the number of matching journal articles that the user has permission to view 4007 * @throws SystemException if a system exception occurred 4008 */ 4009 public static int filterCountByG_T(long groupId, java.lang.String templateId) 4010 throws com.liferay.portal.kernel.exception.SystemException { 4011 return getPersistence().filterCountByG_T(groupId, templateId); 4012 } 4013 4014 /** 4015 * Returns all the journal articles where groupId = ? and layoutUuid = ?. 4016 * 4017 * @param groupId the group ID 4018 * @param layoutUuid the layout uuid 4019 * @return the matching journal articles 4020 * @throws SystemException if a system exception occurred 4021 */ 4022 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 4023 long groupId, java.lang.String layoutUuid) 4024 throws com.liferay.portal.kernel.exception.SystemException { 4025 return getPersistence().findByG_L(groupId, layoutUuid); 4026 } 4027 4028 /** 4029 * Returns a range of all the journal articles where groupId = ? and layoutUuid = ?. 4030 * 4031 * <p> 4032 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4033 * </p> 4034 * 4035 * @param groupId the group ID 4036 * @param layoutUuid the layout uuid 4037 * @param start the lower bound of the range of journal articles 4038 * @param end the upper bound of the range of journal articles (not inclusive) 4039 * @return the range of matching journal articles 4040 * @throws SystemException if a system exception occurred 4041 */ 4042 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 4043 long groupId, java.lang.String layoutUuid, int start, int end) 4044 throws com.liferay.portal.kernel.exception.SystemException { 4045 return getPersistence().findByG_L(groupId, layoutUuid, start, end); 4046 } 4047 4048 /** 4049 * Returns an ordered range of all the journal articles where groupId = ? and layoutUuid = ?. 4050 * 4051 * <p> 4052 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4053 * </p> 4054 * 4055 * @param groupId the group ID 4056 * @param layoutUuid the layout uuid 4057 * @param start the lower bound of the range of journal articles 4058 * @param end the upper bound of the range of journal articles (not inclusive) 4059 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4060 * @return the ordered range of matching journal articles 4061 * @throws SystemException if a system exception occurred 4062 */ 4063 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_L( 4064 long groupId, java.lang.String layoutUuid, int start, int end, 4065 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4066 throws com.liferay.portal.kernel.exception.SystemException { 4067 return getPersistence() 4068 .findByG_L(groupId, layoutUuid, start, end, orderByComparator); 4069 } 4070 4071 /** 4072 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 4073 * 4074 * @param groupId the group ID 4075 * @param layoutUuid the layout uuid 4076 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4077 * @return the first matching journal article 4078 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4079 * @throws SystemException if a system exception occurred 4080 */ 4081 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_First( 4082 long groupId, java.lang.String layoutUuid, 4083 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4084 throws com.liferay.portal.kernel.exception.SystemException, 4085 com.liferay.portlet.journal.NoSuchArticleException { 4086 return getPersistence() 4087 .findByG_L_First(groupId, layoutUuid, orderByComparator); 4088 } 4089 4090 /** 4091 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid = ?. 4092 * 4093 * @param groupId the group ID 4094 * @param layoutUuid the layout uuid 4095 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4096 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4097 * @throws SystemException if a system exception occurred 4098 */ 4099 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_First( 4100 long groupId, java.lang.String layoutUuid, 4101 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4102 throws com.liferay.portal.kernel.exception.SystemException { 4103 return getPersistence() 4104 .fetchByG_L_First(groupId, layoutUuid, orderByComparator); 4105 } 4106 4107 /** 4108 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 4109 * 4110 * @param groupId the group ID 4111 * @param layoutUuid the layout uuid 4112 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4113 * @return the last matching journal article 4114 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4115 * @throws SystemException if a system exception occurred 4116 */ 4117 public static com.liferay.portlet.journal.model.JournalArticle findByG_L_Last( 4118 long groupId, java.lang.String layoutUuid, 4119 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4120 throws com.liferay.portal.kernel.exception.SystemException, 4121 com.liferay.portlet.journal.NoSuchArticleException { 4122 return getPersistence() 4123 .findByG_L_Last(groupId, layoutUuid, orderByComparator); 4124 } 4125 4126 /** 4127 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid = ?. 4128 * 4129 * @param groupId the group ID 4130 * @param layoutUuid the layout uuid 4131 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4132 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4133 * @throws SystemException if a system exception occurred 4134 */ 4135 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_L_Last( 4136 long groupId, java.lang.String layoutUuid, 4137 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4138 throws com.liferay.portal.kernel.exception.SystemException { 4139 return getPersistence() 4140 .fetchByG_L_Last(groupId, layoutUuid, orderByComparator); 4141 } 4142 4143 /** 4144 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and layoutUuid = ?. 4145 * 4146 * @param id the primary key of the current journal article 4147 * @param groupId the group ID 4148 * @param layoutUuid the layout uuid 4149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4150 * @return the previous, current, and next journal article 4151 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4152 * @throws SystemException if a system exception occurred 4153 */ 4154 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_L_PrevAndNext( 4155 long id, long groupId, java.lang.String layoutUuid, 4156 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4157 throws com.liferay.portal.kernel.exception.SystemException, 4158 com.liferay.portlet.journal.NoSuchArticleException { 4159 return getPersistence() 4160 .findByG_L_PrevAndNext(id, groupId, layoutUuid, 4161 orderByComparator); 4162 } 4163 4164 /** 4165 * Returns all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4166 * 4167 * @param groupId the group ID 4168 * @param layoutUuid the layout uuid 4169 * @return the matching journal articles that the user has permission to view 4170 * @throws SystemException if a system exception occurred 4171 */ 4172 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4173 long groupId, java.lang.String layoutUuid) 4174 throws com.liferay.portal.kernel.exception.SystemException { 4175 return getPersistence().filterFindByG_L(groupId, layoutUuid); 4176 } 4177 4178 /** 4179 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4180 * 4181 * <p> 4182 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4183 * </p> 4184 * 4185 * @param groupId the group ID 4186 * @param layoutUuid the layout uuid 4187 * @param start the lower bound of the range of journal articles 4188 * @param end the upper bound of the range of journal articles (not inclusive) 4189 * @return the range of matching journal articles that the user has permission to view 4190 * @throws SystemException if a system exception occurred 4191 */ 4192 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4193 long groupId, java.lang.String layoutUuid, int start, int end) 4194 throws com.liferay.portal.kernel.exception.SystemException { 4195 return getPersistence().filterFindByG_L(groupId, layoutUuid, start, end); 4196 } 4197 4198 /** 4199 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and layoutUuid = ?. 4200 * 4201 * <p> 4202 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4203 * </p> 4204 * 4205 * @param groupId the group ID 4206 * @param layoutUuid the layout uuid 4207 * @param start the lower bound of the range of journal articles 4208 * @param end the upper bound of the range of journal articles (not inclusive) 4209 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4210 * @return the ordered range of matching journal articles that the user has permission to view 4211 * @throws SystemException if a system exception occurred 4212 */ 4213 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_L( 4214 long groupId, java.lang.String layoutUuid, int start, int end, 4215 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4216 throws com.liferay.portal.kernel.exception.SystemException { 4217 return getPersistence() 4218 .filterFindByG_L(groupId, layoutUuid, start, end, 4219 orderByComparator); 4220 } 4221 4222 /** 4223 * 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 = ?. 4224 * 4225 * @param id the primary key of the current journal article 4226 * @param groupId the group ID 4227 * @param layoutUuid the layout uuid 4228 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4229 * @return the previous, current, and next journal article 4230 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4231 * @throws SystemException if a system exception occurred 4232 */ 4233 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_L_PrevAndNext( 4234 long id, long groupId, java.lang.String layoutUuid, 4235 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4236 throws com.liferay.portal.kernel.exception.SystemException, 4237 com.liferay.portlet.journal.NoSuchArticleException { 4238 return getPersistence() 4239 .filterFindByG_L_PrevAndNext(id, groupId, layoutUuid, 4240 orderByComparator); 4241 } 4242 4243 /** 4244 * Removes all the journal articles where groupId = ? and layoutUuid = ? from the database. 4245 * 4246 * @param groupId the group ID 4247 * @param layoutUuid the layout uuid 4248 * @throws SystemException if a system exception occurred 4249 */ 4250 public static void removeByG_L(long groupId, java.lang.String layoutUuid) 4251 throws com.liferay.portal.kernel.exception.SystemException { 4252 getPersistence().removeByG_L(groupId, layoutUuid); 4253 } 4254 4255 /** 4256 * Returns the number of journal articles where groupId = ? and layoutUuid = ?. 4257 * 4258 * @param groupId the group ID 4259 * @param layoutUuid the layout uuid 4260 * @return the number of matching journal articles 4261 * @throws SystemException if a system exception occurred 4262 */ 4263 public static int countByG_L(long groupId, java.lang.String layoutUuid) 4264 throws com.liferay.portal.kernel.exception.SystemException { 4265 return getPersistence().countByG_L(groupId, layoutUuid); 4266 } 4267 4268 /** 4269 * Returns the number of journal articles that the user has permission to view where groupId = ? and layoutUuid = ?. 4270 * 4271 * @param groupId the group ID 4272 * @param layoutUuid the layout uuid 4273 * @return the number of matching journal articles that the user has permission to view 4274 * @throws SystemException if a system exception occurred 4275 */ 4276 public static int filterCountByG_L(long groupId, java.lang.String layoutUuid) 4277 throws com.liferay.portal.kernel.exception.SystemException { 4278 return getPersistence().filterCountByG_L(groupId, layoutUuid); 4279 } 4280 4281 /** 4282 * Returns all the journal articles where groupId = ? and layoutUuid ≠ ?. 4283 * 4284 * @param groupId the group ID 4285 * @param layoutUuid the layout uuid 4286 * @return the matching journal articles 4287 * @throws SystemException if a system exception occurred 4288 */ 4289 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL( 4290 long groupId, java.lang.String layoutUuid) 4291 throws com.liferay.portal.kernel.exception.SystemException { 4292 return getPersistence().findByG_NotL(groupId, layoutUuid); 4293 } 4294 4295 /** 4296 * Returns a range of all the journal articles where groupId = ? and layoutUuid ≠ ?. 4297 * 4298 * <p> 4299 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4300 * </p> 4301 * 4302 * @param groupId the group ID 4303 * @param layoutUuid the layout uuid 4304 * @param start the lower bound of the range of journal articles 4305 * @param end the upper bound of the range of journal articles (not inclusive) 4306 * @return the range of matching journal articles 4307 * @throws SystemException if a system exception occurred 4308 */ 4309 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL( 4310 long groupId, java.lang.String layoutUuid, int start, int end) 4311 throws com.liferay.portal.kernel.exception.SystemException { 4312 return getPersistence().findByG_NotL(groupId, layoutUuid, start, end); 4313 } 4314 4315 /** 4316 * Returns an ordered range of all the journal articles where groupId = ? and layoutUuid ≠ ?. 4317 * 4318 * <p> 4319 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4320 * </p> 4321 * 4322 * @param groupId the group ID 4323 * @param layoutUuid the layout uuid 4324 * @param start the lower bound of the range of journal articles 4325 * @param end the upper bound of the range of journal articles (not inclusive) 4326 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4327 * @return the ordered range of matching journal articles 4328 * @throws SystemException if a system exception occurred 4329 */ 4330 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL( 4331 long groupId, java.lang.String layoutUuid, int start, int end, 4332 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4333 throws com.liferay.portal.kernel.exception.SystemException { 4334 return getPersistence() 4335 .findByG_NotL(groupId, layoutUuid, start, end, 4336 orderByComparator); 4337 } 4338 4339 /** 4340 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid ≠ ?. 4341 * 4342 * @param groupId the group ID 4343 * @param layoutUuid the layout uuid 4344 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4345 * @return the first matching journal article 4346 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4347 * @throws SystemException if a system exception occurred 4348 */ 4349 public static com.liferay.portlet.journal.model.JournalArticle findByG_NotL_First( 4350 long groupId, java.lang.String layoutUuid, 4351 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4352 throws com.liferay.portal.kernel.exception.SystemException, 4353 com.liferay.portlet.journal.NoSuchArticleException { 4354 return getPersistence() 4355 .findByG_NotL_First(groupId, layoutUuid, orderByComparator); 4356 } 4357 4358 /** 4359 * Returns the first journal article in the ordered set where groupId = ? and layoutUuid ≠ ?. 4360 * 4361 * @param groupId the group ID 4362 * @param layoutUuid the layout uuid 4363 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4364 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4365 * @throws SystemException if a system exception occurred 4366 */ 4367 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_NotL_First( 4368 long groupId, java.lang.String layoutUuid, 4369 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4370 throws com.liferay.portal.kernel.exception.SystemException { 4371 return getPersistence() 4372 .fetchByG_NotL_First(groupId, layoutUuid, orderByComparator); 4373 } 4374 4375 /** 4376 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid ≠ ?. 4377 * 4378 * @param groupId the group ID 4379 * @param layoutUuid the layout uuid 4380 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4381 * @return the last matching journal article 4382 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4383 * @throws SystemException if a system exception occurred 4384 */ 4385 public static com.liferay.portlet.journal.model.JournalArticle findByG_NotL_Last( 4386 long groupId, java.lang.String layoutUuid, 4387 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4388 throws com.liferay.portal.kernel.exception.SystemException, 4389 com.liferay.portlet.journal.NoSuchArticleException { 4390 return getPersistence() 4391 .findByG_NotL_Last(groupId, layoutUuid, orderByComparator); 4392 } 4393 4394 /** 4395 * Returns the last journal article in the ordered set where groupId = ? and layoutUuid ≠ ?. 4396 * 4397 * @param groupId the group ID 4398 * @param layoutUuid the layout uuid 4399 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4400 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4401 * @throws SystemException if a system exception occurred 4402 */ 4403 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_NotL_Last( 4404 long groupId, java.lang.String layoutUuid, 4405 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4406 throws com.liferay.portal.kernel.exception.SystemException { 4407 return getPersistence() 4408 .fetchByG_NotL_Last(groupId, layoutUuid, orderByComparator); 4409 } 4410 4411 /** 4412 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and layoutUuid ≠ ?. 4413 * 4414 * @param id the primary key of the current journal article 4415 * @param groupId the group ID 4416 * @param layoutUuid the layout uuid 4417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4418 * @return the previous, current, and next journal article 4419 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4420 * @throws SystemException if a system exception occurred 4421 */ 4422 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_NotL_PrevAndNext( 4423 long id, long groupId, java.lang.String layoutUuid, 4424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4425 throws com.liferay.portal.kernel.exception.SystemException, 4426 com.liferay.portlet.journal.NoSuchArticleException { 4427 return getPersistence() 4428 .findByG_NotL_PrevAndNext(id, groupId, layoutUuid, 4429 orderByComparator); 4430 } 4431 4432 /** 4433 * Returns all the journal articles that the user has permission to view where groupId = ? and layoutUuid ≠ ?. 4434 * 4435 * @param groupId the group ID 4436 * @param layoutUuid the layout uuid 4437 * @return the matching journal articles that the user has permission to view 4438 * @throws SystemException if a system exception occurred 4439 */ 4440 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL( 4441 long groupId, java.lang.String layoutUuid) 4442 throws com.liferay.portal.kernel.exception.SystemException { 4443 return getPersistence().filterFindByG_NotL(groupId, layoutUuid); 4444 } 4445 4446 /** 4447 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and layoutUuid ≠ ?. 4448 * 4449 * <p> 4450 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4451 * </p> 4452 * 4453 * @param groupId the group ID 4454 * @param layoutUuid the layout uuid 4455 * @param start the lower bound of the range of journal articles 4456 * @param end the upper bound of the range of journal articles (not inclusive) 4457 * @return the range of matching journal articles that the user has permission to view 4458 * @throws SystemException if a system exception occurred 4459 */ 4460 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL( 4461 long groupId, java.lang.String layoutUuid, int start, int end) 4462 throws com.liferay.portal.kernel.exception.SystemException { 4463 return getPersistence() 4464 .filterFindByG_NotL(groupId, layoutUuid, start, end); 4465 } 4466 4467 /** 4468 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and layoutUuid ≠ ?. 4469 * 4470 * <p> 4471 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4472 * </p> 4473 * 4474 * @param groupId the group ID 4475 * @param layoutUuid the layout uuid 4476 * @param start the lower bound of the range of journal articles 4477 * @param end the upper bound of the range of journal articles (not inclusive) 4478 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4479 * @return the ordered range of matching journal articles that the user has permission to view 4480 * @throws SystemException if a system exception occurred 4481 */ 4482 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL( 4483 long groupId, java.lang.String layoutUuid, int start, int end, 4484 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4485 throws com.liferay.portal.kernel.exception.SystemException { 4486 return getPersistence() 4487 .filterFindByG_NotL(groupId, layoutUuid, start, end, 4488 orderByComparator); 4489 } 4490 4491 /** 4492 * 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 ≠ ?. 4493 * 4494 * @param id the primary key of the current journal article 4495 * @param groupId the group ID 4496 * @param layoutUuid the layout uuid 4497 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4498 * @return the previous, current, and next journal article 4499 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4500 * @throws SystemException if a system exception occurred 4501 */ 4502 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_NotL_PrevAndNext( 4503 long id, long groupId, java.lang.String layoutUuid, 4504 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4505 throws com.liferay.portal.kernel.exception.SystemException, 4506 com.liferay.portlet.journal.NoSuchArticleException { 4507 return getPersistence() 4508 .filterFindByG_NotL_PrevAndNext(id, groupId, layoutUuid, 4509 orderByComparator); 4510 } 4511 4512 /** 4513 * Returns all the journal articles that the user has permission to view where groupId = ? and layoutUuid ≠ all ?. 4514 * 4515 * @param groupId the group ID 4516 * @param layoutUuids the layout uuids 4517 * @return the matching journal articles that the user has permission to view 4518 * @throws SystemException if a system exception occurred 4519 */ 4520 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL( 4521 long groupId, java.lang.String[] layoutUuids) 4522 throws com.liferay.portal.kernel.exception.SystemException { 4523 return getPersistence().filterFindByG_NotL(groupId, layoutUuids); 4524 } 4525 4526 /** 4527 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and layoutUuid ≠ all ?. 4528 * 4529 * <p> 4530 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4531 * </p> 4532 * 4533 * @param groupId the group ID 4534 * @param layoutUuids the layout uuids 4535 * @param start the lower bound of the range of journal articles 4536 * @param end the upper bound of the range of journal articles (not inclusive) 4537 * @return the range of matching journal articles that the user has permission to view 4538 * @throws SystemException if a system exception occurred 4539 */ 4540 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL( 4541 long groupId, java.lang.String[] layoutUuids, int start, int end) 4542 throws com.liferay.portal.kernel.exception.SystemException { 4543 return getPersistence() 4544 .filterFindByG_NotL(groupId, layoutUuids, start, end); 4545 } 4546 4547 /** 4548 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and layoutUuid ≠ all ?. 4549 * 4550 * <p> 4551 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4552 * </p> 4553 * 4554 * @param groupId the group ID 4555 * @param layoutUuids the layout uuids 4556 * @param start the lower bound of the range of journal articles 4557 * @param end the upper bound of the range of journal articles (not inclusive) 4558 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4559 * @return the ordered range of matching journal articles that the user has permission to view 4560 * @throws SystemException if a system exception occurred 4561 */ 4562 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_NotL( 4563 long groupId, java.lang.String[] layoutUuids, int start, int end, 4564 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4565 throws com.liferay.portal.kernel.exception.SystemException { 4566 return getPersistence() 4567 .filterFindByG_NotL(groupId, layoutUuids, start, end, 4568 orderByComparator); 4569 } 4570 4571 /** 4572 * Returns all the journal articles where groupId = ? and layoutUuid ≠ all ?. 4573 * 4574 * <p> 4575 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4576 * </p> 4577 * 4578 * @param groupId the group ID 4579 * @param layoutUuids the layout uuids 4580 * @return the matching journal articles 4581 * @throws SystemException if a system exception occurred 4582 */ 4583 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL( 4584 long groupId, java.lang.String[] layoutUuids) 4585 throws com.liferay.portal.kernel.exception.SystemException { 4586 return getPersistence().findByG_NotL(groupId, layoutUuids); 4587 } 4588 4589 /** 4590 * Returns a range of all the journal articles where groupId = ? and layoutUuid ≠ all ?. 4591 * 4592 * <p> 4593 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4594 * </p> 4595 * 4596 * @param groupId the group ID 4597 * @param layoutUuids the layout uuids 4598 * @param start the lower bound of the range of journal articles 4599 * @param end the upper bound of the range of journal articles (not inclusive) 4600 * @return the range of matching journal articles 4601 * @throws SystemException if a system exception occurred 4602 */ 4603 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL( 4604 long groupId, java.lang.String[] layoutUuids, int start, int end) 4605 throws com.liferay.portal.kernel.exception.SystemException { 4606 return getPersistence().findByG_NotL(groupId, layoutUuids, start, end); 4607 } 4608 4609 /** 4610 * Returns an ordered range of all the journal articles where groupId = ? and layoutUuid ≠ all ?. 4611 * 4612 * <p> 4613 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4614 * </p> 4615 * 4616 * @param groupId the group ID 4617 * @param layoutUuids the layout uuids 4618 * @param start the lower bound of the range of journal articles 4619 * @param end the upper bound of the range of journal articles (not inclusive) 4620 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4621 * @return the ordered range of matching journal articles 4622 * @throws SystemException if a system exception occurred 4623 */ 4624 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_NotL( 4625 long groupId, java.lang.String[] layoutUuids, int start, int end, 4626 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4627 throws com.liferay.portal.kernel.exception.SystemException { 4628 return getPersistence() 4629 .findByG_NotL(groupId, layoutUuids, start, end, 4630 orderByComparator); 4631 } 4632 4633 /** 4634 * Removes all the journal articles where groupId = ? and layoutUuid ≠ ? from the database. 4635 * 4636 * @param groupId the group ID 4637 * @param layoutUuid the layout uuid 4638 * @throws SystemException if a system exception occurred 4639 */ 4640 public static void removeByG_NotL(long groupId, java.lang.String layoutUuid) 4641 throws com.liferay.portal.kernel.exception.SystemException { 4642 getPersistence().removeByG_NotL(groupId, layoutUuid); 4643 } 4644 4645 /** 4646 * Returns the number of journal articles where groupId = ? and layoutUuid ≠ ?. 4647 * 4648 * @param groupId the group ID 4649 * @param layoutUuid the layout uuid 4650 * @return the number of matching journal articles 4651 * @throws SystemException if a system exception occurred 4652 */ 4653 public static int countByG_NotL(long groupId, java.lang.String layoutUuid) 4654 throws com.liferay.portal.kernel.exception.SystemException { 4655 return getPersistence().countByG_NotL(groupId, layoutUuid); 4656 } 4657 4658 /** 4659 * Returns the number of journal articles where groupId = ? and layoutUuid ≠ all ?. 4660 * 4661 * @param groupId the group ID 4662 * @param layoutUuids the layout uuids 4663 * @return the number of matching journal articles 4664 * @throws SystemException if a system exception occurred 4665 */ 4666 public static int countByG_NotL(long groupId, java.lang.String[] layoutUuids) 4667 throws com.liferay.portal.kernel.exception.SystemException { 4668 return getPersistence().countByG_NotL(groupId, layoutUuids); 4669 } 4670 4671 /** 4672 * Returns the number of journal articles that the user has permission to view where groupId = ? and layoutUuid ≠ ?. 4673 * 4674 * @param groupId the group ID 4675 * @param layoutUuid the layout uuid 4676 * @return the number of matching journal articles that the user has permission to view 4677 * @throws SystemException if a system exception occurred 4678 */ 4679 public static int filterCountByG_NotL(long groupId, 4680 java.lang.String layoutUuid) 4681 throws com.liferay.portal.kernel.exception.SystemException { 4682 return getPersistence().filterCountByG_NotL(groupId, layoutUuid); 4683 } 4684 4685 /** 4686 * Returns the number of journal articles that the user has permission to view where groupId = ? and layoutUuid ≠ all ?. 4687 * 4688 * @param groupId the group ID 4689 * @param layoutUuids the layout uuids 4690 * @return the number of matching journal articles that the user has permission to view 4691 * @throws SystemException if a system exception occurred 4692 */ 4693 public static int filterCountByG_NotL(long groupId, 4694 java.lang.String[] layoutUuids) 4695 throws com.liferay.portal.kernel.exception.SystemException { 4696 return getPersistence().filterCountByG_NotL(groupId, layoutUuids); 4697 } 4698 4699 /** 4700 * Returns all the journal articles where groupId = ? and status = ?. 4701 * 4702 * @param groupId the group ID 4703 * @param status the status 4704 * @return the matching journal articles 4705 * @throws SystemException if a system exception occurred 4706 */ 4707 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4708 long groupId, int status) 4709 throws com.liferay.portal.kernel.exception.SystemException { 4710 return getPersistence().findByG_ST(groupId, status); 4711 } 4712 4713 /** 4714 * Returns a range of all the journal articles where groupId = ? and status = ?. 4715 * 4716 * <p> 4717 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4718 * </p> 4719 * 4720 * @param groupId the group ID 4721 * @param status the status 4722 * @param start the lower bound of the range of journal articles 4723 * @param end the upper bound of the range of journal articles (not inclusive) 4724 * @return the range of matching journal articles 4725 * @throws SystemException if a system exception occurred 4726 */ 4727 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4728 long groupId, int status, int start, int end) 4729 throws com.liferay.portal.kernel.exception.SystemException { 4730 return getPersistence().findByG_ST(groupId, status, start, end); 4731 } 4732 4733 /** 4734 * Returns an ordered range of all the journal articles where groupId = ? and status = ?. 4735 * 4736 * <p> 4737 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4738 * </p> 4739 * 4740 * @param groupId the group ID 4741 * @param status the status 4742 * @param start the lower bound of the range of journal articles 4743 * @param end the upper bound of the range of journal articles (not inclusive) 4744 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4745 * @return the ordered range of matching journal articles 4746 * @throws SystemException if a system exception occurred 4747 */ 4748 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_ST( 4749 long groupId, int status, int start, int end, 4750 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4751 throws com.liferay.portal.kernel.exception.SystemException { 4752 return getPersistence() 4753 .findByG_ST(groupId, status, start, end, orderByComparator); 4754 } 4755 4756 /** 4757 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4758 * 4759 * @param groupId the group ID 4760 * @param status the status 4761 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4762 * @return the first matching journal article 4763 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4764 * @throws SystemException if a system exception occurred 4765 */ 4766 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_First( 4767 long groupId, int status, 4768 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4769 throws com.liferay.portal.kernel.exception.SystemException, 4770 com.liferay.portlet.journal.NoSuchArticleException { 4771 return getPersistence() 4772 .findByG_ST_First(groupId, status, orderByComparator); 4773 } 4774 4775 /** 4776 * Returns the first journal article in the ordered set where groupId = ? and status = ?. 4777 * 4778 * @param groupId the group ID 4779 * @param status the status 4780 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4781 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 4782 * @throws SystemException if a system exception occurred 4783 */ 4784 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_First( 4785 long groupId, int status, 4786 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4787 throws com.liferay.portal.kernel.exception.SystemException { 4788 return getPersistence() 4789 .fetchByG_ST_First(groupId, status, orderByComparator); 4790 } 4791 4792 /** 4793 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4794 * 4795 * @param groupId the group ID 4796 * @param status the status 4797 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4798 * @return the last matching journal article 4799 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 4800 * @throws SystemException if a system exception occurred 4801 */ 4802 public static com.liferay.portlet.journal.model.JournalArticle findByG_ST_Last( 4803 long groupId, int status, 4804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4805 throws com.liferay.portal.kernel.exception.SystemException, 4806 com.liferay.portlet.journal.NoSuchArticleException { 4807 return getPersistence() 4808 .findByG_ST_Last(groupId, status, orderByComparator); 4809 } 4810 4811 /** 4812 * Returns the last journal article in the ordered set where groupId = ? and status = ?. 4813 * 4814 * @param groupId the group ID 4815 * @param status the status 4816 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4817 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 4818 * @throws SystemException if a system exception occurred 4819 */ 4820 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_ST_Last( 4821 long groupId, int status, 4822 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4823 throws com.liferay.portal.kernel.exception.SystemException { 4824 return getPersistence() 4825 .fetchByG_ST_Last(groupId, status, orderByComparator); 4826 } 4827 4828 /** 4829 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and status = ?. 4830 * 4831 * @param id the primary key of the current journal article 4832 * @param groupId the group ID 4833 * @param status the status 4834 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4835 * @return the previous, current, and next journal article 4836 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4837 * @throws SystemException if a system exception occurred 4838 */ 4839 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_ST_PrevAndNext( 4840 long id, long groupId, int status, 4841 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4842 throws com.liferay.portal.kernel.exception.SystemException, 4843 com.liferay.portlet.journal.NoSuchArticleException { 4844 return getPersistence() 4845 .findByG_ST_PrevAndNext(id, groupId, status, 4846 orderByComparator); 4847 } 4848 4849 /** 4850 * Returns all the journal articles that the user has permission to view where groupId = ? and status = ?. 4851 * 4852 * @param groupId the group ID 4853 * @param status the status 4854 * @return the matching journal articles that the user has permission to view 4855 * @throws SystemException if a system exception occurred 4856 */ 4857 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4858 long groupId, int status) 4859 throws com.liferay.portal.kernel.exception.SystemException { 4860 return getPersistence().filterFindByG_ST(groupId, status); 4861 } 4862 4863 /** 4864 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and status = ?. 4865 * 4866 * <p> 4867 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4868 * </p> 4869 * 4870 * @param groupId the group ID 4871 * @param status the status 4872 * @param start the lower bound of the range of journal articles 4873 * @param end the upper bound of the range of journal articles (not inclusive) 4874 * @return the range of matching journal articles that the user has permission to view 4875 * @throws SystemException if a system exception occurred 4876 */ 4877 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4878 long groupId, int status, int start, int end) 4879 throws com.liferay.portal.kernel.exception.SystemException { 4880 return getPersistence().filterFindByG_ST(groupId, status, start, end); 4881 } 4882 4883 /** 4884 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and status = ?. 4885 * 4886 * <p> 4887 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4888 * </p> 4889 * 4890 * @param groupId the group ID 4891 * @param status the status 4892 * @param start the lower bound of the range of journal articles 4893 * @param end the upper bound of the range of journal articles (not inclusive) 4894 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4895 * @return the ordered range of matching journal articles that the user has permission to view 4896 * @throws SystemException if a system exception occurred 4897 */ 4898 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_ST( 4899 long groupId, int status, int start, int end, 4900 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4901 throws com.liferay.portal.kernel.exception.SystemException { 4902 return getPersistence() 4903 .filterFindByG_ST(groupId, status, start, end, 4904 orderByComparator); 4905 } 4906 4907 /** 4908 * 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 = ?. 4909 * 4910 * @param id the primary key of the current journal article 4911 * @param groupId the group ID 4912 * @param status the status 4913 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4914 * @return the previous, current, and next journal article 4915 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 4916 * @throws SystemException if a system exception occurred 4917 */ 4918 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_ST_PrevAndNext( 4919 long id, long groupId, int status, 4920 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 4921 throws com.liferay.portal.kernel.exception.SystemException, 4922 com.liferay.portlet.journal.NoSuchArticleException { 4923 return getPersistence() 4924 .filterFindByG_ST_PrevAndNext(id, groupId, status, 4925 orderByComparator); 4926 } 4927 4928 /** 4929 * Removes all the journal articles where groupId = ? and status = ? from the database. 4930 * 4931 * @param groupId the group ID 4932 * @param status the status 4933 * @throws SystemException if a system exception occurred 4934 */ 4935 public static void removeByG_ST(long groupId, int status) 4936 throws com.liferay.portal.kernel.exception.SystemException { 4937 getPersistence().removeByG_ST(groupId, status); 4938 } 4939 4940 /** 4941 * Returns the number of journal articles where groupId = ? and status = ?. 4942 * 4943 * @param groupId the group ID 4944 * @param status the status 4945 * @return the number of matching journal articles 4946 * @throws SystemException if a system exception occurred 4947 */ 4948 public static int countByG_ST(long groupId, int status) 4949 throws com.liferay.portal.kernel.exception.SystemException { 4950 return getPersistence().countByG_ST(groupId, status); 4951 } 4952 4953 /** 4954 * Returns the number of journal articles that the user has permission to view where groupId = ? and status = ?. 4955 * 4956 * @param groupId the group ID 4957 * @param status the status 4958 * @return the number of matching journal articles that the user has permission to view 4959 * @throws SystemException if a system exception occurred 4960 */ 4961 public static int filterCountByG_ST(long groupId, int status) 4962 throws com.liferay.portal.kernel.exception.SystemException { 4963 return getPersistence().filterCountByG_ST(groupId, status); 4964 } 4965 4966 /** 4967 * Returns all the journal articles where companyId = ? and version = ?. 4968 * 4969 * @param companyId the company ID 4970 * @param version the version 4971 * @return the matching journal articles 4972 * @throws SystemException if a system exception occurred 4973 */ 4974 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4975 long companyId, double version) 4976 throws com.liferay.portal.kernel.exception.SystemException { 4977 return getPersistence().findByC_V(companyId, version); 4978 } 4979 4980 /** 4981 * Returns a range of all the journal articles where companyId = ? and version = ?. 4982 * 4983 * <p> 4984 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4985 * </p> 4986 * 4987 * @param companyId the company ID 4988 * @param version the version 4989 * @param start the lower bound of the range of journal articles 4990 * @param end the upper bound of the range of journal articles (not inclusive) 4991 * @return the range of matching journal articles 4992 * @throws SystemException if a system exception occurred 4993 */ 4994 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 4995 long companyId, double version, int start, int end) 4996 throws com.liferay.portal.kernel.exception.SystemException { 4997 return getPersistence().findByC_V(companyId, version, start, end); 4998 } 4999 5000 /** 5001 * Returns an ordered range of all the journal articles where companyId = ? and version = ?. 5002 * 5003 * <p> 5004 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5005 * </p> 5006 * 5007 * @param companyId the company ID 5008 * @param version the version 5009 * @param start the lower bound of the range of journal articles 5010 * @param end the upper bound of the range of journal articles (not inclusive) 5011 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5012 * @return the ordered range of matching journal articles 5013 * @throws SystemException if a system exception occurred 5014 */ 5015 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V( 5016 long companyId, double version, int start, int end, 5017 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5018 throws com.liferay.portal.kernel.exception.SystemException { 5019 return getPersistence() 5020 .findByC_V(companyId, version, start, end, orderByComparator); 5021 } 5022 5023 /** 5024 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 5025 * 5026 * @param companyId the company ID 5027 * @param version the version 5028 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5029 * @return the first matching journal article 5030 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5031 * @throws SystemException if a system exception occurred 5032 */ 5033 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_First( 5034 long companyId, double version, 5035 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5036 throws com.liferay.portal.kernel.exception.SystemException, 5037 com.liferay.portlet.journal.NoSuchArticleException { 5038 return getPersistence() 5039 .findByC_V_First(companyId, version, orderByComparator); 5040 } 5041 5042 /** 5043 * Returns the first journal article in the ordered set where companyId = ? and version = ?. 5044 * 5045 * @param companyId the company ID 5046 * @param version the version 5047 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5048 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5049 * @throws SystemException if a system exception occurred 5050 */ 5051 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_First( 5052 long companyId, double version, 5053 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5054 throws com.liferay.portal.kernel.exception.SystemException { 5055 return getPersistence() 5056 .fetchByC_V_First(companyId, version, orderByComparator); 5057 } 5058 5059 /** 5060 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 5061 * 5062 * @param companyId the company ID 5063 * @param version the version 5064 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5065 * @return the last matching journal article 5066 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5067 * @throws SystemException if a system exception occurred 5068 */ 5069 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_Last( 5070 long companyId, double version, 5071 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5072 throws com.liferay.portal.kernel.exception.SystemException, 5073 com.liferay.portlet.journal.NoSuchArticleException { 5074 return getPersistence() 5075 .findByC_V_Last(companyId, version, orderByComparator); 5076 } 5077 5078 /** 5079 * Returns the last journal article in the ordered set where companyId = ? and version = ?. 5080 * 5081 * @param companyId the company ID 5082 * @param version the version 5083 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5084 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5085 * @throws SystemException if a system exception occurred 5086 */ 5087 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_Last( 5088 long companyId, double version, 5089 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5090 throws com.liferay.portal.kernel.exception.SystemException { 5091 return getPersistence() 5092 .fetchByC_V_Last(companyId, version, orderByComparator); 5093 } 5094 5095 /** 5096 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ?. 5097 * 5098 * @param id the primary key of the current journal article 5099 * @param companyId the company ID 5100 * @param version the version 5101 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5102 * @return the previous, current, and next journal article 5103 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5104 * @throws SystemException if a system exception occurred 5105 */ 5106 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_PrevAndNext( 5107 long id, long companyId, double version, 5108 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5109 throws com.liferay.portal.kernel.exception.SystemException, 5110 com.liferay.portlet.journal.NoSuchArticleException { 5111 return getPersistence() 5112 .findByC_V_PrevAndNext(id, companyId, version, 5113 orderByComparator); 5114 } 5115 5116 /** 5117 * Removes all the journal articles where companyId = ? and version = ? from the database. 5118 * 5119 * @param companyId the company ID 5120 * @param version the version 5121 * @throws SystemException if a system exception occurred 5122 */ 5123 public static void removeByC_V(long companyId, double version) 5124 throws com.liferay.portal.kernel.exception.SystemException { 5125 getPersistence().removeByC_V(companyId, version); 5126 } 5127 5128 /** 5129 * Returns the number of journal articles where companyId = ? and version = ?. 5130 * 5131 * @param companyId the company ID 5132 * @param version the version 5133 * @return the number of matching journal articles 5134 * @throws SystemException if a system exception occurred 5135 */ 5136 public static int countByC_V(long companyId, double version) 5137 throws com.liferay.portal.kernel.exception.SystemException { 5138 return getPersistence().countByC_V(companyId, version); 5139 } 5140 5141 /** 5142 * Returns all the journal articles where companyId = ? and status = ?. 5143 * 5144 * @param companyId the company ID 5145 * @param status the status 5146 * @return the matching journal articles 5147 * @throws SystemException if a system exception occurred 5148 */ 5149 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 5150 long companyId, int status) 5151 throws com.liferay.portal.kernel.exception.SystemException { 5152 return getPersistence().findByC_ST(companyId, status); 5153 } 5154 5155 /** 5156 * Returns a range of all the journal articles where companyId = ? and status = ?. 5157 * 5158 * <p> 5159 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5160 * </p> 5161 * 5162 * @param companyId the company ID 5163 * @param status the status 5164 * @param start the lower bound of the range of journal articles 5165 * @param end the upper bound of the range of journal articles (not inclusive) 5166 * @return the range of matching journal articles 5167 * @throws SystemException if a system exception occurred 5168 */ 5169 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 5170 long companyId, int status, int start, int end) 5171 throws com.liferay.portal.kernel.exception.SystemException { 5172 return getPersistence().findByC_ST(companyId, status, start, end); 5173 } 5174 5175 /** 5176 * Returns an ordered range of all the journal articles where companyId = ? and status = ?. 5177 * 5178 * <p> 5179 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5180 * </p> 5181 * 5182 * @param companyId the company ID 5183 * @param status the status 5184 * @param start the lower bound of the range of journal articles 5185 * @param end the upper bound of the range of journal articles (not inclusive) 5186 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5187 * @return the ordered range of matching journal articles 5188 * @throws SystemException if a system exception occurred 5189 */ 5190 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_ST( 5191 long companyId, int status, int start, int end, 5192 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5193 throws com.liferay.portal.kernel.exception.SystemException { 5194 return getPersistence() 5195 .findByC_ST(companyId, status, start, end, orderByComparator); 5196 } 5197 5198 /** 5199 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 5200 * 5201 * @param companyId the company ID 5202 * @param status the status 5203 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5204 * @return the first matching journal article 5205 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5206 * @throws SystemException if a system exception occurred 5207 */ 5208 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_First( 5209 long companyId, int status, 5210 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5211 throws com.liferay.portal.kernel.exception.SystemException, 5212 com.liferay.portlet.journal.NoSuchArticleException { 5213 return getPersistence() 5214 .findByC_ST_First(companyId, status, orderByComparator); 5215 } 5216 5217 /** 5218 * Returns the first journal article in the ordered set where companyId = ? and status = ?. 5219 * 5220 * @param companyId the company ID 5221 * @param status the status 5222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5223 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5224 * @throws SystemException if a system exception occurred 5225 */ 5226 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_First( 5227 long companyId, int status, 5228 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5229 throws com.liferay.portal.kernel.exception.SystemException { 5230 return getPersistence() 5231 .fetchByC_ST_First(companyId, status, orderByComparator); 5232 } 5233 5234 /** 5235 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 5236 * 5237 * @param companyId the company ID 5238 * @param status the status 5239 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5240 * @return the last matching journal article 5241 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5242 * @throws SystemException if a system exception occurred 5243 */ 5244 public static com.liferay.portlet.journal.model.JournalArticle findByC_ST_Last( 5245 long companyId, int status, 5246 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5247 throws com.liferay.portal.kernel.exception.SystemException, 5248 com.liferay.portlet.journal.NoSuchArticleException { 5249 return getPersistence() 5250 .findByC_ST_Last(companyId, status, orderByComparator); 5251 } 5252 5253 /** 5254 * Returns the last journal article in the ordered set where companyId = ? and status = ?. 5255 * 5256 * @param companyId the company ID 5257 * @param status the status 5258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5259 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5260 * @throws SystemException if a system exception occurred 5261 */ 5262 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_ST_Last( 5263 long companyId, int status, 5264 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5265 throws com.liferay.portal.kernel.exception.SystemException { 5266 return getPersistence() 5267 .fetchByC_ST_Last(companyId, status, orderByComparator); 5268 } 5269 5270 /** 5271 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status = ?. 5272 * 5273 * @param id the primary key of the current journal article 5274 * @param companyId the company ID 5275 * @param status the status 5276 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5277 * @return the previous, current, and next journal article 5278 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5279 * @throws SystemException if a system exception occurred 5280 */ 5281 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_ST_PrevAndNext( 5282 long id, long companyId, int status, 5283 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5284 throws com.liferay.portal.kernel.exception.SystemException, 5285 com.liferay.portlet.journal.NoSuchArticleException { 5286 return getPersistence() 5287 .findByC_ST_PrevAndNext(id, companyId, status, 5288 orderByComparator); 5289 } 5290 5291 /** 5292 * Removes all the journal articles where companyId = ? and status = ? from the database. 5293 * 5294 * @param companyId the company ID 5295 * @param status the status 5296 * @throws SystemException if a system exception occurred 5297 */ 5298 public static void removeByC_ST(long companyId, int status) 5299 throws com.liferay.portal.kernel.exception.SystemException { 5300 getPersistence().removeByC_ST(companyId, status); 5301 } 5302 5303 /** 5304 * Returns the number of journal articles where companyId = ? and status = ?. 5305 * 5306 * @param companyId the company ID 5307 * @param status the status 5308 * @return the number of matching journal articles 5309 * @throws SystemException if a system exception occurred 5310 */ 5311 public static int countByC_ST(long companyId, int status) 5312 throws com.liferay.portal.kernel.exception.SystemException { 5313 return getPersistence().countByC_ST(companyId, status); 5314 } 5315 5316 /** 5317 * Returns all the journal articles where companyId = ? and status ≠ ?. 5318 * 5319 * @param companyId the company ID 5320 * @param status the status 5321 * @return the matching journal articles 5322 * @throws SystemException if a system exception occurred 5323 */ 5324 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 5325 long companyId, int status) 5326 throws com.liferay.portal.kernel.exception.SystemException { 5327 return getPersistence().findByC_NotST(companyId, status); 5328 } 5329 5330 /** 5331 * Returns a range of all the journal articles where companyId = ? and status ≠ ?. 5332 * 5333 * <p> 5334 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5335 * </p> 5336 * 5337 * @param companyId the company ID 5338 * @param status the status 5339 * @param start the lower bound of the range of journal articles 5340 * @param end the upper bound of the range of journal articles (not inclusive) 5341 * @return the range of matching journal articles 5342 * @throws SystemException if a system exception occurred 5343 */ 5344 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 5345 long companyId, int status, int start, int end) 5346 throws com.liferay.portal.kernel.exception.SystemException { 5347 return getPersistence().findByC_NotST(companyId, status, start, end); 5348 } 5349 5350 /** 5351 * Returns an ordered range of all the journal articles where companyId = ? and status ≠ ?. 5352 * 5353 * <p> 5354 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5355 * </p> 5356 * 5357 * @param companyId the company ID 5358 * @param status the status 5359 * @param start the lower bound of the range of journal articles 5360 * @param end the upper bound of the range of journal articles (not inclusive) 5361 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5362 * @return the ordered range of matching journal articles 5363 * @throws SystemException if a system exception occurred 5364 */ 5365 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_NotST( 5366 long companyId, int status, int start, int end, 5367 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5368 throws com.liferay.portal.kernel.exception.SystemException { 5369 return getPersistence() 5370 .findByC_NotST(companyId, status, start, end, 5371 orderByComparator); 5372 } 5373 5374 /** 5375 * Returns the first journal article in the ordered set where companyId = ? and status ≠ ?. 5376 * 5377 * @param companyId the company ID 5378 * @param status the status 5379 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5380 * @return the first matching journal article 5381 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5382 * @throws SystemException if a system exception occurred 5383 */ 5384 public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_First( 5385 long companyId, int status, 5386 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5387 throws com.liferay.portal.kernel.exception.SystemException, 5388 com.liferay.portlet.journal.NoSuchArticleException { 5389 return getPersistence() 5390 .findByC_NotST_First(companyId, status, orderByComparator); 5391 } 5392 5393 /** 5394 * Returns the first journal article in the ordered set where companyId = ? and status ≠ ?. 5395 * 5396 * @param companyId the company ID 5397 * @param status the status 5398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5399 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5400 * @throws SystemException if a system exception occurred 5401 */ 5402 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_NotST_First( 5403 long companyId, int status, 5404 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5405 throws com.liferay.portal.kernel.exception.SystemException { 5406 return getPersistence() 5407 .fetchByC_NotST_First(companyId, status, orderByComparator); 5408 } 5409 5410 /** 5411 * Returns the last journal article in the ordered set where companyId = ? and status ≠ ?. 5412 * 5413 * @param companyId the company ID 5414 * @param status the status 5415 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5416 * @return the last matching journal article 5417 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5418 * @throws SystemException if a system exception occurred 5419 */ 5420 public static com.liferay.portlet.journal.model.JournalArticle findByC_NotST_Last( 5421 long companyId, int status, 5422 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5423 throws com.liferay.portal.kernel.exception.SystemException, 5424 com.liferay.portlet.journal.NoSuchArticleException { 5425 return getPersistence() 5426 .findByC_NotST_Last(companyId, status, orderByComparator); 5427 } 5428 5429 /** 5430 * Returns the last journal article in the ordered set where companyId = ? and status ≠ ?. 5431 * 5432 * @param companyId the company ID 5433 * @param status the status 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 fetchByC_NotST_Last( 5439 long companyId, int status, 5440 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5441 throws com.liferay.portal.kernel.exception.SystemException { 5442 return getPersistence() 5443 .fetchByC_NotST_Last(companyId, status, orderByComparator); 5444 } 5445 5446 /** 5447 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and status ≠ ?. 5448 * 5449 * @param id the primary key of the current journal article 5450 * @param companyId the company ID 5451 * @param status the status 5452 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5453 * @return the previous, current, and next journal article 5454 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5455 * @throws SystemException if a system exception occurred 5456 */ 5457 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_NotST_PrevAndNext( 5458 long id, long companyId, int status, 5459 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5460 throws com.liferay.portal.kernel.exception.SystemException, 5461 com.liferay.portlet.journal.NoSuchArticleException { 5462 return getPersistence() 5463 .findByC_NotST_PrevAndNext(id, companyId, status, 5464 orderByComparator); 5465 } 5466 5467 /** 5468 * Removes all the journal articles where companyId = ? and status ≠ ? from the database. 5469 * 5470 * @param companyId the company ID 5471 * @param status the status 5472 * @throws SystemException if a system exception occurred 5473 */ 5474 public static void removeByC_NotST(long companyId, int status) 5475 throws com.liferay.portal.kernel.exception.SystemException { 5476 getPersistence().removeByC_NotST(companyId, status); 5477 } 5478 5479 /** 5480 * Returns the number of journal articles where companyId = ? and status ≠ ?. 5481 * 5482 * @param companyId the company ID 5483 * @param status the status 5484 * @return the number of matching journal articles 5485 * @throws SystemException if a system exception occurred 5486 */ 5487 public static int countByC_NotST(long companyId, int status) 5488 throws com.liferay.portal.kernel.exception.SystemException { 5489 return getPersistence().countByC_NotST(companyId, status); 5490 } 5491 5492 /** 5493 * Returns all the journal articles where classNameId = ? and templateId = ?. 5494 * 5495 * @param classNameId the class name ID 5496 * @param templateId the template ID 5497 * @return the matching journal articles 5498 * @throws SystemException if a system exception occurred 5499 */ 5500 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T( 5501 long classNameId, java.lang.String templateId) 5502 throws com.liferay.portal.kernel.exception.SystemException { 5503 return getPersistence().findByC_T(classNameId, templateId); 5504 } 5505 5506 /** 5507 * Returns a range of all the journal articles where classNameId = ? and templateId = ?. 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 classNameId the class name ID 5514 * @param templateId the template ID 5515 * @param start the lower bound of the range of journal articles 5516 * @param end the upper bound of the range of journal articles (not inclusive) 5517 * @return the range of matching journal articles 5518 * @throws SystemException if a system exception occurred 5519 */ 5520 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T( 5521 long classNameId, java.lang.String templateId, int start, int end) 5522 throws com.liferay.portal.kernel.exception.SystemException { 5523 return getPersistence().findByC_T(classNameId, templateId, start, end); 5524 } 5525 5526 /** 5527 * Returns an ordered range of all the journal articles where classNameId = ? and templateId = ?. 5528 * 5529 * <p> 5530 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5531 * </p> 5532 * 5533 * @param classNameId the class name ID 5534 * @param templateId the template ID 5535 * @param start the lower bound of the range of journal articles 5536 * @param end the upper bound of the range of journal articles (not inclusive) 5537 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5538 * @return the ordered range of matching journal articles 5539 * @throws SystemException if a system exception occurred 5540 */ 5541 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_T( 5542 long classNameId, java.lang.String templateId, int start, int end, 5543 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5544 throws com.liferay.portal.kernel.exception.SystemException { 5545 return getPersistence() 5546 .findByC_T(classNameId, templateId, start, end, 5547 orderByComparator); 5548 } 5549 5550 /** 5551 * Returns the first journal article in the ordered set where classNameId = ? and templateId = ?. 5552 * 5553 * @param classNameId the class name ID 5554 * @param templateId the template ID 5555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5556 * @return the first matching journal article 5557 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5558 * @throws SystemException if a system exception occurred 5559 */ 5560 public static com.liferay.portlet.journal.model.JournalArticle findByC_T_First( 5561 long classNameId, java.lang.String templateId, 5562 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5563 throws com.liferay.portal.kernel.exception.SystemException, 5564 com.liferay.portlet.journal.NoSuchArticleException { 5565 return getPersistence() 5566 .findByC_T_First(classNameId, templateId, orderByComparator); 5567 } 5568 5569 /** 5570 * Returns the first journal article in the ordered set where classNameId = ? and templateId = ?. 5571 * 5572 * @param classNameId the class name ID 5573 * @param templateId the template ID 5574 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5575 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5576 * @throws SystemException if a system exception occurred 5577 */ 5578 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_T_First( 5579 long classNameId, java.lang.String templateId, 5580 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5581 throws com.liferay.portal.kernel.exception.SystemException { 5582 return getPersistence() 5583 .fetchByC_T_First(classNameId, templateId, orderByComparator); 5584 } 5585 5586 /** 5587 * Returns the last journal article in the ordered set where classNameId = ? and templateId = ?. 5588 * 5589 * @param classNameId the class name ID 5590 * @param templateId the template ID 5591 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5592 * @return the last matching journal article 5593 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5594 * @throws SystemException if a system exception occurred 5595 */ 5596 public static com.liferay.portlet.journal.model.JournalArticle findByC_T_Last( 5597 long classNameId, java.lang.String templateId, 5598 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5599 throws com.liferay.portal.kernel.exception.SystemException, 5600 com.liferay.portlet.journal.NoSuchArticleException { 5601 return getPersistence() 5602 .findByC_T_Last(classNameId, templateId, orderByComparator); 5603 } 5604 5605 /** 5606 * Returns the last journal article in the ordered set where classNameId = ? and templateId = ?. 5607 * 5608 * @param classNameId the class name ID 5609 * @param templateId the template ID 5610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5611 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5612 * @throws SystemException if a system exception occurred 5613 */ 5614 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_T_Last( 5615 long classNameId, java.lang.String templateId, 5616 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5617 throws com.liferay.portal.kernel.exception.SystemException { 5618 return getPersistence() 5619 .fetchByC_T_Last(classNameId, templateId, orderByComparator); 5620 } 5621 5622 /** 5623 * Returns the journal articles before and after the current journal article in the ordered set where classNameId = ? and templateId = ?. 5624 * 5625 * @param id the primary key of the current journal article 5626 * @param classNameId the class name ID 5627 * @param templateId the template ID 5628 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5629 * @return the previous, current, and next journal article 5630 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5631 * @throws SystemException if a system exception occurred 5632 */ 5633 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_T_PrevAndNext( 5634 long id, long classNameId, java.lang.String templateId, 5635 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5636 throws com.liferay.portal.kernel.exception.SystemException, 5637 com.liferay.portlet.journal.NoSuchArticleException { 5638 return getPersistence() 5639 .findByC_T_PrevAndNext(id, classNameId, templateId, 5640 orderByComparator); 5641 } 5642 5643 /** 5644 * Removes all the journal articles where classNameId = ? and templateId = ? from the database. 5645 * 5646 * @param classNameId the class name ID 5647 * @param templateId the template ID 5648 * @throws SystemException if a system exception occurred 5649 */ 5650 public static void removeByC_T(long classNameId, java.lang.String templateId) 5651 throws com.liferay.portal.kernel.exception.SystemException { 5652 getPersistence().removeByC_T(classNameId, templateId); 5653 } 5654 5655 /** 5656 * Returns the number of journal articles where classNameId = ? and templateId = ?. 5657 * 5658 * @param classNameId the class name ID 5659 * @param templateId the template ID 5660 * @return the number of matching journal articles 5661 * @throws SystemException if a system exception occurred 5662 */ 5663 public static int countByC_T(long classNameId, java.lang.String templateId) 5664 throws com.liferay.portal.kernel.exception.SystemException { 5665 return getPersistence().countByC_T(classNameId, templateId); 5666 } 5667 5668 /** 5669 * Returns all the journal articles where displayDate < ? and status = ?. 5670 * 5671 * @param displayDate the display date 5672 * @param status the status 5673 * @return the matching journal articles 5674 * @throws SystemException if a system exception occurred 5675 */ 5676 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5677 java.util.Date displayDate, int status) 5678 throws com.liferay.portal.kernel.exception.SystemException { 5679 return getPersistence().findByLtD_S(displayDate, status); 5680 } 5681 5682 /** 5683 * Returns a range of all the journal articles where displayDate < ? and status = ?. 5684 * 5685 * <p> 5686 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5687 * </p> 5688 * 5689 * @param displayDate the display date 5690 * @param status the status 5691 * @param start the lower bound of the range of journal articles 5692 * @param end the upper bound of the range of journal articles (not inclusive) 5693 * @return the range of matching journal articles 5694 * @throws SystemException if a system exception occurred 5695 */ 5696 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5697 java.util.Date displayDate, int status, int start, int end) 5698 throws com.liferay.portal.kernel.exception.SystemException { 5699 return getPersistence().findByLtD_S(displayDate, status, start, end); 5700 } 5701 5702 /** 5703 * Returns an ordered range of all the journal articles where displayDate < ? and status = ?. 5704 * 5705 * <p> 5706 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5707 * </p> 5708 * 5709 * @param displayDate the display date 5710 * @param status the status 5711 * @param start the lower bound of the range of journal articles 5712 * @param end the upper bound of the range of journal articles (not inclusive) 5713 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5714 * @return the ordered range of matching journal articles 5715 * @throws SystemException if a system exception occurred 5716 */ 5717 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByLtD_S( 5718 java.util.Date displayDate, int status, int start, int end, 5719 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5720 throws com.liferay.portal.kernel.exception.SystemException { 5721 return getPersistence() 5722 .findByLtD_S(displayDate, status, start, end, 5723 orderByComparator); 5724 } 5725 5726 /** 5727 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 5728 * 5729 * @param displayDate the display date 5730 * @param status the status 5731 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5732 * @return the first matching journal article 5733 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5734 * @throws SystemException if a system exception occurred 5735 */ 5736 public static com.liferay.portlet.journal.model.JournalArticle findByLtD_S_First( 5737 java.util.Date displayDate, int status, 5738 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5739 throws com.liferay.portal.kernel.exception.SystemException, 5740 com.liferay.portlet.journal.NoSuchArticleException { 5741 return getPersistence() 5742 .findByLtD_S_First(displayDate, status, orderByComparator); 5743 } 5744 5745 /** 5746 * Returns the first journal article in the ordered set where displayDate < ? and status = ?. 5747 * 5748 * @param displayDate the display date 5749 * @param status the status 5750 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5751 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5752 * @throws SystemException if a system exception occurred 5753 */ 5754 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_First( 5755 java.util.Date displayDate, int status, 5756 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5757 throws com.liferay.portal.kernel.exception.SystemException { 5758 return getPersistence() 5759 .fetchByLtD_S_First(displayDate, status, orderByComparator); 5760 } 5761 5762 /** 5763 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 5764 * 5765 * @param displayDate the display date 5766 * @param status the status 5767 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5768 * @return the last matching journal article 5769 * @throws com.liferay.portlet.journal.NoSuchArticleException 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 findByLtD_S_Last( 5773 java.util.Date displayDate, int status, 5774 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5775 throws com.liferay.portal.kernel.exception.SystemException, 5776 com.liferay.portlet.journal.NoSuchArticleException { 5777 return getPersistence() 5778 .findByLtD_S_Last(displayDate, status, orderByComparator); 5779 } 5780 5781 /** 5782 * Returns the last journal article in the ordered set where displayDate < ? and status = ?. 5783 * 5784 * @param displayDate the display date 5785 * @param status the status 5786 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5787 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5788 * @throws SystemException if a system exception occurred 5789 */ 5790 public static com.liferay.portlet.journal.model.JournalArticle fetchByLtD_S_Last( 5791 java.util.Date displayDate, int status, 5792 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5793 throws com.liferay.portal.kernel.exception.SystemException { 5794 return getPersistence() 5795 .fetchByLtD_S_Last(displayDate, status, orderByComparator); 5796 } 5797 5798 /** 5799 * Returns the journal articles before and after the current journal article in the ordered set where displayDate < ? and status = ?. 5800 * 5801 * @param id the primary key of the current journal article 5802 * @param displayDate the display date 5803 * @param status the status 5804 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5805 * @return the previous, current, and next journal article 5806 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5807 * @throws SystemException if a system exception occurred 5808 */ 5809 public static com.liferay.portlet.journal.model.JournalArticle[] findByLtD_S_PrevAndNext( 5810 long id, java.util.Date displayDate, int status, 5811 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5812 throws com.liferay.portal.kernel.exception.SystemException, 5813 com.liferay.portlet.journal.NoSuchArticleException { 5814 return getPersistence() 5815 .findByLtD_S_PrevAndNext(id, displayDate, status, 5816 orderByComparator); 5817 } 5818 5819 /** 5820 * Removes all the journal articles where displayDate < ? and status = ? from the database. 5821 * 5822 * @param displayDate the display date 5823 * @param status the status 5824 * @throws SystemException if a system exception occurred 5825 */ 5826 public static void removeByLtD_S(java.util.Date displayDate, int status) 5827 throws com.liferay.portal.kernel.exception.SystemException { 5828 getPersistence().removeByLtD_S(displayDate, status); 5829 } 5830 5831 /** 5832 * Returns the number of journal articles where displayDate < ? and status = ?. 5833 * 5834 * @param displayDate the display date 5835 * @param status the status 5836 * @return the number of matching journal articles 5837 * @throws SystemException if a system exception occurred 5838 */ 5839 public static int countByLtD_S(java.util.Date displayDate, int status) 5840 throws com.liferay.portal.kernel.exception.SystemException { 5841 return getPersistence().countByLtD_S(displayDate, status); 5842 } 5843 5844 /** 5845 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5846 * 5847 * @param resourcePrimKey the resource prim key 5848 * @param indexable the indexable 5849 * @param status the status 5850 * @return the matching journal articles 5851 * @throws SystemException if a system exception occurred 5852 */ 5853 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5854 long resourcePrimKey, boolean indexable, int status) 5855 throws com.liferay.portal.kernel.exception.SystemException { 5856 return getPersistence().findByR_I_S(resourcePrimKey, indexable, status); 5857 } 5858 5859 /** 5860 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 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 resourcePrimKey the resource prim key 5867 * @param indexable the indexable 5868 * @param status the status 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 5872 * @throws SystemException if a system exception occurred 5873 */ 5874 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5875 long resourcePrimKey, boolean indexable, int status, int start, int end) 5876 throws com.liferay.portal.kernel.exception.SystemException { 5877 return getPersistence() 5878 .findByR_I_S(resourcePrimKey, indexable, status, start, end); 5879 } 5880 5881 /** 5882 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 5883 * 5884 * <p> 5885 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5886 * </p> 5887 * 5888 * @param resourcePrimKey the resource prim key 5889 * @param indexable the indexable 5890 * @param status the status 5891 * @param start the lower bound of the range of journal articles 5892 * @param end the upper bound of the range of journal articles (not inclusive) 5893 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5894 * @return the ordered range of matching journal articles 5895 * @throws SystemException if a system exception occurred 5896 */ 5897 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 5898 long resourcePrimKey, boolean indexable, int status, int start, 5899 int end, 5900 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5901 throws com.liferay.portal.kernel.exception.SystemException { 5902 return getPersistence() 5903 .findByR_I_S(resourcePrimKey, indexable, status, start, end, 5904 orderByComparator); 5905 } 5906 5907 /** 5908 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5909 * 5910 * @param resourcePrimKey the resource prim key 5911 * @param indexable the indexable 5912 * @param status the status 5913 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5914 * @return the first matching journal article 5915 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5916 * @throws SystemException if a system exception occurred 5917 */ 5918 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_First( 5919 long resourcePrimKey, boolean indexable, int status, 5920 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5921 throws com.liferay.portal.kernel.exception.SystemException, 5922 com.liferay.portlet.journal.NoSuchArticleException { 5923 return getPersistence() 5924 .findByR_I_S_First(resourcePrimKey, indexable, status, 5925 orderByComparator); 5926 } 5927 5928 /** 5929 * Returns the first journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5930 * 5931 * @param resourcePrimKey the resource prim key 5932 * @param indexable the indexable 5933 * @param status the status 5934 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5935 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 5936 * @throws SystemException if a system exception occurred 5937 */ 5938 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_First( 5939 long resourcePrimKey, boolean indexable, int status, 5940 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5941 throws com.liferay.portal.kernel.exception.SystemException { 5942 return getPersistence() 5943 .fetchByR_I_S_First(resourcePrimKey, indexable, status, 5944 orderByComparator); 5945 } 5946 5947 /** 5948 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5949 * 5950 * @param resourcePrimKey the resource prim key 5951 * @param indexable the indexable 5952 * @param status the status 5953 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5954 * @return the last matching journal article 5955 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 5956 * @throws SystemException if a system exception occurred 5957 */ 5958 public static com.liferay.portlet.journal.model.JournalArticle findByR_I_S_Last( 5959 long resourcePrimKey, boolean indexable, int status, 5960 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5961 throws com.liferay.portal.kernel.exception.SystemException, 5962 com.liferay.portlet.journal.NoSuchArticleException { 5963 return getPersistence() 5964 .findByR_I_S_Last(resourcePrimKey, indexable, status, 5965 orderByComparator); 5966 } 5967 5968 /** 5969 * Returns the last journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5970 * 5971 * @param resourcePrimKey the resource prim key 5972 * @param indexable the indexable 5973 * @param status the status 5974 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5975 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 5976 * @throws SystemException if a system exception occurred 5977 */ 5978 public static com.liferay.portlet.journal.model.JournalArticle fetchByR_I_S_Last( 5979 long resourcePrimKey, boolean indexable, int status, 5980 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 5981 throws com.liferay.portal.kernel.exception.SystemException { 5982 return getPersistence() 5983 .fetchByR_I_S_Last(resourcePrimKey, indexable, status, 5984 orderByComparator); 5985 } 5986 5987 /** 5988 * Returns the journal articles before and after the current journal article in the ordered set where resourcePrimKey = ? and indexable = ? and status = ?. 5989 * 5990 * @param id the primary key of the current journal article 5991 * @param resourcePrimKey the resource prim key 5992 * @param indexable the indexable 5993 * @param status the status 5994 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5995 * @return the previous, current, and next journal article 5996 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 5997 * @throws SystemException if a system exception occurred 5998 */ 5999 public static com.liferay.portlet.journal.model.JournalArticle[] findByR_I_S_PrevAndNext( 6000 long id, long resourcePrimKey, boolean indexable, int status, 6001 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6002 throws com.liferay.portal.kernel.exception.SystemException, 6003 com.liferay.portlet.journal.NoSuchArticleException { 6004 return getPersistence() 6005 .findByR_I_S_PrevAndNext(id, resourcePrimKey, indexable, 6006 status, orderByComparator); 6007 } 6008 6009 /** 6010 * Returns all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 6011 * 6012 * <p> 6013 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6014 * </p> 6015 * 6016 * @param resourcePrimKey the resource prim key 6017 * @param indexable the indexable 6018 * @param statuses the statuses 6019 * @return the matching journal articles 6020 * @throws SystemException if a system exception occurred 6021 */ 6022 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 6023 long resourcePrimKey, boolean indexable, int[] statuses) 6024 throws com.liferay.portal.kernel.exception.SystemException { 6025 return getPersistence().findByR_I_S(resourcePrimKey, indexable, statuses); 6026 } 6027 6028 /** 6029 * Returns a range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 6030 * 6031 * <p> 6032 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6033 * </p> 6034 * 6035 * @param resourcePrimKey the resource prim key 6036 * @param indexable the indexable 6037 * @param statuses the statuses 6038 * @param start the lower bound of the range of journal articles 6039 * @param end the upper bound of the range of journal articles (not inclusive) 6040 * @return the range of matching journal articles 6041 * @throws SystemException if a system exception occurred 6042 */ 6043 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 6044 long resourcePrimKey, boolean indexable, int[] statuses, int start, 6045 int end) throws com.liferay.portal.kernel.exception.SystemException { 6046 return getPersistence() 6047 .findByR_I_S(resourcePrimKey, indexable, statuses, start, end); 6048 } 6049 6050 /** 6051 * Returns an ordered range of all the journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 6052 * 6053 * <p> 6054 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6055 * </p> 6056 * 6057 * @param resourcePrimKey the resource prim key 6058 * @param indexable the indexable 6059 * @param statuses the statuses 6060 * @param start the lower bound of the range of journal articles 6061 * @param end the upper bound of the range of journal articles (not inclusive) 6062 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6063 * @return the ordered range of matching journal articles 6064 * @throws SystemException if a system exception occurred 6065 */ 6066 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByR_I_S( 6067 long resourcePrimKey, boolean indexable, int[] statuses, int start, 6068 int end, 6069 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6070 throws com.liferay.portal.kernel.exception.SystemException { 6071 return getPersistence() 6072 .findByR_I_S(resourcePrimKey, indexable, statuses, start, 6073 end, orderByComparator); 6074 } 6075 6076 /** 6077 * Removes all the journal articles where resourcePrimKey = ? and indexable = ? and status = ? from the database. 6078 * 6079 * @param resourcePrimKey the resource prim key 6080 * @param indexable the indexable 6081 * @param status the status 6082 * @throws SystemException if a system exception occurred 6083 */ 6084 public static void removeByR_I_S(long resourcePrimKey, boolean indexable, 6085 int status) throws com.liferay.portal.kernel.exception.SystemException { 6086 getPersistence().removeByR_I_S(resourcePrimKey, indexable, status); 6087 } 6088 6089 /** 6090 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = ?. 6091 * 6092 * @param resourcePrimKey the resource prim key 6093 * @param indexable the indexable 6094 * @param status the status 6095 * @return the number of matching journal articles 6096 * @throws SystemException if a system exception occurred 6097 */ 6098 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 6099 int status) throws com.liferay.portal.kernel.exception.SystemException { 6100 return getPersistence().countByR_I_S(resourcePrimKey, indexable, status); 6101 } 6102 6103 /** 6104 * Returns the number of journal articles where resourcePrimKey = ? and indexable = ? and status = any ?. 6105 * 6106 * @param resourcePrimKey the resource prim key 6107 * @param indexable the indexable 6108 * @param statuses the statuses 6109 * @return the number of matching journal articles 6110 * @throws SystemException if a system exception occurred 6111 */ 6112 public static int countByR_I_S(long resourcePrimKey, boolean indexable, 6113 int[] statuses) 6114 throws com.liferay.portal.kernel.exception.SystemException { 6115 return getPersistence() 6116 .countByR_I_S(resourcePrimKey, indexable, statuses); 6117 } 6118 6119 /** 6120 * Returns all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6121 * 6122 * @param groupId the group ID 6123 * @param userId the user ID 6124 * @param classNameId the class name ID 6125 * @return the matching journal articles 6126 * @throws SystemException if a system exception occurred 6127 */ 6128 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6129 long groupId, long userId, long classNameId) 6130 throws com.liferay.portal.kernel.exception.SystemException { 6131 return getPersistence().findByG_U_C(groupId, userId, classNameId); 6132 } 6133 6134 /** 6135 * Returns a range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 6136 * 6137 * <p> 6138 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6139 * </p> 6140 * 6141 * @param groupId the group ID 6142 * @param userId the user ID 6143 * @param classNameId the class name ID 6144 * @param start the lower bound of the range of journal articles 6145 * @param end the upper bound of the range of journal articles (not inclusive) 6146 * @return the range of matching journal articles 6147 * @throws SystemException if a system exception occurred 6148 */ 6149 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6150 long groupId, long userId, long classNameId, int start, int end) 6151 throws com.liferay.portal.kernel.exception.SystemException { 6152 return getPersistence() 6153 .findByG_U_C(groupId, userId, classNameId, start, end); 6154 } 6155 6156 /** 6157 * Returns an ordered range of all the journal articles where groupId = ? and userId = ? and classNameId = ?. 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 userId the user ID 6165 * @param classNameId the class name ID 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 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6169 * @return the ordered range of matching journal articles 6170 * @throws SystemException if a system exception occurred 6171 */ 6172 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_U_C( 6173 long groupId, long userId, long classNameId, int start, int end, 6174 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6175 throws com.liferay.portal.kernel.exception.SystemException { 6176 return getPersistence() 6177 .findByG_U_C(groupId, userId, classNameId, start, end, 6178 orderByComparator); 6179 } 6180 6181 /** 6182 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6183 * 6184 * @param groupId the group ID 6185 * @param userId the user ID 6186 * @param classNameId the class name ID 6187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6188 * @return the first matching journal article 6189 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6190 * @throws SystemException if a system exception occurred 6191 */ 6192 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_First( 6193 long groupId, long userId, long classNameId, 6194 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6195 throws com.liferay.portal.kernel.exception.SystemException, 6196 com.liferay.portlet.journal.NoSuchArticleException { 6197 return getPersistence() 6198 .findByG_U_C_First(groupId, userId, classNameId, 6199 orderByComparator); 6200 } 6201 6202 /** 6203 * Returns the first journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6204 * 6205 * @param groupId the group ID 6206 * @param userId the user ID 6207 * @param classNameId the class name ID 6208 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6209 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6210 * @throws SystemException if a system exception occurred 6211 */ 6212 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_First( 6213 long groupId, long userId, long classNameId, 6214 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6215 throws com.liferay.portal.kernel.exception.SystemException { 6216 return getPersistence() 6217 .fetchByG_U_C_First(groupId, userId, classNameId, 6218 orderByComparator); 6219 } 6220 6221 /** 6222 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6223 * 6224 * @param groupId the group ID 6225 * @param userId the user ID 6226 * @param classNameId the class name ID 6227 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6228 * @return the last matching journal article 6229 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6230 * @throws SystemException if a system exception occurred 6231 */ 6232 public static com.liferay.portlet.journal.model.JournalArticle findByG_U_C_Last( 6233 long groupId, long userId, long classNameId, 6234 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6235 throws com.liferay.portal.kernel.exception.SystemException, 6236 com.liferay.portlet.journal.NoSuchArticleException { 6237 return getPersistence() 6238 .findByG_U_C_Last(groupId, userId, classNameId, 6239 orderByComparator); 6240 } 6241 6242 /** 6243 * Returns the last journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6244 * 6245 * @param groupId the group ID 6246 * @param userId the user ID 6247 * @param classNameId the class name ID 6248 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6249 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6250 * @throws SystemException if a system exception occurred 6251 */ 6252 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_U_C_Last( 6253 long groupId, long userId, long classNameId, 6254 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6255 throws com.liferay.portal.kernel.exception.SystemException { 6256 return getPersistence() 6257 .fetchByG_U_C_Last(groupId, userId, classNameId, 6258 orderByComparator); 6259 } 6260 6261 /** 6262 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and userId = ? and classNameId = ?. 6263 * 6264 * @param id the primary key of the current journal article 6265 * @param groupId the group ID 6266 * @param userId the user ID 6267 * @param classNameId the class name ID 6268 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6269 * @return the previous, current, and next journal article 6270 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6271 * @throws SystemException if a system exception occurred 6272 */ 6273 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_U_C_PrevAndNext( 6274 long id, long groupId, long userId, long classNameId, 6275 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6276 throws com.liferay.portal.kernel.exception.SystemException, 6277 com.liferay.portlet.journal.NoSuchArticleException { 6278 return getPersistence() 6279 .findByG_U_C_PrevAndNext(id, groupId, userId, classNameId, 6280 orderByComparator); 6281 } 6282 6283 /** 6284 * Returns all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6285 * 6286 * @param groupId the group ID 6287 * @param userId the user ID 6288 * @param classNameId the class name ID 6289 * @return the matching journal articles that the user has permission to view 6290 * @throws SystemException if a system exception occurred 6291 */ 6292 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6293 long groupId, long userId, long classNameId) 6294 throws com.liferay.portal.kernel.exception.SystemException { 6295 return getPersistence().filterFindByG_U_C(groupId, userId, classNameId); 6296 } 6297 6298 /** 6299 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6300 * 6301 * <p> 6302 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6303 * </p> 6304 * 6305 * @param groupId the group ID 6306 * @param userId the user ID 6307 * @param classNameId the class name ID 6308 * @param start the lower bound of the range of journal articles 6309 * @param end the upper bound of the range of journal articles (not inclusive) 6310 * @return the range of matching journal articles that the user has permission to view 6311 * @throws SystemException if a system exception occurred 6312 */ 6313 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6314 long groupId, long userId, long classNameId, int start, int end) 6315 throws com.liferay.portal.kernel.exception.SystemException { 6316 return getPersistence() 6317 .filterFindByG_U_C(groupId, userId, classNameId, start, end); 6318 } 6319 6320 /** 6321 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and userId = ? and classNameId = ?. 6322 * 6323 * <p> 6324 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6325 * </p> 6326 * 6327 * @param groupId the group ID 6328 * @param userId the user ID 6329 * @param classNameId the class name ID 6330 * @param start the lower bound of the range of journal articles 6331 * @param end the upper bound of the range of journal articles (not inclusive) 6332 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6333 * @return the ordered range of matching journal articles that the user has permission to view 6334 * @throws SystemException if a system exception occurred 6335 */ 6336 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_U_C( 6337 long groupId, long userId, long classNameId, int start, int end, 6338 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6339 throws com.liferay.portal.kernel.exception.SystemException { 6340 return getPersistence() 6341 .filterFindByG_U_C(groupId, userId, classNameId, start, end, 6342 orderByComparator); 6343 } 6344 6345 /** 6346 * 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 = ?. 6347 * 6348 * @param id the primary key of the current journal article 6349 * @param groupId the group ID 6350 * @param userId the user ID 6351 * @param classNameId the class name ID 6352 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6353 * @return the previous, current, and next journal article 6354 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6355 * @throws SystemException if a system exception occurred 6356 */ 6357 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_U_C_PrevAndNext( 6358 long id, long groupId, long userId, long classNameId, 6359 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6360 throws com.liferay.portal.kernel.exception.SystemException, 6361 com.liferay.portlet.journal.NoSuchArticleException { 6362 return getPersistence() 6363 .filterFindByG_U_C_PrevAndNext(id, groupId, userId, 6364 classNameId, orderByComparator); 6365 } 6366 6367 /** 6368 * Removes all the journal articles where groupId = ? and userId = ? and classNameId = ? from the database. 6369 * 6370 * @param groupId the group ID 6371 * @param userId the user ID 6372 * @param classNameId the class name ID 6373 * @throws SystemException if a system exception occurred 6374 */ 6375 public static void removeByG_U_C(long groupId, long userId, long classNameId) 6376 throws com.liferay.portal.kernel.exception.SystemException { 6377 getPersistence().removeByG_U_C(groupId, userId, classNameId); 6378 } 6379 6380 /** 6381 * Returns the number of journal articles where groupId = ? and userId = ? and classNameId = ?. 6382 * 6383 * @param groupId the group ID 6384 * @param userId the user ID 6385 * @param classNameId the class name ID 6386 * @return the number of matching journal articles 6387 * @throws SystemException if a system exception occurred 6388 */ 6389 public static int countByG_U_C(long groupId, long userId, long classNameId) 6390 throws com.liferay.portal.kernel.exception.SystemException { 6391 return getPersistence().countByG_U_C(groupId, userId, classNameId); 6392 } 6393 6394 /** 6395 * Returns the number of journal articles that the user has permission to view where groupId = ? and userId = ? and classNameId = ?. 6396 * 6397 * @param groupId the group ID 6398 * @param userId the user ID 6399 * @param classNameId the class name ID 6400 * @return the number of matching journal articles that the user has permission to view 6401 * @throws SystemException if a system exception occurred 6402 */ 6403 public static int filterCountByG_U_C(long groupId, long userId, 6404 long classNameId) 6405 throws com.liferay.portal.kernel.exception.SystemException { 6406 return getPersistence().filterCountByG_U_C(groupId, userId, classNameId); 6407 } 6408 6409 /** 6410 * Returns all the journal articles where groupId = ? and folderId = ? and status = ?. 6411 * 6412 * @param groupId the group ID 6413 * @param folderId the folder ID 6414 * @param status the status 6415 * @return the matching journal articles 6416 * @throws SystemException if a system exception occurred 6417 */ 6418 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6419 long groupId, long folderId, int status) 6420 throws com.liferay.portal.kernel.exception.SystemException { 6421 return getPersistence().findByG_F_ST(groupId, folderId, status); 6422 } 6423 6424 /** 6425 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = ?. 6426 * 6427 * <p> 6428 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6429 * </p> 6430 * 6431 * @param groupId the group ID 6432 * @param folderId the folder ID 6433 * @param status the status 6434 * @param start the lower bound of the range of journal articles 6435 * @param end the upper bound of the range of journal articles (not inclusive) 6436 * @return the range of matching journal articles 6437 * @throws SystemException if a system exception occurred 6438 */ 6439 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6440 long groupId, long folderId, int status, int start, int end) 6441 throws com.liferay.portal.kernel.exception.SystemException { 6442 return getPersistence() 6443 .findByG_F_ST(groupId, folderId, status, start, end); 6444 } 6445 6446 /** 6447 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = ?. 6448 * 6449 * <p> 6450 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6451 * </p> 6452 * 6453 * @param groupId the group ID 6454 * @param folderId the folder ID 6455 * @param status the status 6456 * @param start the lower bound of the range of journal articles 6457 * @param end the upper bound of the range of journal articles (not inclusive) 6458 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6459 * @return the ordered range of matching journal articles 6460 * @throws SystemException if a system exception occurred 6461 */ 6462 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6463 long groupId, long folderId, int status, int start, int end, 6464 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6465 throws com.liferay.portal.kernel.exception.SystemException { 6466 return getPersistence() 6467 .findByG_F_ST(groupId, folderId, status, start, end, 6468 orderByComparator); 6469 } 6470 6471 /** 6472 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 6473 * 6474 * @param groupId the group ID 6475 * @param folderId the folder ID 6476 * @param status the status 6477 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6478 * @return the first matching journal article 6479 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6480 * @throws SystemException if a system exception occurred 6481 */ 6482 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_First( 6483 long groupId, long folderId, int status, 6484 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6485 throws com.liferay.portal.kernel.exception.SystemException, 6486 com.liferay.portlet.journal.NoSuchArticleException { 6487 return getPersistence() 6488 .findByG_F_ST_First(groupId, folderId, status, 6489 orderByComparator); 6490 } 6491 6492 /** 6493 * Returns the first journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 6494 * 6495 * @param groupId the group ID 6496 * @param folderId the folder ID 6497 * @param status the status 6498 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6499 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6500 * @throws SystemException if a system exception occurred 6501 */ 6502 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_First( 6503 long groupId, long folderId, int status, 6504 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6505 throws com.liferay.portal.kernel.exception.SystemException { 6506 return getPersistence() 6507 .fetchByG_F_ST_First(groupId, folderId, status, 6508 orderByComparator); 6509 } 6510 6511 /** 6512 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 6513 * 6514 * @param groupId the group ID 6515 * @param folderId the folder ID 6516 * @param status the status 6517 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6518 * @return the last matching journal article 6519 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6520 * @throws SystemException if a system exception occurred 6521 */ 6522 public static com.liferay.portlet.journal.model.JournalArticle findByG_F_ST_Last( 6523 long groupId, long folderId, int status, 6524 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6525 throws com.liferay.portal.kernel.exception.SystemException, 6526 com.liferay.portlet.journal.NoSuchArticleException { 6527 return getPersistence() 6528 .findByG_F_ST_Last(groupId, folderId, status, 6529 orderByComparator); 6530 } 6531 6532 /** 6533 * Returns the last journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 6534 * 6535 * @param groupId the group ID 6536 * @param folderId the folder ID 6537 * @param status the status 6538 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6539 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6540 * @throws SystemException if a system exception occurred 6541 */ 6542 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_F_ST_Last( 6543 long groupId, long folderId, int status, 6544 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6545 throws com.liferay.portal.kernel.exception.SystemException { 6546 return getPersistence() 6547 .fetchByG_F_ST_Last(groupId, folderId, status, 6548 orderByComparator); 6549 } 6550 6551 /** 6552 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and folderId = ? and status = ?. 6553 * 6554 * @param id the primary key of the current journal article 6555 * @param groupId the group ID 6556 * @param folderId the folder ID 6557 * @param status the status 6558 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6559 * @return the previous, current, and next journal article 6560 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6561 * @throws SystemException if a system exception occurred 6562 */ 6563 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_F_ST_PrevAndNext( 6564 long id, long groupId, long folderId, int status, 6565 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6566 throws com.liferay.portal.kernel.exception.SystemException, 6567 com.liferay.portlet.journal.NoSuchArticleException { 6568 return getPersistence() 6569 .findByG_F_ST_PrevAndNext(id, groupId, folderId, status, 6570 orderByComparator); 6571 } 6572 6573 /** 6574 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 6575 * 6576 * @param groupId the group ID 6577 * @param folderId the folder ID 6578 * @param status the status 6579 * @return the matching journal articles that the user has permission to view 6580 * @throws SystemException if a system exception occurred 6581 */ 6582 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6583 long groupId, long folderId, int status) 6584 throws com.liferay.portal.kernel.exception.SystemException { 6585 return getPersistence().filterFindByG_F_ST(groupId, folderId, status); 6586 } 6587 6588 /** 6589 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 6590 * 6591 * <p> 6592 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6593 * </p> 6594 * 6595 * @param groupId the group ID 6596 * @param folderId the folder ID 6597 * @param status the status 6598 * @param start the lower bound of the range of journal articles 6599 * @param end the upper bound of the range of journal articles (not inclusive) 6600 * @return the range of matching journal articles that the user has permission to view 6601 * @throws SystemException if a system exception occurred 6602 */ 6603 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6604 long groupId, long folderId, int status, int start, int end) 6605 throws com.liferay.portal.kernel.exception.SystemException { 6606 return getPersistence() 6607 .filterFindByG_F_ST(groupId, folderId, status, start, end); 6608 } 6609 6610 /** 6611 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and folderId = ? and status = ?. 6612 * 6613 * <p> 6614 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6615 * </p> 6616 * 6617 * @param groupId the group ID 6618 * @param folderId the folder ID 6619 * @param status the status 6620 * @param start the lower bound of the range of journal articles 6621 * @param end the upper bound of the range of journal articles (not inclusive) 6622 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6623 * @return the ordered range of matching journal articles that the user has permission to view 6624 * @throws SystemException if a system exception occurred 6625 */ 6626 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6627 long groupId, long folderId, int status, int start, int end, 6628 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6629 throws com.liferay.portal.kernel.exception.SystemException { 6630 return getPersistence() 6631 .filterFindByG_F_ST(groupId, folderId, status, start, end, 6632 orderByComparator); 6633 } 6634 6635 /** 6636 * 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 = ?. 6637 * 6638 * @param id the primary key of the current journal article 6639 * @param groupId the group ID 6640 * @param folderId the folder ID 6641 * @param status the status 6642 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6643 * @return the previous, current, and next journal article 6644 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 6645 * @throws SystemException if a system exception occurred 6646 */ 6647 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_F_ST_PrevAndNext( 6648 long id, long groupId, long folderId, int status, 6649 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6650 throws com.liferay.portal.kernel.exception.SystemException, 6651 com.liferay.portlet.journal.NoSuchArticleException { 6652 return getPersistence() 6653 .filterFindByG_F_ST_PrevAndNext(id, groupId, folderId, 6654 status, orderByComparator); 6655 } 6656 6657 /** 6658 * Returns all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6659 * 6660 * @param groupId the group ID 6661 * @param folderId the folder ID 6662 * @param statuses the statuses 6663 * @return the matching journal articles that the user has permission to view 6664 * @throws SystemException if a system exception occurred 6665 */ 6666 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6667 long groupId, long folderId, int[] statuses) 6668 throws com.liferay.portal.kernel.exception.SystemException { 6669 return getPersistence().filterFindByG_F_ST(groupId, folderId, statuses); 6670 } 6671 6672 /** 6673 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6674 * 6675 * <p> 6676 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6677 * </p> 6678 * 6679 * @param groupId the group ID 6680 * @param folderId the folder ID 6681 * @param statuses the statuses 6682 * @param start the lower bound of the range of journal articles 6683 * @param end the upper bound of the range of journal articles (not inclusive) 6684 * @return the range of matching journal articles that the user has permission to view 6685 * @throws SystemException if a system exception occurred 6686 */ 6687 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6688 long groupId, long folderId, int[] statuses, int start, int end) 6689 throws com.liferay.portal.kernel.exception.SystemException { 6690 return getPersistence() 6691 .filterFindByG_F_ST(groupId, folderId, statuses, start, end); 6692 } 6693 6694 /** 6695 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6696 * 6697 * <p> 6698 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6699 * </p> 6700 * 6701 * @param groupId the group ID 6702 * @param folderId the folder ID 6703 * @param statuses the statuses 6704 * @param start the lower bound of the range of journal articles 6705 * @param end the upper bound of the range of journal articles (not inclusive) 6706 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6707 * @return the ordered range of matching journal articles that the user has permission to view 6708 * @throws SystemException if a system exception occurred 6709 */ 6710 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_F_ST( 6711 long groupId, long folderId, int[] statuses, int start, int end, 6712 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6713 throws com.liferay.portal.kernel.exception.SystemException { 6714 return getPersistence() 6715 .filterFindByG_F_ST(groupId, folderId, statuses, start, end, 6716 orderByComparator); 6717 } 6718 6719 /** 6720 * Returns all the journal articles where groupId = ? and folderId = ? and status = any ?. 6721 * 6722 * <p> 6723 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6724 * </p> 6725 * 6726 * @param groupId the group ID 6727 * @param folderId the folder ID 6728 * @param statuses the statuses 6729 * @return the matching journal articles 6730 * @throws SystemException if a system exception occurred 6731 */ 6732 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6733 long groupId, long folderId, int[] statuses) 6734 throws com.liferay.portal.kernel.exception.SystemException { 6735 return getPersistence().findByG_F_ST(groupId, folderId, statuses); 6736 } 6737 6738 /** 6739 * Returns a range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 6740 * 6741 * <p> 6742 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6743 * </p> 6744 * 6745 * @param groupId the group ID 6746 * @param folderId the folder ID 6747 * @param statuses the statuses 6748 * @param start the lower bound of the range of journal articles 6749 * @param end the upper bound of the range of journal articles (not inclusive) 6750 * @return the range of matching journal articles 6751 * @throws SystemException if a system exception occurred 6752 */ 6753 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6754 long groupId, long folderId, int[] statuses, int start, int end) 6755 throws com.liferay.portal.kernel.exception.SystemException { 6756 return getPersistence() 6757 .findByG_F_ST(groupId, folderId, statuses, start, end); 6758 } 6759 6760 /** 6761 * Returns an ordered range of all the journal articles where groupId = ? and folderId = ? and status = any ?. 6762 * 6763 * <p> 6764 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6765 * </p> 6766 * 6767 * @param groupId the group ID 6768 * @param folderId the folder ID 6769 * @param statuses the statuses 6770 * @param start the lower bound of the range of journal articles 6771 * @param end the upper bound of the range of journal articles (not inclusive) 6772 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6773 * @return the ordered range of matching journal articles 6774 * @throws SystemException if a system exception occurred 6775 */ 6776 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_F_ST( 6777 long groupId, long folderId, int[] statuses, int start, int end, 6778 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6779 throws com.liferay.portal.kernel.exception.SystemException { 6780 return getPersistence() 6781 .findByG_F_ST(groupId, folderId, statuses, start, end, 6782 orderByComparator); 6783 } 6784 6785 /** 6786 * Removes all the journal articles where groupId = ? and folderId = ? and status = ? from the database. 6787 * 6788 * @param groupId the group ID 6789 * @param folderId the folder ID 6790 * @param status the status 6791 * @throws SystemException if a system exception occurred 6792 */ 6793 public static void removeByG_F_ST(long groupId, long folderId, int status) 6794 throws com.liferay.portal.kernel.exception.SystemException { 6795 getPersistence().removeByG_F_ST(groupId, folderId, status); 6796 } 6797 6798 /** 6799 * Returns the number of journal articles where groupId = ? and folderId = ? and status = ?. 6800 * 6801 * @param groupId the group ID 6802 * @param folderId the folder ID 6803 * @param status the status 6804 * @return the number of matching journal articles 6805 * @throws SystemException if a system exception occurred 6806 */ 6807 public static int countByG_F_ST(long groupId, long folderId, int status) 6808 throws com.liferay.portal.kernel.exception.SystemException { 6809 return getPersistence().countByG_F_ST(groupId, folderId, status); 6810 } 6811 6812 /** 6813 * Returns the number of journal articles where groupId = ? and folderId = ? and status = any ?. 6814 * 6815 * @param groupId the group ID 6816 * @param folderId the folder ID 6817 * @param statuses the statuses 6818 * @return the number of matching journal articles 6819 * @throws SystemException if a system exception occurred 6820 */ 6821 public static int countByG_F_ST(long groupId, long folderId, int[] statuses) 6822 throws com.liferay.portal.kernel.exception.SystemException { 6823 return getPersistence().countByG_F_ST(groupId, folderId, statuses); 6824 } 6825 6826 /** 6827 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = ?. 6828 * 6829 * @param groupId the group ID 6830 * @param folderId the folder ID 6831 * @param status the status 6832 * @return the number of matching journal articles that the user has permission to view 6833 * @throws SystemException if a system exception occurred 6834 */ 6835 public static int filterCountByG_F_ST(long groupId, long folderId, 6836 int status) throws com.liferay.portal.kernel.exception.SystemException { 6837 return getPersistence().filterCountByG_F_ST(groupId, folderId, status); 6838 } 6839 6840 /** 6841 * Returns the number of journal articles that the user has permission to view where groupId = ? and folderId = ? and status = any ?. 6842 * 6843 * @param groupId the group ID 6844 * @param folderId the folder ID 6845 * @param statuses the statuses 6846 * @return the number of matching journal articles that the user has permission to view 6847 * @throws SystemException if a system exception occurred 6848 */ 6849 public static int filterCountByG_F_ST(long groupId, long folderId, 6850 int[] statuses) 6851 throws com.liferay.portal.kernel.exception.SystemException { 6852 return getPersistence().filterCountByG_F_ST(groupId, folderId, statuses); 6853 } 6854 6855 /** 6856 * Returns all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6857 * 6858 * @param groupId the group ID 6859 * @param classNameId the class name ID 6860 * @param classPK the class p k 6861 * @return the matching journal articles 6862 * @throws SystemException if a system exception occurred 6863 */ 6864 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6865 long groupId, long classNameId, long classPK) 6866 throws com.liferay.portal.kernel.exception.SystemException { 6867 return getPersistence().findByG_C_C(groupId, classNameId, classPK); 6868 } 6869 6870 /** 6871 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6872 * 6873 * <p> 6874 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6875 * </p> 6876 * 6877 * @param groupId the group ID 6878 * @param classNameId the class name ID 6879 * @param classPK the class p k 6880 * @param start the lower bound of the range of journal articles 6881 * @param end the upper bound of the range of journal articles (not inclusive) 6882 * @return the range of matching journal articles 6883 * @throws SystemException if a system exception occurred 6884 */ 6885 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6886 long groupId, long classNameId, long classPK, int start, int end) 6887 throws com.liferay.portal.kernel.exception.SystemException { 6888 return getPersistence() 6889 .findByG_C_C(groupId, classNameId, classPK, start, end); 6890 } 6891 6892 /** 6893 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and classPK = ?. 6894 * 6895 * <p> 6896 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 6897 * </p> 6898 * 6899 * @param groupId the group ID 6900 * @param classNameId the class name ID 6901 * @param classPK the class p k 6902 * @param start the lower bound of the range of journal articles 6903 * @param end the upper bound of the range of journal articles (not inclusive) 6904 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 6905 * @return the ordered range of matching journal articles 6906 * @throws SystemException if a system exception occurred 6907 */ 6908 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_C( 6909 long groupId, long classNameId, long classPK, int start, int end, 6910 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6911 throws com.liferay.portal.kernel.exception.SystemException { 6912 return getPersistence() 6913 .findByG_C_C(groupId, classNameId, classPK, start, end, 6914 orderByComparator); 6915 } 6916 6917 /** 6918 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6919 * 6920 * @param groupId the group ID 6921 * @param classNameId the class name ID 6922 * @param classPK the class p k 6923 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6924 * @return the first matching journal article 6925 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6926 * @throws SystemException if a system exception occurred 6927 */ 6928 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_First( 6929 long groupId, long classNameId, long classPK, 6930 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6931 throws com.liferay.portal.kernel.exception.SystemException, 6932 com.liferay.portlet.journal.NoSuchArticleException { 6933 return getPersistence() 6934 .findByG_C_C_First(groupId, classNameId, classPK, 6935 orderByComparator); 6936 } 6937 6938 /** 6939 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6940 * 6941 * @param groupId the group ID 6942 * @param classNameId the class name ID 6943 * @param classPK the class p k 6944 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6945 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 6946 * @throws SystemException if a system exception occurred 6947 */ 6948 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_First( 6949 long groupId, long classNameId, long classPK, 6950 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6951 throws com.liferay.portal.kernel.exception.SystemException { 6952 return getPersistence() 6953 .fetchByG_C_C_First(groupId, classNameId, classPK, 6954 orderByComparator); 6955 } 6956 6957 /** 6958 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6959 * 6960 * @param groupId the group ID 6961 * @param classNameId the class name ID 6962 * @param classPK the class p k 6963 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6964 * @return the last matching journal article 6965 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 6966 * @throws SystemException if a system exception occurred 6967 */ 6968 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_C_Last( 6969 long groupId, long classNameId, long classPK, 6970 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6971 throws com.liferay.portal.kernel.exception.SystemException, 6972 com.liferay.portlet.journal.NoSuchArticleException { 6973 return getPersistence() 6974 .findByG_C_C_Last(groupId, classNameId, classPK, 6975 orderByComparator); 6976 } 6977 6978 /** 6979 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6980 * 6981 * @param groupId the group ID 6982 * @param classNameId the class name ID 6983 * @param classPK the class p k 6984 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 6985 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 6986 * @throws SystemException if a system exception occurred 6987 */ 6988 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_C_Last( 6989 long groupId, long classNameId, long classPK, 6990 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 6991 throws com.liferay.portal.kernel.exception.SystemException { 6992 return getPersistence() 6993 .fetchByG_C_C_Last(groupId, classNameId, classPK, 6994 orderByComparator); 6995 } 6996 6997 /** 6998 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and classPK = ?. 6999 * 7000 * @param id the primary key of the current journal article 7001 * @param groupId the group ID 7002 * @param classNameId the class name ID 7003 * @param classPK the class p k 7004 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7005 * @return the previous, current, and next journal article 7006 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7007 * @throws SystemException if a system exception occurred 7008 */ 7009 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_C_PrevAndNext( 7010 long id, long groupId, long classNameId, long classPK, 7011 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7012 throws com.liferay.portal.kernel.exception.SystemException, 7013 com.liferay.portlet.journal.NoSuchArticleException { 7014 return getPersistence() 7015 .findByG_C_C_PrevAndNext(id, groupId, classNameId, classPK, 7016 orderByComparator); 7017 } 7018 7019 /** 7020 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 7021 * 7022 * @param groupId the group ID 7023 * @param classNameId the class name ID 7024 * @param classPK the class p k 7025 * @return the matching journal articles that the user has permission to view 7026 * @throws SystemException if a system exception occurred 7027 */ 7028 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 7029 long groupId, long classNameId, long classPK) 7030 throws com.liferay.portal.kernel.exception.SystemException { 7031 return getPersistence().filterFindByG_C_C(groupId, classNameId, classPK); 7032 } 7033 7034 /** 7035 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 7036 * 7037 * <p> 7038 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7039 * </p> 7040 * 7041 * @param groupId the group ID 7042 * @param classNameId the class name ID 7043 * @param classPK the class p k 7044 * @param start the lower bound of the range of journal articles 7045 * @param end the upper bound of the range of journal articles (not inclusive) 7046 * @return the range of matching journal articles that the user has permission to view 7047 * @throws SystemException if a system exception occurred 7048 */ 7049 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 7050 long groupId, long classNameId, long classPK, int start, int end) 7051 throws com.liferay.portal.kernel.exception.SystemException { 7052 return getPersistence() 7053 .filterFindByG_C_C(groupId, classNameId, classPK, start, end); 7054 } 7055 7056 /** 7057 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and classPK = ?. 7058 * 7059 * <p> 7060 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7061 * </p> 7062 * 7063 * @param groupId the group ID 7064 * @param classNameId the class name ID 7065 * @param classPK the class p k 7066 * @param start the lower bound of the range of journal articles 7067 * @param end the upper bound of the range of journal articles (not inclusive) 7068 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7069 * @return the ordered range of matching journal articles that the user has permission to view 7070 * @throws SystemException if a system exception occurred 7071 */ 7072 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_C( 7073 long groupId, long classNameId, long classPK, int start, int end, 7074 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7075 throws com.liferay.portal.kernel.exception.SystemException { 7076 return getPersistence() 7077 .filterFindByG_C_C(groupId, classNameId, classPK, start, 7078 end, orderByComparator); 7079 } 7080 7081 /** 7082 * 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 = ?. 7083 * 7084 * @param id the primary key of the current journal article 7085 * @param groupId the group ID 7086 * @param classNameId the class name ID 7087 * @param classPK the class p k 7088 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7089 * @return the previous, current, and next journal article 7090 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7091 * @throws SystemException if a system exception occurred 7092 */ 7093 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_C_PrevAndNext( 7094 long id, long groupId, long classNameId, long classPK, 7095 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7096 throws com.liferay.portal.kernel.exception.SystemException, 7097 com.liferay.portlet.journal.NoSuchArticleException { 7098 return getPersistence() 7099 .filterFindByG_C_C_PrevAndNext(id, groupId, classNameId, 7100 classPK, orderByComparator); 7101 } 7102 7103 /** 7104 * Removes all the journal articles where groupId = ? and classNameId = ? and classPK = ? from the database. 7105 * 7106 * @param groupId the group ID 7107 * @param classNameId the class name ID 7108 * @param classPK the class p k 7109 * @throws SystemException if a system exception occurred 7110 */ 7111 public static void removeByG_C_C(long groupId, long classNameId, 7112 long classPK) 7113 throws com.liferay.portal.kernel.exception.SystemException { 7114 getPersistence().removeByG_C_C(groupId, classNameId, classPK); 7115 } 7116 7117 /** 7118 * Returns the number of journal articles where groupId = ? and classNameId = ? and classPK = ?. 7119 * 7120 * @param groupId the group ID 7121 * @param classNameId the class name ID 7122 * @param classPK the class p k 7123 * @return the number of matching journal articles 7124 * @throws SystemException if a system exception occurred 7125 */ 7126 public static int countByG_C_C(long groupId, long classNameId, long classPK) 7127 throws com.liferay.portal.kernel.exception.SystemException { 7128 return getPersistence().countByG_C_C(groupId, classNameId, classPK); 7129 } 7130 7131 /** 7132 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and classPK = ?. 7133 * 7134 * @param groupId the group ID 7135 * @param classNameId the class name ID 7136 * @param classPK the class p k 7137 * @return the number of matching journal articles that the user has permission to view 7138 * @throws SystemException if a system exception occurred 7139 */ 7140 public static int filterCountByG_C_C(long groupId, long classNameId, 7141 long classPK) 7142 throws com.liferay.portal.kernel.exception.SystemException { 7143 return getPersistence().filterCountByG_C_C(groupId, classNameId, classPK); 7144 } 7145 7146 /** 7147 * 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. 7148 * 7149 * @param groupId the group ID 7150 * @param classNameId the class name ID 7151 * @param structureId the structure ID 7152 * @return the matching journal article 7153 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7154 * @throws SystemException if a system exception occurred 7155 */ 7156 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_S( 7157 long groupId, long classNameId, java.lang.String structureId) 7158 throws com.liferay.portal.kernel.exception.SystemException, 7159 com.liferay.portlet.journal.NoSuchArticleException { 7160 return getPersistence().findByG_C_S(groupId, classNameId, structureId); 7161 } 7162 7163 /** 7164 * 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. 7165 * 7166 * @param groupId the group ID 7167 * @param classNameId the class name ID 7168 * @param structureId the structure ID 7169 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7170 * @throws SystemException if a system exception occurred 7171 */ 7172 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 7173 long groupId, long classNameId, java.lang.String structureId) 7174 throws com.liferay.portal.kernel.exception.SystemException { 7175 return getPersistence().fetchByG_C_S(groupId, classNameId, structureId); 7176 } 7177 7178 /** 7179 * 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. 7180 * 7181 * @param groupId the group ID 7182 * @param classNameId the class name ID 7183 * @param structureId the structure ID 7184 * @param retrieveFromCache whether to use the finder cache 7185 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7186 * @throws SystemException if a system exception occurred 7187 */ 7188 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_S( 7189 long groupId, long classNameId, java.lang.String structureId, 7190 boolean retrieveFromCache) 7191 throws com.liferay.portal.kernel.exception.SystemException { 7192 return getPersistence() 7193 .fetchByG_C_S(groupId, classNameId, structureId, 7194 retrieveFromCache); 7195 } 7196 7197 /** 7198 * Removes the journal article where groupId = ? and classNameId = ? and structureId = ? from the database. 7199 * 7200 * @param groupId the group ID 7201 * @param classNameId the class name ID 7202 * @param structureId the structure ID 7203 * @return the journal article that was removed 7204 * @throws SystemException if a system exception occurred 7205 */ 7206 public static com.liferay.portlet.journal.model.JournalArticle removeByG_C_S( 7207 long groupId, long classNameId, java.lang.String structureId) 7208 throws com.liferay.portal.kernel.exception.SystemException, 7209 com.liferay.portlet.journal.NoSuchArticleException { 7210 return getPersistence().removeByG_C_S(groupId, classNameId, structureId); 7211 } 7212 7213 /** 7214 * Returns the number of journal articles where groupId = ? and classNameId = ? and structureId = ?. 7215 * 7216 * @param groupId the group ID 7217 * @param classNameId the class name ID 7218 * @param structureId the structure ID 7219 * @return the number of matching journal articles 7220 * @throws SystemException if a system exception occurred 7221 */ 7222 public static int countByG_C_S(long groupId, long classNameId, 7223 java.lang.String structureId) 7224 throws com.liferay.portal.kernel.exception.SystemException { 7225 return getPersistence().countByG_C_S(groupId, classNameId, structureId); 7226 } 7227 7228 /** 7229 * Returns all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 7230 * 7231 * @param groupId the group ID 7232 * @param classNameId the class name ID 7233 * @param templateId the template ID 7234 * @return the matching journal articles 7235 * @throws SystemException if a system exception occurred 7236 */ 7237 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 7238 long groupId, long classNameId, java.lang.String templateId) 7239 throws com.liferay.portal.kernel.exception.SystemException { 7240 return getPersistence().findByG_C_T(groupId, classNameId, templateId); 7241 } 7242 7243 /** 7244 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 7245 * 7246 * <p> 7247 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7248 * </p> 7249 * 7250 * @param groupId the group ID 7251 * @param classNameId the class name ID 7252 * @param templateId the template ID 7253 * @param start the lower bound of the range of journal articles 7254 * @param end the upper bound of the range of journal articles (not inclusive) 7255 * @return the range of matching journal articles 7256 * @throws SystemException if a system exception occurred 7257 */ 7258 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 7259 long groupId, long classNameId, java.lang.String templateId, int start, 7260 int end) throws com.liferay.portal.kernel.exception.SystemException { 7261 return getPersistence() 7262 .findByG_C_T(groupId, classNameId, templateId, start, end); 7263 } 7264 7265 /** 7266 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and templateId = ?. 7267 * 7268 * <p> 7269 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7270 * </p> 7271 * 7272 * @param groupId the group ID 7273 * @param classNameId the class name ID 7274 * @param templateId the template ID 7275 * @param start the lower bound of the range of journal articles 7276 * @param end the upper bound of the range of journal articles (not inclusive) 7277 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7278 * @return the ordered range of matching journal articles 7279 * @throws SystemException if a system exception occurred 7280 */ 7281 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_T( 7282 long groupId, long classNameId, java.lang.String templateId, int start, 7283 int end, 7284 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7285 throws com.liferay.portal.kernel.exception.SystemException { 7286 return getPersistence() 7287 .findByG_C_T(groupId, classNameId, templateId, start, end, 7288 orderByComparator); 7289 } 7290 7291 /** 7292 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 7293 * 7294 * @param groupId the group ID 7295 * @param classNameId the class name ID 7296 * @param templateId the template ID 7297 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7298 * @return the first matching journal article 7299 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7300 * @throws SystemException if a system exception occurred 7301 */ 7302 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_First( 7303 long groupId, long classNameId, java.lang.String templateId, 7304 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7305 throws com.liferay.portal.kernel.exception.SystemException, 7306 com.liferay.portlet.journal.NoSuchArticleException { 7307 return getPersistence() 7308 .findByG_C_T_First(groupId, classNameId, templateId, 7309 orderByComparator); 7310 } 7311 7312 /** 7313 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 7314 * 7315 * @param groupId the group ID 7316 * @param classNameId the class name ID 7317 * @param templateId the template ID 7318 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7319 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7320 * @throws SystemException if a system exception occurred 7321 */ 7322 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_First( 7323 long groupId, long classNameId, java.lang.String templateId, 7324 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7325 throws com.liferay.portal.kernel.exception.SystemException { 7326 return getPersistence() 7327 .fetchByG_C_T_First(groupId, classNameId, templateId, 7328 orderByComparator); 7329 } 7330 7331 /** 7332 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 7333 * 7334 * @param groupId the group ID 7335 * @param classNameId the class name ID 7336 * @param templateId the template ID 7337 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7338 * @return the last matching journal article 7339 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7340 * @throws SystemException if a system exception occurred 7341 */ 7342 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_T_Last( 7343 long groupId, long classNameId, java.lang.String templateId, 7344 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7345 throws com.liferay.portal.kernel.exception.SystemException, 7346 com.liferay.portlet.journal.NoSuchArticleException { 7347 return getPersistence() 7348 .findByG_C_T_Last(groupId, classNameId, templateId, 7349 orderByComparator); 7350 } 7351 7352 /** 7353 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 7354 * 7355 * @param groupId the group ID 7356 * @param classNameId the class name ID 7357 * @param templateId the template ID 7358 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7359 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7360 * @throws SystemException if a system exception occurred 7361 */ 7362 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_T_Last( 7363 long groupId, long classNameId, java.lang.String templateId, 7364 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7365 throws com.liferay.portal.kernel.exception.SystemException { 7366 return getPersistence() 7367 .fetchByG_C_T_Last(groupId, classNameId, templateId, 7368 orderByComparator); 7369 } 7370 7371 /** 7372 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and templateId = ?. 7373 * 7374 * @param id the primary key of the current journal article 7375 * @param groupId the group ID 7376 * @param classNameId the class name ID 7377 * @param templateId the template ID 7378 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7379 * @return the previous, current, and next journal article 7380 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7381 * @throws SystemException if a system exception occurred 7382 */ 7383 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_T_PrevAndNext( 7384 long id, long groupId, long classNameId, java.lang.String templateId, 7385 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7386 throws com.liferay.portal.kernel.exception.SystemException, 7387 com.liferay.portlet.journal.NoSuchArticleException { 7388 return getPersistence() 7389 .findByG_C_T_PrevAndNext(id, groupId, classNameId, 7390 templateId, orderByComparator); 7391 } 7392 7393 /** 7394 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 7395 * 7396 * @param groupId the group ID 7397 * @param classNameId the class name ID 7398 * @param templateId the template ID 7399 * @return the matching journal articles that the user has permission to view 7400 * @throws SystemException if a system exception occurred 7401 */ 7402 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 7403 long groupId, long classNameId, java.lang.String templateId) 7404 throws com.liferay.portal.kernel.exception.SystemException { 7405 return getPersistence() 7406 .filterFindByG_C_T(groupId, classNameId, templateId); 7407 } 7408 7409 /** 7410 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 7411 * 7412 * <p> 7413 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7414 * </p> 7415 * 7416 * @param groupId the group ID 7417 * @param classNameId the class name ID 7418 * @param templateId the template ID 7419 * @param start the lower bound of the range of journal articles 7420 * @param end the upper bound of the range of journal articles (not inclusive) 7421 * @return the range of matching journal articles that the user has permission to view 7422 * @throws SystemException if a system exception occurred 7423 */ 7424 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 7425 long groupId, long classNameId, java.lang.String templateId, int start, 7426 int end) throws com.liferay.portal.kernel.exception.SystemException { 7427 return getPersistence() 7428 .filterFindByG_C_T(groupId, classNameId, templateId, start, 7429 end); 7430 } 7431 7432 /** 7433 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and templateId = ?. 7434 * 7435 * <p> 7436 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7437 * </p> 7438 * 7439 * @param groupId the group ID 7440 * @param classNameId the class name ID 7441 * @param templateId the template ID 7442 * @param start the lower bound of the range of journal articles 7443 * @param end the upper bound of the range of journal articles (not inclusive) 7444 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7445 * @return the ordered range of matching journal articles that the user has permission to view 7446 * @throws SystemException if a system exception occurred 7447 */ 7448 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_T( 7449 long groupId, long classNameId, java.lang.String templateId, int start, 7450 int end, 7451 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7452 throws com.liferay.portal.kernel.exception.SystemException { 7453 return getPersistence() 7454 .filterFindByG_C_T(groupId, classNameId, templateId, start, 7455 end, orderByComparator); 7456 } 7457 7458 /** 7459 * 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 = ?. 7460 * 7461 * @param id the primary key of the current journal article 7462 * @param groupId the group ID 7463 * @param classNameId the class name ID 7464 * @param templateId the template ID 7465 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7466 * @return the previous, current, and next journal article 7467 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7468 * @throws SystemException if a system exception occurred 7469 */ 7470 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_T_PrevAndNext( 7471 long id, long groupId, long classNameId, java.lang.String templateId, 7472 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7473 throws com.liferay.portal.kernel.exception.SystemException, 7474 com.liferay.portlet.journal.NoSuchArticleException { 7475 return getPersistence() 7476 .filterFindByG_C_T_PrevAndNext(id, groupId, classNameId, 7477 templateId, orderByComparator); 7478 } 7479 7480 /** 7481 * Removes all the journal articles where groupId = ? and classNameId = ? and templateId = ? from the database. 7482 * 7483 * @param groupId the group ID 7484 * @param classNameId the class name ID 7485 * @param templateId the template ID 7486 * @throws SystemException if a system exception occurred 7487 */ 7488 public static void removeByG_C_T(long groupId, long classNameId, 7489 java.lang.String templateId) 7490 throws com.liferay.portal.kernel.exception.SystemException { 7491 getPersistence().removeByG_C_T(groupId, classNameId, templateId); 7492 } 7493 7494 /** 7495 * Returns the number of journal articles where groupId = ? and classNameId = ? and templateId = ?. 7496 * 7497 * @param groupId the group ID 7498 * @param classNameId the class name ID 7499 * @param templateId the template ID 7500 * @return the number of matching journal articles 7501 * @throws SystemException if a system exception occurred 7502 */ 7503 public static int countByG_C_T(long groupId, long classNameId, 7504 java.lang.String templateId) 7505 throws com.liferay.portal.kernel.exception.SystemException { 7506 return getPersistence().countByG_C_T(groupId, classNameId, templateId); 7507 } 7508 7509 /** 7510 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and templateId = ?. 7511 * 7512 * @param groupId the group ID 7513 * @param classNameId the class name ID 7514 * @param templateId the template ID 7515 * @return the number of matching journal articles that the user has permission to view 7516 * @throws SystemException if a system exception occurred 7517 */ 7518 public static int filterCountByG_C_T(long groupId, long classNameId, 7519 java.lang.String templateId) 7520 throws com.liferay.portal.kernel.exception.SystemException { 7521 return getPersistence() 7522 .filterCountByG_C_T(groupId, classNameId, templateId); 7523 } 7524 7525 /** 7526 * Returns all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 7527 * 7528 * @param groupId the group ID 7529 * @param classNameId the class name ID 7530 * @param layoutUuid the layout uuid 7531 * @return the matching journal articles 7532 * @throws SystemException if a system exception occurred 7533 */ 7534 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 7535 long groupId, long classNameId, java.lang.String layoutUuid) 7536 throws com.liferay.portal.kernel.exception.SystemException { 7537 return getPersistence().findByG_C_L(groupId, classNameId, layoutUuid); 7538 } 7539 7540 /** 7541 * Returns a range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 7542 * 7543 * <p> 7544 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7545 * </p> 7546 * 7547 * @param groupId the group ID 7548 * @param classNameId the class name ID 7549 * @param layoutUuid the layout uuid 7550 * @param start the lower bound of the range of journal articles 7551 * @param end the upper bound of the range of journal articles (not inclusive) 7552 * @return the range of matching journal articles 7553 * @throws SystemException if a system exception occurred 7554 */ 7555 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 7556 long groupId, long classNameId, java.lang.String layoutUuid, int start, 7557 int end) throws com.liferay.portal.kernel.exception.SystemException { 7558 return getPersistence() 7559 .findByG_C_L(groupId, classNameId, layoutUuid, start, end); 7560 } 7561 7562 /** 7563 * Returns an ordered range of all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 7564 * 7565 * <p> 7566 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7567 * </p> 7568 * 7569 * @param groupId the group ID 7570 * @param classNameId the class name ID 7571 * @param layoutUuid the layout uuid 7572 * @param start the lower bound of the range of journal articles 7573 * @param end the upper bound of the range of journal articles (not inclusive) 7574 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7575 * @return the ordered range of matching journal articles 7576 * @throws SystemException if a system exception occurred 7577 */ 7578 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_C_L( 7579 long groupId, long classNameId, java.lang.String layoutUuid, int start, 7580 int end, 7581 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7582 throws com.liferay.portal.kernel.exception.SystemException { 7583 return getPersistence() 7584 .findByG_C_L(groupId, classNameId, layoutUuid, start, end, 7585 orderByComparator); 7586 } 7587 7588 /** 7589 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7590 * 7591 * @param groupId the group ID 7592 * @param classNameId the class name ID 7593 * @param layoutUuid the layout uuid 7594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7595 * @return the first matching journal article 7596 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7597 * @throws SystemException if a system exception occurred 7598 */ 7599 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_First( 7600 long groupId, long classNameId, java.lang.String layoutUuid, 7601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7602 throws com.liferay.portal.kernel.exception.SystemException, 7603 com.liferay.portlet.journal.NoSuchArticleException { 7604 return getPersistence() 7605 .findByG_C_L_First(groupId, classNameId, layoutUuid, 7606 orderByComparator); 7607 } 7608 7609 /** 7610 * Returns the first journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7611 * 7612 * @param groupId the group ID 7613 * @param classNameId the class name ID 7614 * @param layoutUuid the layout uuid 7615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7616 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7617 * @throws SystemException if a system exception occurred 7618 */ 7619 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_First( 7620 long groupId, long classNameId, java.lang.String layoutUuid, 7621 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7622 throws com.liferay.portal.kernel.exception.SystemException { 7623 return getPersistence() 7624 .fetchByG_C_L_First(groupId, classNameId, layoutUuid, 7625 orderByComparator); 7626 } 7627 7628 /** 7629 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7630 * 7631 * @param groupId the group ID 7632 * @param classNameId the class name ID 7633 * @param layoutUuid the layout uuid 7634 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7635 * @return the last matching journal article 7636 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7637 * @throws SystemException if a system exception occurred 7638 */ 7639 public static com.liferay.portlet.journal.model.JournalArticle findByG_C_L_Last( 7640 long groupId, long classNameId, java.lang.String layoutUuid, 7641 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7642 throws com.liferay.portal.kernel.exception.SystemException, 7643 com.liferay.portlet.journal.NoSuchArticleException { 7644 return getPersistence() 7645 .findByG_C_L_Last(groupId, classNameId, layoutUuid, 7646 orderByComparator); 7647 } 7648 7649 /** 7650 * Returns the last journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7651 * 7652 * @param groupId the group ID 7653 * @param classNameId the class name ID 7654 * @param layoutUuid the layout uuid 7655 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7656 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 7657 * @throws SystemException if a system exception occurred 7658 */ 7659 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_C_L_Last( 7660 long groupId, long classNameId, java.lang.String layoutUuid, 7661 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7662 throws com.liferay.portal.kernel.exception.SystemException { 7663 return getPersistence() 7664 .fetchByG_C_L_Last(groupId, classNameId, layoutUuid, 7665 orderByComparator); 7666 } 7667 7668 /** 7669 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and classNameId = ? and layoutUuid = ?. 7670 * 7671 * @param id the primary key of the current journal article 7672 * @param groupId the group ID 7673 * @param classNameId the class name ID 7674 * @param layoutUuid the layout uuid 7675 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7676 * @return the previous, current, and next journal article 7677 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7678 * @throws SystemException if a system exception occurred 7679 */ 7680 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_C_L_PrevAndNext( 7681 long id, long groupId, long classNameId, java.lang.String layoutUuid, 7682 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7683 throws com.liferay.portal.kernel.exception.SystemException, 7684 com.liferay.portlet.journal.NoSuchArticleException { 7685 return getPersistence() 7686 .findByG_C_L_PrevAndNext(id, groupId, classNameId, 7687 layoutUuid, orderByComparator); 7688 } 7689 7690 /** 7691 * Returns all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7692 * 7693 * @param groupId the group ID 7694 * @param classNameId the class name ID 7695 * @param layoutUuid the layout uuid 7696 * @return the matching journal articles that the user has permission to view 7697 * @throws SystemException if a system exception occurred 7698 */ 7699 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7700 long groupId, long classNameId, java.lang.String layoutUuid) 7701 throws com.liferay.portal.kernel.exception.SystemException { 7702 return getPersistence() 7703 .filterFindByG_C_L(groupId, classNameId, layoutUuid); 7704 } 7705 7706 /** 7707 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7708 * 7709 * <p> 7710 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7711 * </p> 7712 * 7713 * @param groupId the group ID 7714 * @param classNameId the class name ID 7715 * @param layoutUuid the layout uuid 7716 * @param start the lower bound of the range of journal articles 7717 * @param end the upper bound of the range of journal articles (not inclusive) 7718 * @return the range of matching journal articles that the user has permission to view 7719 * @throws SystemException if a system exception occurred 7720 */ 7721 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7722 long groupId, long classNameId, java.lang.String layoutUuid, int start, 7723 int end) throws com.liferay.portal.kernel.exception.SystemException { 7724 return getPersistence() 7725 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 7726 end); 7727 } 7728 7729 /** 7730 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7731 * 7732 * <p> 7733 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7734 * </p> 7735 * 7736 * @param groupId the group ID 7737 * @param classNameId the class name ID 7738 * @param layoutUuid the layout uuid 7739 * @param start the lower bound of the range of journal articles 7740 * @param end the upper bound of the range of journal articles (not inclusive) 7741 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7742 * @return the ordered range of matching journal articles that the user has permission to view 7743 * @throws SystemException if a system exception occurred 7744 */ 7745 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_C_L( 7746 long groupId, long classNameId, java.lang.String layoutUuid, int start, 7747 int end, 7748 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7749 throws com.liferay.portal.kernel.exception.SystemException { 7750 return getPersistence() 7751 .filterFindByG_C_L(groupId, classNameId, layoutUuid, start, 7752 end, orderByComparator); 7753 } 7754 7755 /** 7756 * 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 = ?. 7757 * 7758 * @param id the primary key of the current journal article 7759 * @param groupId the group ID 7760 * @param classNameId the class name ID 7761 * @param layoutUuid the layout uuid 7762 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7763 * @return the previous, current, and next journal article 7764 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 7765 * @throws SystemException if a system exception occurred 7766 */ 7767 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_C_L_PrevAndNext( 7768 long id, long groupId, long classNameId, java.lang.String layoutUuid, 7769 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7770 throws com.liferay.portal.kernel.exception.SystemException, 7771 com.liferay.portlet.journal.NoSuchArticleException { 7772 return getPersistence() 7773 .filterFindByG_C_L_PrevAndNext(id, groupId, classNameId, 7774 layoutUuid, orderByComparator); 7775 } 7776 7777 /** 7778 * Removes all the journal articles where groupId = ? and classNameId = ? and layoutUuid = ? from the database. 7779 * 7780 * @param groupId the group ID 7781 * @param classNameId the class name ID 7782 * @param layoutUuid the layout uuid 7783 * @throws SystemException if a system exception occurred 7784 */ 7785 public static void removeByG_C_L(long groupId, long classNameId, 7786 java.lang.String layoutUuid) 7787 throws com.liferay.portal.kernel.exception.SystemException { 7788 getPersistence().removeByG_C_L(groupId, classNameId, layoutUuid); 7789 } 7790 7791 /** 7792 * Returns the number of journal articles where groupId = ? and classNameId = ? and layoutUuid = ?. 7793 * 7794 * @param groupId the group ID 7795 * @param classNameId the class name ID 7796 * @param layoutUuid the layout uuid 7797 * @return the number of matching journal articles 7798 * @throws SystemException if a system exception occurred 7799 */ 7800 public static int countByG_C_L(long groupId, long classNameId, 7801 java.lang.String layoutUuid) 7802 throws com.liferay.portal.kernel.exception.SystemException { 7803 return getPersistence().countByG_C_L(groupId, classNameId, layoutUuid); 7804 } 7805 7806 /** 7807 * Returns the number of journal articles that the user has permission to view where groupId = ? and classNameId = ? and layoutUuid = ?. 7808 * 7809 * @param groupId the group ID 7810 * @param classNameId the class name ID 7811 * @param layoutUuid the layout uuid 7812 * @return the number of matching journal articles that the user has permission to view 7813 * @throws SystemException if a system exception occurred 7814 */ 7815 public static int filterCountByG_C_L(long groupId, long classNameId, 7816 java.lang.String layoutUuid) 7817 throws com.liferay.portal.kernel.exception.SystemException { 7818 return getPersistence() 7819 .filterCountByG_C_L(groupId, classNameId, layoutUuid); 7820 } 7821 7822 /** 7823 * 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. 7824 * 7825 * @param groupId the group ID 7826 * @param articleId the article ID 7827 * @param version the version 7828 * @return the matching journal article 7829 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7830 * @throws SystemException if a system exception occurred 7831 */ 7832 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_V( 7833 long groupId, java.lang.String articleId, double version) 7834 throws com.liferay.portal.kernel.exception.SystemException, 7835 com.liferay.portlet.journal.NoSuchArticleException { 7836 return getPersistence().findByG_A_V(groupId, articleId, version); 7837 } 7838 7839 /** 7840 * 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. 7841 * 7842 * @param groupId the group ID 7843 * @param articleId the article ID 7844 * @param version the version 7845 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7846 * @throws SystemException if a system exception occurred 7847 */ 7848 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 7849 long groupId, java.lang.String articleId, double version) 7850 throws com.liferay.portal.kernel.exception.SystemException { 7851 return getPersistence().fetchByG_A_V(groupId, articleId, version); 7852 } 7853 7854 /** 7855 * 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. 7856 * 7857 * @param groupId the group ID 7858 * @param articleId the article ID 7859 * @param version the version 7860 * @param retrieveFromCache whether to use the finder cache 7861 * @return the matching journal article, or <code>null</code> if a matching journal article could not be found 7862 * @throws SystemException if a system exception occurred 7863 */ 7864 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_V( 7865 long groupId, java.lang.String articleId, double version, 7866 boolean retrieveFromCache) 7867 throws com.liferay.portal.kernel.exception.SystemException { 7868 return getPersistence() 7869 .fetchByG_A_V(groupId, articleId, version, retrieveFromCache); 7870 } 7871 7872 /** 7873 * Removes the journal article where groupId = ? and articleId = ? and version = ? from the database. 7874 * 7875 * @param groupId the group ID 7876 * @param articleId the article ID 7877 * @param version the version 7878 * @return the journal article that was removed 7879 * @throws SystemException if a system exception occurred 7880 */ 7881 public static com.liferay.portlet.journal.model.JournalArticle removeByG_A_V( 7882 long groupId, java.lang.String articleId, double version) 7883 throws com.liferay.portal.kernel.exception.SystemException, 7884 com.liferay.portlet.journal.NoSuchArticleException { 7885 return getPersistence().removeByG_A_V(groupId, articleId, version); 7886 } 7887 7888 /** 7889 * Returns the number of journal articles where groupId = ? and articleId = ? and version = ?. 7890 * 7891 * @param groupId the group ID 7892 * @param articleId the article ID 7893 * @param version the version 7894 * @return the number of matching journal articles 7895 * @throws SystemException if a system exception occurred 7896 */ 7897 public static int countByG_A_V(long groupId, java.lang.String articleId, 7898 double version) 7899 throws com.liferay.portal.kernel.exception.SystemException { 7900 return getPersistence().countByG_A_V(groupId, articleId, version); 7901 } 7902 7903 /** 7904 * Returns all the journal articles where groupId = ? and articleId = ? and status = ?. 7905 * 7906 * @param groupId the group ID 7907 * @param articleId the article ID 7908 * @param status the status 7909 * @return the matching journal articles 7910 * @throws SystemException if a system exception occurred 7911 */ 7912 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7913 long groupId, java.lang.String articleId, int status) 7914 throws com.liferay.portal.kernel.exception.SystemException { 7915 return getPersistence().findByG_A_ST(groupId, articleId, status); 7916 } 7917 7918 /** 7919 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = ?. 7920 * 7921 * <p> 7922 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7923 * </p> 7924 * 7925 * @param groupId the group ID 7926 * @param articleId the article ID 7927 * @param status the status 7928 * @param start the lower bound of the range of journal articles 7929 * @param end the upper bound of the range of journal articles (not inclusive) 7930 * @return the range of matching journal articles 7931 * @throws SystemException if a system exception occurred 7932 */ 7933 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7934 long groupId, java.lang.String articleId, int status, int start, int end) 7935 throws com.liferay.portal.kernel.exception.SystemException { 7936 return getPersistence() 7937 .findByG_A_ST(groupId, articleId, status, start, end); 7938 } 7939 7940 /** 7941 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = ?. 7942 * 7943 * <p> 7944 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 7945 * </p> 7946 * 7947 * @param groupId the group ID 7948 * @param articleId the article ID 7949 * @param status the status 7950 * @param start the lower bound of the range of journal articles 7951 * @param end the upper bound of the range of journal articles (not inclusive) 7952 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 7953 * @return the ordered range of matching journal articles 7954 * @throws SystemException if a system exception occurred 7955 */ 7956 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 7957 long groupId, java.lang.String articleId, int status, int start, 7958 int end, 7959 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7960 throws com.liferay.portal.kernel.exception.SystemException { 7961 return getPersistence() 7962 .findByG_A_ST(groupId, articleId, status, start, end, 7963 orderByComparator); 7964 } 7965 7966 /** 7967 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7968 * 7969 * @param groupId the group ID 7970 * @param articleId the article ID 7971 * @param status the status 7972 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7973 * @return the first matching journal article 7974 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 7975 * @throws SystemException if a system exception occurred 7976 */ 7977 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_First( 7978 long groupId, java.lang.String articleId, int status, 7979 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 7980 throws com.liferay.portal.kernel.exception.SystemException, 7981 com.liferay.portlet.journal.NoSuchArticleException { 7982 return getPersistence() 7983 .findByG_A_ST_First(groupId, articleId, status, 7984 orderByComparator); 7985 } 7986 7987 /** 7988 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 7989 * 7990 * @param groupId the group ID 7991 * @param articleId the article ID 7992 * @param status the status 7993 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 7994 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 7995 * @throws SystemException if a system exception occurred 7996 */ 7997 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_First( 7998 long groupId, java.lang.String articleId, int status, 7999 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8000 throws com.liferay.portal.kernel.exception.SystemException { 8001 return getPersistence() 8002 .fetchByG_A_ST_First(groupId, articleId, status, 8003 orderByComparator); 8004 } 8005 8006 /** 8007 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 8008 * 8009 * @param groupId the group ID 8010 * @param articleId the article ID 8011 * @param status the status 8012 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8013 * @return the last matching journal article 8014 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8015 * @throws SystemException if a system exception occurred 8016 */ 8017 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_ST_Last( 8018 long groupId, java.lang.String articleId, int status, 8019 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8020 throws com.liferay.portal.kernel.exception.SystemException, 8021 com.liferay.portlet.journal.NoSuchArticleException { 8022 return getPersistence() 8023 .findByG_A_ST_Last(groupId, articleId, status, 8024 orderByComparator); 8025 } 8026 8027 /** 8028 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 8029 * 8030 * @param groupId the group ID 8031 * @param articleId the article ID 8032 * @param status the status 8033 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8034 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 8035 * @throws SystemException if a system exception occurred 8036 */ 8037 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_ST_Last( 8038 long groupId, java.lang.String articleId, int status, 8039 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8040 throws com.liferay.portal.kernel.exception.SystemException { 8041 return getPersistence() 8042 .fetchByG_A_ST_Last(groupId, articleId, status, 8043 orderByComparator); 8044 } 8045 8046 /** 8047 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status = ?. 8048 * 8049 * @param id the primary key of the current journal article 8050 * @param groupId the group ID 8051 * @param articleId the article ID 8052 * @param status the status 8053 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8054 * @return the previous, current, and next journal article 8055 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8056 * @throws SystemException if a system exception occurred 8057 */ 8058 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_ST_PrevAndNext( 8059 long id, long groupId, java.lang.String articleId, int status, 8060 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8061 throws com.liferay.portal.kernel.exception.SystemException, 8062 com.liferay.portlet.journal.NoSuchArticleException { 8063 return getPersistence() 8064 .findByG_A_ST_PrevAndNext(id, groupId, articleId, status, 8065 orderByComparator); 8066 } 8067 8068 /** 8069 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 8070 * 8071 * @param groupId the group ID 8072 * @param articleId the article ID 8073 * @param status the status 8074 * @return the matching journal articles that the user has permission to view 8075 * @throws SystemException if a system exception occurred 8076 */ 8077 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 8078 long groupId, java.lang.String articleId, int status) 8079 throws com.liferay.portal.kernel.exception.SystemException { 8080 return getPersistence().filterFindByG_A_ST(groupId, articleId, status); 8081 } 8082 8083 /** 8084 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 8085 * 8086 * <p> 8087 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8088 * </p> 8089 * 8090 * @param groupId the group ID 8091 * @param articleId the article ID 8092 * @param status the status 8093 * @param start the lower bound of the range of journal articles 8094 * @param end the upper bound of the range of journal articles (not inclusive) 8095 * @return the range of matching journal articles that the user has permission to view 8096 * @throws SystemException if a system exception occurred 8097 */ 8098 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 8099 long groupId, java.lang.String articleId, int status, int start, int end) 8100 throws com.liferay.portal.kernel.exception.SystemException { 8101 return getPersistence() 8102 .filterFindByG_A_ST(groupId, articleId, status, start, end); 8103 } 8104 8105 /** 8106 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status = ?. 8107 * 8108 * <p> 8109 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8110 * </p> 8111 * 8112 * @param groupId the group ID 8113 * @param articleId the article ID 8114 * @param status the status 8115 * @param start the lower bound of the range of journal articles 8116 * @param end the upper bound of the range of journal articles (not inclusive) 8117 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8118 * @return the ordered range of matching journal articles that the user has permission to view 8119 * @throws SystemException if a system exception occurred 8120 */ 8121 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 8122 long groupId, java.lang.String articleId, int status, int start, 8123 int end, 8124 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8125 throws com.liferay.portal.kernel.exception.SystemException { 8126 return getPersistence() 8127 .filterFindByG_A_ST(groupId, articleId, status, start, end, 8128 orderByComparator); 8129 } 8130 8131 /** 8132 * 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 = ?. 8133 * 8134 * @param id the primary key of the current journal article 8135 * @param groupId the group ID 8136 * @param articleId the article ID 8137 * @param status the status 8138 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8139 * @return the previous, current, and next journal article 8140 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8141 * @throws SystemException if a system exception occurred 8142 */ 8143 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_ST_PrevAndNext( 8144 long id, long groupId, java.lang.String articleId, int status, 8145 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8146 throws com.liferay.portal.kernel.exception.SystemException, 8147 com.liferay.portlet.journal.NoSuchArticleException { 8148 return getPersistence() 8149 .filterFindByG_A_ST_PrevAndNext(id, groupId, articleId, 8150 status, orderByComparator); 8151 } 8152 8153 /** 8154 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 8155 * 8156 * @param groupId the group ID 8157 * @param articleId the article ID 8158 * @param statuses the statuses 8159 * @return the matching journal articles that the user has permission to view 8160 * @throws SystemException if a system exception occurred 8161 */ 8162 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 8163 long groupId, java.lang.String articleId, int[] statuses) 8164 throws com.liferay.portal.kernel.exception.SystemException { 8165 return getPersistence().filterFindByG_A_ST(groupId, articleId, statuses); 8166 } 8167 8168 /** 8169 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 8170 * 8171 * <p> 8172 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8173 * </p> 8174 * 8175 * @param groupId the group ID 8176 * @param articleId the article ID 8177 * @param statuses the statuses 8178 * @param start the lower bound of the range of journal articles 8179 * @param end the upper bound of the range of journal articles (not inclusive) 8180 * @return the range of matching journal articles that the user has permission to view 8181 * @throws SystemException if a system exception occurred 8182 */ 8183 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 8184 long groupId, java.lang.String articleId, int[] statuses, int start, 8185 int end) throws com.liferay.portal.kernel.exception.SystemException { 8186 return getPersistence() 8187 .filterFindByG_A_ST(groupId, articleId, statuses, start, end); 8188 } 8189 8190 /** 8191 * Returns an ordered range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 8192 * 8193 * <p> 8194 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8195 * </p> 8196 * 8197 * @param groupId the group ID 8198 * @param articleId the article ID 8199 * @param statuses the statuses 8200 * @param start the lower bound of the range of journal articles 8201 * @param end the upper bound of the range of journal articles (not inclusive) 8202 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8203 * @return the ordered range of matching journal articles that the user has permission to view 8204 * @throws SystemException if a system exception occurred 8205 */ 8206 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_ST( 8207 long groupId, java.lang.String articleId, int[] statuses, int start, 8208 int end, 8209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8210 throws com.liferay.portal.kernel.exception.SystemException { 8211 return getPersistence() 8212 .filterFindByG_A_ST(groupId, articleId, statuses, start, 8213 end, orderByComparator); 8214 } 8215 8216 /** 8217 * Returns all the journal articles where groupId = ? and articleId = ? and status = any ?. 8218 * 8219 * <p> 8220 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8221 * </p> 8222 * 8223 * @param groupId the group ID 8224 * @param articleId the article ID 8225 * @param statuses the statuses 8226 * @return the matching journal articles 8227 * @throws SystemException if a system exception occurred 8228 */ 8229 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 8230 long groupId, java.lang.String articleId, int[] statuses) 8231 throws com.liferay.portal.kernel.exception.SystemException { 8232 return getPersistence().findByG_A_ST(groupId, articleId, statuses); 8233 } 8234 8235 /** 8236 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 8237 * 8238 * <p> 8239 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8240 * </p> 8241 * 8242 * @param groupId the group ID 8243 * @param articleId the article ID 8244 * @param statuses the statuses 8245 * @param start the lower bound of the range of journal articles 8246 * @param end the upper bound of the range of journal articles (not inclusive) 8247 * @return the range of matching journal articles 8248 * @throws SystemException if a system exception occurred 8249 */ 8250 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 8251 long groupId, java.lang.String articleId, int[] statuses, int start, 8252 int end) throws com.liferay.portal.kernel.exception.SystemException { 8253 return getPersistence() 8254 .findByG_A_ST(groupId, articleId, statuses, start, end); 8255 } 8256 8257 /** 8258 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status = any ?. 8259 * 8260 * <p> 8261 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8262 * </p> 8263 * 8264 * @param groupId the group ID 8265 * @param articleId the article ID 8266 * @param statuses the statuses 8267 * @param start the lower bound of the range of journal articles 8268 * @param end the upper bound of the range of journal articles (not inclusive) 8269 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8270 * @return the ordered range of matching journal articles 8271 * @throws SystemException if a system exception occurred 8272 */ 8273 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_ST( 8274 long groupId, java.lang.String articleId, int[] statuses, int start, 8275 int end, 8276 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8277 throws com.liferay.portal.kernel.exception.SystemException { 8278 return getPersistence() 8279 .findByG_A_ST(groupId, articleId, statuses, start, end, 8280 orderByComparator); 8281 } 8282 8283 /** 8284 * Removes all the journal articles where groupId = ? and articleId = ? and status = ? from the database. 8285 * 8286 * @param groupId the group ID 8287 * @param articleId the article ID 8288 * @param status the status 8289 * @throws SystemException if a system exception occurred 8290 */ 8291 public static void removeByG_A_ST(long groupId, java.lang.String articleId, 8292 int status) throws com.liferay.portal.kernel.exception.SystemException { 8293 getPersistence().removeByG_A_ST(groupId, articleId, status); 8294 } 8295 8296 /** 8297 * Returns the number of journal articles where groupId = ? and articleId = ? and status = ?. 8298 * 8299 * @param groupId the group ID 8300 * @param articleId the article ID 8301 * @param status the status 8302 * @return the number of matching journal articles 8303 * @throws SystemException if a system exception occurred 8304 */ 8305 public static int countByG_A_ST(long groupId, java.lang.String articleId, 8306 int status) throws com.liferay.portal.kernel.exception.SystemException { 8307 return getPersistence().countByG_A_ST(groupId, articleId, status); 8308 } 8309 8310 /** 8311 * Returns the number of journal articles where groupId = ? and articleId = ? and status = any ?. 8312 * 8313 * @param groupId the group ID 8314 * @param articleId the article ID 8315 * @param statuses the statuses 8316 * @return the number of matching journal articles 8317 * @throws SystemException if a system exception occurred 8318 */ 8319 public static int countByG_A_ST(long groupId, java.lang.String articleId, 8320 int[] statuses) 8321 throws com.liferay.portal.kernel.exception.SystemException { 8322 return getPersistence().countByG_A_ST(groupId, articleId, statuses); 8323 } 8324 8325 /** 8326 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = ?. 8327 * 8328 * @param groupId the group ID 8329 * @param articleId the article ID 8330 * @param status the status 8331 * @return the number of matching journal articles that the user has permission to view 8332 * @throws SystemException if a system exception occurred 8333 */ 8334 public static int filterCountByG_A_ST(long groupId, 8335 java.lang.String articleId, int status) 8336 throws com.liferay.portal.kernel.exception.SystemException { 8337 return getPersistence().filterCountByG_A_ST(groupId, articleId, status); 8338 } 8339 8340 /** 8341 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status = any ?. 8342 * 8343 * @param groupId the group ID 8344 * @param articleId the article ID 8345 * @param statuses the statuses 8346 * @return the number of matching journal articles that the user has permission to view 8347 * @throws SystemException if a system exception occurred 8348 */ 8349 public static int filterCountByG_A_ST(long groupId, 8350 java.lang.String articleId, int[] statuses) 8351 throws com.liferay.portal.kernel.exception.SystemException { 8352 return getPersistence().filterCountByG_A_ST(groupId, articleId, statuses); 8353 } 8354 8355 /** 8356 * Returns all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 8357 * 8358 * @param groupId the group ID 8359 * @param articleId the article ID 8360 * @param status the status 8361 * @return the matching journal articles 8362 * @throws SystemException if a system exception occurred 8363 */ 8364 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 8365 long groupId, java.lang.String articleId, int status) 8366 throws com.liferay.portal.kernel.exception.SystemException { 8367 return getPersistence().findByG_A_NotST(groupId, articleId, status); 8368 } 8369 8370 /** 8371 * Returns a range of all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 8372 * 8373 * <p> 8374 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8375 * </p> 8376 * 8377 * @param groupId the group ID 8378 * @param articleId the article ID 8379 * @param status the status 8380 * @param start the lower bound of the range of journal articles 8381 * @param end the upper bound of the range of journal articles (not inclusive) 8382 * @return the range of matching journal articles 8383 * @throws SystemException if a system exception occurred 8384 */ 8385 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 8386 long groupId, java.lang.String articleId, int status, int start, int end) 8387 throws com.liferay.portal.kernel.exception.SystemException { 8388 return getPersistence() 8389 .findByG_A_NotST(groupId, articleId, status, start, end); 8390 } 8391 8392 /** 8393 * Returns an ordered range of all the journal articles where groupId = ? and articleId = ? and status ≠ ?. 8394 * 8395 * <p> 8396 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8397 * </p> 8398 * 8399 * @param groupId the group ID 8400 * @param articleId the article ID 8401 * @param status the status 8402 * @param start the lower bound of the range of journal articles 8403 * @param end the upper bound of the range of journal articles (not inclusive) 8404 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8405 * @return the ordered range of matching journal articles 8406 * @throws SystemException if a system exception occurred 8407 */ 8408 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_A_NotST( 8409 long groupId, java.lang.String articleId, int status, int start, 8410 int end, 8411 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8412 throws com.liferay.portal.kernel.exception.SystemException { 8413 return getPersistence() 8414 .findByG_A_NotST(groupId, articleId, status, start, end, 8415 orderByComparator); 8416 } 8417 8418 /** 8419 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 8420 * 8421 * @param groupId the group ID 8422 * @param articleId the article ID 8423 * @param status the status 8424 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8425 * @return the first matching journal article 8426 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8427 * @throws SystemException if a system exception occurred 8428 */ 8429 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_First( 8430 long groupId, java.lang.String articleId, int status, 8431 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8432 throws com.liferay.portal.kernel.exception.SystemException, 8433 com.liferay.portlet.journal.NoSuchArticleException { 8434 return getPersistence() 8435 .findByG_A_NotST_First(groupId, articleId, status, 8436 orderByComparator); 8437 } 8438 8439 /** 8440 * Returns the first journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 8441 * 8442 * @param groupId the group ID 8443 * @param articleId the article ID 8444 * @param status the status 8445 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8446 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 8447 * @throws SystemException if a system exception occurred 8448 */ 8449 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_First( 8450 long groupId, java.lang.String articleId, int status, 8451 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8452 throws com.liferay.portal.kernel.exception.SystemException { 8453 return getPersistence() 8454 .fetchByG_A_NotST_First(groupId, articleId, status, 8455 orderByComparator); 8456 } 8457 8458 /** 8459 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 8460 * 8461 * @param groupId the group ID 8462 * @param articleId the article ID 8463 * @param status the status 8464 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8465 * @return the last matching journal article 8466 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8467 * @throws SystemException if a system exception occurred 8468 */ 8469 public static com.liferay.portlet.journal.model.JournalArticle findByG_A_NotST_Last( 8470 long groupId, java.lang.String articleId, int status, 8471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8472 throws com.liferay.portal.kernel.exception.SystemException, 8473 com.liferay.portlet.journal.NoSuchArticleException { 8474 return getPersistence() 8475 .findByG_A_NotST_Last(groupId, articleId, status, 8476 orderByComparator); 8477 } 8478 8479 /** 8480 * Returns the last journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 8481 * 8482 * @param groupId the group ID 8483 * @param articleId the article ID 8484 * @param status the status 8485 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8486 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 8487 * @throws SystemException if a system exception occurred 8488 */ 8489 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_A_NotST_Last( 8490 long groupId, java.lang.String articleId, int status, 8491 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8492 throws com.liferay.portal.kernel.exception.SystemException { 8493 return getPersistence() 8494 .fetchByG_A_NotST_Last(groupId, articleId, status, 8495 orderByComparator); 8496 } 8497 8498 /** 8499 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and articleId = ? and status ≠ ?. 8500 * 8501 * @param id the primary key of the current journal article 8502 * @param groupId the group ID 8503 * @param articleId the article ID 8504 * @param status the status 8505 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8506 * @return the previous, current, and next journal article 8507 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8508 * @throws SystemException if a system exception occurred 8509 */ 8510 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_A_NotST_PrevAndNext( 8511 long id, long groupId, java.lang.String articleId, int status, 8512 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8513 throws com.liferay.portal.kernel.exception.SystemException, 8514 com.liferay.portlet.journal.NoSuchArticleException { 8515 return getPersistence() 8516 .findByG_A_NotST_PrevAndNext(id, groupId, articleId, status, 8517 orderByComparator); 8518 } 8519 8520 /** 8521 * Returns all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 8522 * 8523 * @param groupId the group ID 8524 * @param articleId the article ID 8525 * @param status the status 8526 * @return the matching journal articles that the user has permission to view 8527 * @throws SystemException if a system exception occurred 8528 */ 8529 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 8530 long groupId, java.lang.String articleId, int status) 8531 throws com.liferay.portal.kernel.exception.SystemException { 8532 return getPersistence().filterFindByG_A_NotST(groupId, articleId, status); 8533 } 8534 8535 /** 8536 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 8537 * 8538 * <p> 8539 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8540 * </p> 8541 * 8542 * @param groupId the group ID 8543 * @param articleId the article ID 8544 * @param status the status 8545 * @param start the lower bound of the range of journal articles 8546 * @param end the upper bound of the range of journal articles (not inclusive) 8547 * @return the range of matching journal articles that the user has permission to view 8548 * @throws SystemException if a system exception occurred 8549 */ 8550 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 8551 long groupId, java.lang.String articleId, int status, int start, int end) 8552 throws com.liferay.portal.kernel.exception.SystemException { 8553 return getPersistence() 8554 .filterFindByG_A_NotST(groupId, articleId, status, start, end); 8555 } 8556 8557 /** 8558 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and articleId = ? and status ≠ ?. 8559 * 8560 * <p> 8561 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8562 * </p> 8563 * 8564 * @param groupId the group ID 8565 * @param articleId the article ID 8566 * @param status the status 8567 * @param start the lower bound of the range of journal articles 8568 * @param end the upper bound of the range of journal articles (not inclusive) 8569 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8570 * @return the ordered range of matching journal articles that the user has permission to view 8571 * @throws SystemException if a system exception occurred 8572 */ 8573 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_A_NotST( 8574 long groupId, java.lang.String articleId, int status, int start, 8575 int end, 8576 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8577 throws com.liferay.portal.kernel.exception.SystemException { 8578 return getPersistence() 8579 .filterFindByG_A_NotST(groupId, articleId, status, start, 8580 end, orderByComparator); 8581 } 8582 8583 /** 8584 * 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 ≠ ?. 8585 * 8586 * @param id the primary key of the current journal article 8587 * @param groupId the group ID 8588 * @param articleId the article ID 8589 * @param status the status 8590 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8591 * @return the previous, current, and next journal article 8592 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8593 * @throws SystemException if a system exception occurred 8594 */ 8595 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_A_NotST_PrevAndNext( 8596 long id, long groupId, java.lang.String articleId, int status, 8597 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8598 throws com.liferay.portal.kernel.exception.SystemException, 8599 com.liferay.portlet.journal.NoSuchArticleException { 8600 return getPersistence() 8601 .filterFindByG_A_NotST_PrevAndNext(id, groupId, articleId, 8602 status, orderByComparator); 8603 } 8604 8605 /** 8606 * Removes all the journal articles where groupId = ? and articleId = ? and status ≠ ? from the database. 8607 * 8608 * @param groupId the group ID 8609 * @param articleId the article ID 8610 * @param status the status 8611 * @throws SystemException if a system exception occurred 8612 */ 8613 public static void removeByG_A_NotST(long groupId, 8614 java.lang.String articleId, int status) 8615 throws com.liferay.portal.kernel.exception.SystemException { 8616 getPersistence().removeByG_A_NotST(groupId, articleId, status); 8617 } 8618 8619 /** 8620 * Returns the number of journal articles where groupId = ? and articleId = ? and status ≠ ?. 8621 * 8622 * @param groupId the group ID 8623 * @param articleId the article ID 8624 * @param status the status 8625 * @return the number of matching journal articles 8626 * @throws SystemException if a system exception occurred 8627 */ 8628 public static int countByG_A_NotST(long groupId, 8629 java.lang.String articleId, int status) 8630 throws com.liferay.portal.kernel.exception.SystemException { 8631 return getPersistence().countByG_A_NotST(groupId, articleId, status); 8632 } 8633 8634 /** 8635 * Returns the number of journal articles that the user has permission to view where groupId = ? and articleId = ? and status ≠ ?. 8636 * 8637 * @param groupId the group ID 8638 * @param articleId the article ID 8639 * @param status the status 8640 * @return the number of matching journal articles that the user has permission to view 8641 * @throws SystemException if a system exception occurred 8642 */ 8643 public static int filterCountByG_A_NotST(long groupId, 8644 java.lang.String articleId, int status) 8645 throws com.liferay.portal.kernel.exception.SystemException { 8646 return getPersistence() 8647 .filterCountByG_A_NotST(groupId, articleId, status); 8648 } 8649 8650 /** 8651 * Returns all the journal articles where groupId = ? and urlTitle = ? and status = ?. 8652 * 8653 * @param groupId the group ID 8654 * @param urlTitle the url title 8655 * @param status the status 8656 * @return the matching journal articles 8657 * @throws SystemException if a system exception occurred 8658 */ 8659 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 8660 long groupId, java.lang.String urlTitle, int status) 8661 throws com.liferay.portal.kernel.exception.SystemException { 8662 return getPersistence().findByG_UT_ST(groupId, urlTitle, status); 8663 } 8664 8665 /** 8666 * Returns a range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 8667 * 8668 * <p> 8669 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8670 * </p> 8671 * 8672 * @param groupId the group ID 8673 * @param urlTitle the url title 8674 * @param status the status 8675 * @param start the lower bound of the range of journal articles 8676 * @param end the upper bound of the range of journal articles (not inclusive) 8677 * @return the range of matching journal articles 8678 * @throws SystemException if a system exception occurred 8679 */ 8680 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 8681 long groupId, java.lang.String urlTitle, int status, int start, int end) 8682 throws com.liferay.portal.kernel.exception.SystemException { 8683 return getPersistence() 8684 .findByG_UT_ST(groupId, urlTitle, status, start, end); 8685 } 8686 8687 /** 8688 * Returns an ordered range of all the journal articles where groupId = ? and urlTitle = ? and status = ?. 8689 * 8690 * <p> 8691 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8692 * </p> 8693 * 8694 * @param groupId the group ID 8695 * @param urlTitle the url title 8696 * @param status the status 8697 * @param start the lower bound of the range of journal articles 8698 * @param end the upper bound of the range of journal articles (not inclusive) 8699 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8700 * @return the ordered range of matching journal articles 8701 * @throws SystemException if a system exception occurred 8702 */ 8703 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByG_UT_ST( 8704 long groupId, java.lang.String urlTitle, int status, int start, 8705 int end, 8706 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8707 throws com.liferay.portal.kernel.exception.SystemException { 8708 return getPersistence() 8709 .findByG_UT_ST(groupId, urlTitle, status, start, end, 8710 orderByComparator); 8711 } 8712 8713 /** 8714 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8715 * 8716 * @param groupId the group ID 8717 * @param urlTitle the url title 8718 * @param status the status 8719 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8720 * @return the first matching journal article 8721 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8722 * @throws SystemException if a system exception occurred 8723 */ 8724 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_First( 8725 long groupId, java.lang.String urlTitle, int status, 8726 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8727 throws com.liferay.portal.kernel.exception.SystemException, 8728 com.liferay.portlet.journal.NoSuchArticleException { 8729 return getPersistence() 8730 .findByG_UT_ST_First(groupId, urlTitle, status, 8731 orderByComparator); 8732 } 8733 8734 /** 8735 * Returns the first journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8736 * 8737 * @param groupId the group ID 8738 * @param urlTitle the url title 8739 * @param status the status 8740 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8741 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 8742 * @throws SystemException if a system exception occurred 8743 */ 8744 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_First( 8745 long groupId, java.lang.String urlTitle, int status, 8746 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8747 throws com.liferay.portal.kernel.exception.SystemException { 8748 return getPersistence() 8749 .fetchByG_UT_ST_First(groupId, urlTitle, status, 8750 orderByComparator); 8751 } 8752 8753 /** 8754 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8755 * 8756 * @param groupId the group ID 8757 * @param urlTitle the url title 8758 * @param status the status 8759 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8760 * @return the last matching journal article 8761 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 8762 * @throws SystemException if a system exception occurred 8763 */ 8764 public static com.liferay.portlet.journal.model.JournalArticle findByG_UT_ST_Last( 8765 long groupId, java.lang.String urlTitle, int status, 8766 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8767 throws com.liferay.portal.kernel.exception.SystemException, 8768 com.liferay.portlet.journal.NoSuchArticleException { 8769 return getPersistence() 8770 .findByG_UT_ST_Last(groupId, urlTitle, status, 8771 orderByComparator); 8772 } 8773 8774 /** 8775 * Returns the last journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8776 * 8777 * @param groupId the group ID 8778 * @param urlTitle the url title 8779 * @param status the status 8780 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8781 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 8782 * @throws SystemException if a system exception occurred 8783 */ 8784 public static com.liferay.portlet.journal.model.JournalArticle fetchByG_UT_ST_Last( 8785 long groupId, java.lang.String urlTitle, int status, 8786 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8787 throws com.liferay.portal.kernel.exception.SystemException { 8788 return getPersistence() 8789 .fetchByG_UT_ST_Last(groupId, urlTitle, status, 8790 orderByComparator); 8791 } 8792 8793 /** 8794 * Returns the journal articles before and after the current journal article in the ordered set where groupId = ? and urlTitle = ? and status = ?. 8795 * 8796 * @param id the primary key of the current journal article 8797 * @param groupId the group ID 8798 * @param urlTitle the url title 8799 * @param status the status 8800 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8801 * @return the previous, current, and next journal article 8802 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8803 * @throws SystemException if a system exception occurred 8804 */ 8805 public static com.liferay.portlet.journal.model.JournalArticle[] findByG_UT_ST_PrevAndNext( 8806 long id, long groupId, java.lang.String urlTitle, int status, 8807 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8808 throws com.liferay.portal.kernel.exception.SystemException, 8809 com.liferay.portlet.journal.NoSuchArticleException { 8810 return getPersistence() 8811 .findByG_UT_ST_PrevAndNext(id, groupId, urlTitle, status, 8812 orderByComparator); 8813 } 8814 8815 /** 8816 * Returns all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8817 * 8818 * @param groupId the group ID 8819 * @param urlTitle the url title 8820 * @param status the status 8821 * @return the matching journal articles that the user has permission to view 8822 * @throws SystemException if a system exception occurred 8823 */ 8824 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8825 long groupId, java.lang.String urlTitle, int status) 8826 throws com.liferay.portal.kernel.exception.SystemException { 8827 return getPersistence().filterFindByG_UT_ST(groupId, urlTitle, status); 8828 } 8829 8830 /** 8831 * Returns a range of all the journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8832 * 8833 * <p> 8834 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8835 * </p> 8836 * 8837 * @param groupId the group ID 8838 * @param urlTitle the url title 8839 * @param status the status 8840 * @param start the lower bound of the range of journal articles 8841 * @param end the upper bound of the range of journal articles (not inclusive) 8842 * @return the range of matching journal articles that the user has permission to view 8843 * @throws SystemException if a system exception occurred 8844 */ 8845 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8846 long groupId, java.lang.String urlTitle, int status, int start, int end) 8847 throws com.liferay.portal.kernel.exception.SystemException { 8848 return getPersistence() 8849 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end); 8850 } 8851 8852 /** 8853 * Returns an ordered range of all the journal articles that the user has permissions to view where groupId = ? and urlTitle = ? and status = ?. 8854 * 8855 * <p> 8856 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8857 * </p> 8858 * 8859 * @param groupId the group ID 8860 * @param urlTitle the url title 8861 * @param status the status 8862 * @param start the lower bound of the range of journal articles 8863 * @param end the upper bound of the range of journal articles (not inclusive) 8864 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8865 * @return the ordered range of matching journal articles that the user has permission to view 8866 * @throws SystemException if a system exception occurred 8867 */ 8868 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> filterFindByG_UT_ST( 8869 long groupId, java.lang.String urlTitle, int status, int start, 8870 int end, 8871 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8872 throws com.liferay.portal.kernel.exception.SystemException { 8873 return getPersistence() 8874 .filterFindByG_UT_ST(groupId, urlTitle, status, start, end, 8875 orderByComparator); 8876 } 8877 8878 /** 8879 * 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 = ?. 8880 * 8881 * @param id the primary key of the current journal article 8882 * @param groupId the group ID 8883 * @param urlTitle the url title 8884 * @param status the status 8885 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 8886 * @return the previous, current, and next journal article 8887 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 8888 * @throws SystemException if a system exception occurred 8889 */ 8890 public static com.liferay.portlet.journal.model.JournalArticle[] filterFindByG_UT_ST_PrevAndNext( 8891 long id, long groupId, java.lang.String urlTitle, int status, 8892 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8893 throws com.liferay.portal.kernel.exception.SystemException, 8894 com.liferay.portlet.journal.NoSuchArticleException { 8895 return getPersistence() 8896 .filterFindByG_UT_ST_PrevAndNext(id, groupId, urlTitle, 8897 status, orderByComparator); 8898 } 8899 8900 /** 8901 * Removes all the journal articles where groupId = ? and urlTitle = ? and status = ? from the database. 8902 * 8903 * @param groupId the group ID 8904 * @param urlTitle the url title 8905 * @param status the status 8906 * @throws SystemException if a system exception occurred 8907 */ 8908 public static void removeByG_UT_ST(long groupId, java.lang.String urlTitle, 8909 int status) throws com.liferay.portal.kernel.exception.SystemException { 8910 getPersistence().removeByG_UT_ST(groupId, urlTitle, status); 8911 } 8912 8913 /** 8914 * Returns the number of journal articles where groupId = ? and urlTitle = ? and status = ?. 8915 * 8916 * @param groupId the group ID 8917 * @param urlTitle the url title 8918 * @param status the status 8919 * @return the number of matching journal articles 8920 * @throws SystemException if a system exception occurred 8921 */ 8922 public static int countByG_UT_ST(long groupId, java.lang.String urlTitle, 8923 int status) throws com.liferay.portal.kernel.exception.SystemException { 8924 return getPersistence().countByG_UT_ST(groupId, urlTitle, status); 8925 } 8926 8927 /** 8928 * Returns the number of journal articles that the user has permission to view where groupId = ? and urlTitle = ? and status = ?. 8929 * 8930 * @param groupId the group ID 8931 * @param urlTitle the url title 8932 * @param status the status 8933 * @return the number of matching journal articles that the user has permission to view 8934 * @throws SystemException if a system exception occurred 8935 */ 8936 public static int filterCountByG_UT_ST(long groupId, 8937 java.lang.String urlTitle, int status) 8938 throws com.liferay.portal.kernel.exception.SystemException { 8939 return getPersistence().filterCountByG_UT_ST(groupId, urlTitle, status); 8940 } 8941 8942 /** 8943 * Returns all the journal articles where companyId = ? and version = ? and status = ?. 8944 * 8945 * @param companyId the company ID 8946 * @param version the version 8947 * @param status the status 8948 * @return the matching journal articles 8949 * @throws SystemException if a system exception occurred 8950 */ 8951 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8952 long companyId, double version, int status) 8953 throws com.liferay.portal.kernel.exception.SystemException { 8954 return getPersistence().findByC_V_ST(companyId, version, status); 8955 } 8956 8957 /** 8958 * Returns a range of all the journal articles where companyId = ? and version = ? and status = ?. 8959 * 8960 * <p> 8961 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8962 * </p> 8963 * 8964 * @param companyId the company ID 8965 * @param version the version 8966 * @param status the status 8967 * @param start the lower bound of the range of journal articles 8968 * @param end the upper bound of the range of journal articles (not inclusive) 8969 * @return the range of matching journal articles 8970 * @throws SystemException if a system exception occurred 8971 */ 8972 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8973 long companyId, double version, int status, int start, int end) 8974 throws com.liferay.portal.kernel.exception.SystemException { 8975 return getPersistence() 8976 .findByC_V_ST(companyId, version, status, start, end); 8977 } 8978 8979 /** 8980 * Returns an ordered range of all the journal articles where companyId = ? and version = ? and status = ?. 8981 * 8982 * <p> 8983 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 8984 * </p> 8985 * 8986 * @param companyId the company ID 8987 * @param version the version 8988 * @param status the status 8989 * @param start the lower bound of the range of journal articles 8990 * @param end the upper bound of the range of journal articles (not inclusive) 8991 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 8992 * @return the ordered range of matching journal articles 8993 * @throws SystemException if a system exception occurred 8994 */ 8995 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findByC_V_ST( 8996 long companyId, double version, int status, int start, int end, 8997 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 8998 throws com.liferay.portal.kernel.exception.SystemException { 8999 return getPersistence() 9000 .findByC_V_ST(companyId, version, status, start, end, 9001 orderByComparator); 9002 } 9003 9004 /** 9005 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 9006 * 9007 * @param companyId the company ID 9008 * @param version the version 9009 * @param status the status 9010 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 9011 * @return the first matching journal article 9012 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 9013 * @throws SystemException if a system exception occurred 9014 */ 9015 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_First( 9016 long companyId, double version, int status, 9017 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 9018 throws com.liferay.portal.kernel.exception.SystemException, 9019 com.liferay.portlet.journal.NoSuchArticleException { 9020 return getPersistence() 9021 .findByC_V_ST_First(companyId, version, status, 9022 orderByComparator); 9023 } 9024 9025 /** 9026 * Returns the first journal article in the ordered set where companyId = ? and version = ? and status = ?. 9027 * 9028 * @param companyId the company ID 9029 * @param version the version 9030 * @param status the status 9031 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 9032 * @return the first matching journal article, or <code>null</code> if a matching journal article could not be found 9033 * @throws SystemException if a system exception occurred 9034 */ 9035 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_First( 9036 long companyId, double version, int status, 9037 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 9038 throws com.liferay.portal.kernel.exception.SystemException { 9039 return getPersistence() 9040 .fetchByC_V_ST_First(companyId, version, status, 9041 orderByComparator); 9042 } 9043 9044 /** 9045 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 9046 * 9047 * @param companyId the company ID 9048 * @param version the version 9049 * @param status the status 9050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 9051 * @return the last matching journal article 9052 * @throws com.liferay.portlet.journal.NoSuchArticleException if a matching journal article could not be found 9053 * @throws SystemException if a system exception occurred 9054 */ 9055 public static com.liferay.portlet.journal.model.JournalArticle findByC_V_ST_Last( 9056 long companyId, double version, int status, 9057 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 9058 throws com.liferay.portal.kernel.exception.SystemException, 9059 com.liferay.portlet.journal.NoSuchArticleException { 9060 return getPersistence() 9061 .findByC_V_ST_Last(companyId, version, status, 9062 orderByComparator); 9063 } 9064 9065 /** 9066 * Returns the last journal article in the ordered set where companyId = ? and version = ? and status = ?. 9067 * 9068 * @param companyId the company ID 9069 * @param version the version 9070 * @param status the status 9071 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 9072 * @return the last matching journal article, or <code>null</code> if a matching journal article could not be found 9073 * @throws SystemException if a system exception occurred 9074 */ 9075 public static com.liferay.portlet.journal.model.JournalArticle fetchByC_V_ST_Last( 9076 long companyId, double version, int status, 9077 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 9078 throws com.liferay.portal.kernel.exception.SystemException { 9079 return getPersistence() 9080 .fetchByC_V_ST_Last(companyId, version, status, 9081 orderByComparator); 9082 } 9083 9084 /** 9085 * Returns the journal articles before and after the current journal article in the ordered set where companyId = ? and version = ? and status = ?. 9086 * 9087 * @param id the primary key of the current journal article 9088 * @param companyId the company ID 9089 * @param version the version 9090 * @param status the status 9091 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 9092 * @return the previous, current, and next journal article 9093 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 9094 * @throws SystemException if a system exception occurred 9095 */ 9096 public static com.liferay.portlet.journal.model.JournalArticle[] findByC_V_ST_PrevAndNext( 9097 long id, long companyId, double version, int status, 9098 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 9099 throws com.liferay.portal.kernel.exception.SystemException, 9100 com.liferay.portlet.journal.NoSuchArticleException { 9101 return getPersistence() 9102 .findByC_V_ST_PrevAndNext(id, companyId, version, status, 9103 orderByComparator); 9104 } 9105 9106 /** 9107 * Removes all the journal articles where companyId = ? and version = ? and status = ? from the database. 9108 * 9109 * @param companyId the company ID 9110 * @param version the version 9111 * @param status the status 9112 * @throws SystemException if a system exception occurred 9113 */ 9114 public static void removeByC_V_ST(long companyId, double version, int status) 9115 throws com.liferay.portal.kernel.exception.SystemException { 9116 getPersistence().removeByC_V_ST(companyId, version, status); 9117 } 9118 9119 /** 9120 * Returns the number of journal articles where companyId = ? and version = ? and status = ?. 9121 * 9122 * @param companyId the company ID 9123 * @param version the version 9124 * @param status the status 9125 * @return the number of matching journal articles 9126 * @throws SystemException if a system exception occurred 9127 */ 9128 public static int countByC_V_ST(long companyId, double version, int status) 9129 throws com.liferay.portal.kernel.exception.SystemException { 9130 return getPersistence().countByC_V_ST(companyId, version, status); 9131 } 9132 9133 /** 9134 * Caches the journal article in the entity cache if it is enabled. 9135 * 9136 * @param journalArticle the journal article 9137 */ 9138 public static void cacheResult( 9139 com.liferay.portlet.journal.model.JournalArticle journalArticle) { 9140 getPersistence().cacheResult(journalArticle); 9141 } 9142 9143 /** 9144 * Caches the journal articles in the entity cache if it is enabled. 9145 * 9146 * @param journalArticles the journal articles 9147 */ 9148 public static void cacheResult( 9149 java.util.List<com.liferay.portlet.journal.model.JournalArticle> journalArticles) { 9150 getPersistence().cacheResult(journalArticles); 9151 } 9152 9153 /** 9154 * Creates a new journal article with the primary key. Does not add the journal article to the database. 9155 * 9156 * @param id the primary key for the new journal article 9157 * @return the new journal article 9158 */ 9159 public static com.liferay.portlet.journal.model.JournalArticle create( 9160 long id) { 9161 return getPersistence().create(id); 9162 } 9163 9164 /** 9165 * Removes the journal article with the primary key from the database. Also notifies the appropriate model listeners. 9166 * 9167 * @param id the primary key of the journal article 9168 * @return the journal article that was removed 9169 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 9170 * @throws SystemException if a system exception occurred 9171 */ 9172 public static com.liferay.portlet.journal.model.JournalArticle remove( 9173 long id) 9174 throws com.liferay.portal.kernel.exception.SystemException, 9175 com.liferay.portlet.journal.NoSuchArticleException { 9176 return getPersistence().remove(id); 9177 } 9178 9179 public static com.liferay.portlet.journal.model.JournalArticle updateImpl( 9180 com.liferay.portlet.journal.model.JournalArticle journalArticle) 9181 throws com.liferay.portal.kernel.exception.SystemException { 9182 return getPersistence().updateImpl(journalArticle); 9183 } 9184 9185 /** 9186 * Returns the journal article with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleException} if it could not be found. 9187 * 9188 * @param id the primary key of the journal article 9189 * @return the journal article 9190 * @throws com.liferay.portlet.journal.NoSuchArticleException if a journal article with the primary key could not be found 9191 * @throws SystemException if a system exception occurred 9192 */ 9193 public static com.liferay.portlet.journal.model.JournalArticle findByPrimaryKey( 9194 long id) 9195 throws com.liferay.portal.kernel.exception.SystemException, 9196 com.liferay.portlet.journal.NoSuchArticleException { 9197 return getPersistence().findByPrimaryKey(id); 9198 } 9199 9200 /** 9201 * Returns the journal article with the primary key or returns <code>null</code> if it could not be found. 9202 * 9203 * @param id the primary key of the journal article 9204 * @return the journal article, or <code>null</code> if a journal article with the primary key could not be found 9205 * @throws SystemException if a system exception occurred 9206 */ 9207 public static com.liferay.portlet.journal.model.JournalArticle fetchByPrimaryKey( 9208 long id) throws com.liferay.portal.kernel.exception.SystemException { 9209 return getPersistence().fetchByPrimaryKey(id); 9210 } 9211 9212 /** 9213 * Returns all the journal articles. 9214 * 9215 * @return the journal articles 9216 * @throws SystemException if a system exception occurred 9217 */ 9218 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll() 9219 throws com.liferay.portal.kernel.exception.SystemException { 9220 return getPersistence().findAll(); 9221 } 9222 9223 /** 9224 * Returns a range of all the journal articles. 9225 * 9226 * <p> 9227 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 9228 * </p> 9229 * 9230 * @param start the lower bound of the range of journal articles 9231 * @param end the upper bound of the range of journal articles (not inclusive) 9232 * @return the range of journal articles 9233 * @throws SystemException if a system exception occurred 9234 */ 9235 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 9236 int start, int end) 9237 throws com.liferay.portal.kernel.exception.SystemException { 9238 return getPersistence().findAll(start, end); 9239 } 9240 9241 /** 9242 * Returns an ordered range of all the journal articles. 9243 * 9244 * <p> 9245 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.JournalArticleModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 9246 * </p> 9247 * 9248 * @param start the lower bound of the range of journal articles 9249 * @param end the upper bound of the range of journal articles (not inclusive) 9250 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 9251 * @return the ordered range of journal articles 9252 * @throws SystemException if a system exception occurred 9253 */ 9254 public static java.util.List<com.liferay.portlet.journal.model.JournalArticle> findAll( 9255 int start, int end, 9256 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 9257 throws com.liferay.portal.kernel.exception.SystemException { 9258 return getPersistence().findAll(start, end, orderByComparator); 9259 } 9260 9261 /** 9262 * Removes all the journal articles from the database. 9263 * 9264 * @throws SystemException if a system exception occurred 9265 */ 9266 public static void removeAll() 9267 throws com.liferay.portal.kernel.exception.SystemException { 9268 getPersistence().removeAll(); 9269 } 9270 9271 /** 9272 * Returns the number of journal articles. 9273 * 9274 * @return the number of journal articles 9275 * @throws SystemException if a system exception occurred 9276 */ 9277 public static int countAll() 9278 throws com.liferay.portal.kernel.exception.SystemException { 9279 return getPersistence().countAll(); 9280 } 9281 9282 public static JournalArticlePersistence getPersistence() { 9283 if (_persistence == null) { 9284 _persistence = (JournalArticlePersistence)PortalBeanLocatorUtil.locate(JournalArticlePersistence.class.getName()); 9285 9286 ReferenceRegistry.registerReference(JournalArticleUtil.class, 9287 "_persistence"); 9288 } 9289 9290 return _persistence; 9291 } 9292 9293 /** 9294 * @deprecated As of 6.2.0 9295 */ 9296 public void setPersistence(JournalArticlePersistence persistence) { 9297 } 9298 9299 private static JournalArticlePersistence _persistence; 9300 }