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