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