001 /** 002 * Copyright (c) 2000-2013 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.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.exception.SystemException; 022 import com.liferay.portal.kernel.util.OrderByComparator; 023 import com.liferay.portal.kernel.util.ReferenceRegistry; 024 import com.liferay.portal.model.BackgroundTask; 025 import com.liferay.portal.service.ServiceContext; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the background task service. This utility wraps {@link BackgroundTaskPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see BackgroundTaskPersistence 038 * @see BackgroundTaskPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class BackgroundTaskUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(BackgroundTask backgroundTask) { 060 getPersistence().clearCache(backgroundTask); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) 067 throws SystemException { 068 return getPersistence().countWithDynamicQuery(dynamicQuery); 069 } 070 071 /** 072 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 073 */ 074 public static List<BackgroundTask> findWithDynamicQuery( 075 DynamicQuery dynamicQuery) throws SystemException { 076 return getPersistence().findWithDynamicQuery(dynamicQuery); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 081 */ 082 public static List<BackgroundTask> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end) 084 throws SystemException { 085 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 086 } 087 088 /** 089 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 090 */ 091 public static List<BackgroundTask> findWithDynamicQuery( 092 DynamicQuery dynamicQuery, int start, int end, 093 OrderByComparator orderByComparator) throws SystemException { 094 return getPersistence() 095 .findWithDynamicQuery(dynamicQuery, start, end, 096 orderByComparator); 097 } 098 099 /** 100 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 101 */ 102 public static BackgroundTask update(BackgroundTask backgroundTask) 103 throws SystemException { 104 return getPersistence().update(backgroundTask); 105 } 106 107 /** 108 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 109 */ 110 public static BackgroundTask update(BackgroundTask backgroundTask, 111 ServiceContext serviceContext) throws SystemException { 112 return getPersistence().update(backgroundTask, serviceContext); 113 } 114 115 /** 116 * Returns all the background tasks where groupId = ?. 117 * 118 * @param groupId the group ID 119 * @return the matching background tasks 120 * @throws SystemException if a system exception occurred 121 */ 122 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByGroupId( 123 long groupId) 124 throws com.liferay.portal.kernel.exception.SystemException { 125 return getPersistence().findByGroupId(groupId); 126 } 127 128 /** 129 * Returns a range of all the background tasks where groupId = ?. 130 * 131 * <p> 132 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 133 * </p> 134 * 135 * @param groupId the group ID 136 * @param start the lower bound of the range of background tasks 137 * @param end the upper bound of the range of background tasks (not inclusive) 138 * @return the range of matching background tasks 139 * @throws SystemException if a system exception occurred 140 */ 141 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByGroupId( 142 long groupId, int start, int end) 143 throws com.liferay.portal.kernel.exception.SystemException { 144 return getPersistence().findByGroupId(groupId, start, end); 145 } 146 147 /** 148 * Returns an ordered range of all the background tasks where groupId = ?. 149 * 150 * <p> 151 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 152 * </p> 153 * 154 * @param groupId the group ID 155 * @param start the lower bound of the range of background tasks 156 * @param end the upper bound of the range of background tasks (not inclusive) 157 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 158 * @return the ordered range of matching background tasks 159 * @throws SystemException if a system exception occurred 160 */ 161 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByGroupId( 162 long groupId, int start, int end, 163 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 164 throws com.liferay.portal.kernel.exception.SystemException { 165 return getPersistence() 166 .findByGroupId(groupId, start, end, orderByComparator); 167 } 168 169 /** 170 * Returns the first background task in the ordered set where groupId = ?. 171 * 172 * @param groupId the group ID 173 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 174 * @return the first matching background task 175 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 176 * @throws SystemException if a system exception occurred 177 */ 178 public static com.liferay.portal.model.BackgroundTask findByGroupId_First( 179 long groupId, 180 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 181 throws com.liferay.portal.NoSuchBackgroundTaskException, 182 com.liferay.portal.kernel.exception.SystemException { 183 return getPersistence().findByGroupId_First(groupId, orderByComparator); 184 } 185 186 /** 187 * Returns the first background task in the ordered set where groupId = ?. 188 * 189 * @param groupId the group ID 190 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 191 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 192 * @throws SystemException if a system exception occurred 193 */ 194 public static com.liferay.portal.model.BackgroundTask fetchByGroupId_First( 195 long groupId, 196 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 197 throws com.liferay.portal.kernel.exception.SystemException { 198 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 199 } 200 201 /** 202 * Returns the last background task in the ordered set where groupId = ?. 203 * 204 * @param groupId the group ID 205 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 206 * @return the last matching background task 207 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 208 * @throws SystemException if a system exception occurred 209 */ 210 public static com.liferay.portal.model.BackgroundTask findByGroupId_Last( 211 long groupId, 212 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 213 throws com.liferay.portal.NoSuchBackgroundTaskException, 214 com.liferay.portal.kernel.exception.SystemException { 215 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 216 } 217 218 /** 219 * Returns the last background task in the ordered set where groupId = ?. 220 * 221 * @param groupId the group ID 222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 223 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 224 * @throws SystemException if a system exception occurred 225 */ 226 public static com.liferay.portal.model.BackgroundTask fetchByGroupId_Last( 227 long groupId, 228 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 229 throws com.liferay.portal.kernel.exception.SystemException { 230 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 231 } 232 233 /** 234 * Returns the background tasks before and after the current background task in the ordered set where groupId = ?. 235 * 236 * @param backgroundTaskId the primary key of the current background task 237 * @param groupId the group ID 238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 239 * @return the previous, current, and next background task 240 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 241 * @throws SystemException if a system exception occurred 242 */ 243 public static com.liferay.portal.model.BackgroundTask[] findByGroupId_PrevAndNext( 244 long backgroundTaskId, long groupId, 245 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 246 throws com.liferay.portal.NoSuchBackgroundTaskException, 247 com.liferay.portal.kernel.exception.SystemException { 248 return getPersistence() 249 .findByGroupId_PrevAndNext(backgroundTaskId, groupId, 250 orderByComparator); 251 } 252 253 /** 254 * Removes all the background tasks where groupId = ? from the database. 255 * 256 * @param groupId the group ID 257 * @throws SystemException if a system exception occurred 258 */ 259 public static void removeByGroupId(long groupId) 260 throws com.liferay.portal.kernel.exception.SystemException { 261 getPersistence().removeByGroupId(groupId); 262 } 263 264 /** 265 * Returns the number of background tasks where groupId = ?. 266 * 267 * @param groupId the group ID 268 * @return the number of matching background tasks 269 * @throws SystemException if a system exception occurred 270 */ 271 public static int countByGroupId(long groupId) 272 throws com.liferay.portal.kernel.exception.SystemException { 273 return getPersistence().countByGroupId(groupId); 274 } 275 276 /** 277 * Returns all the background tasks where companyId = ?. 278 * 279 * @param companyId the company ID 280 * @return the matching background tasks 281 * @throws SystemException if a system exception occurred 282 */ 283 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByCompanyId( 284 long companyId) 285 throws com.liferay.portal.kernel.exception.SystemException { 286 return getPersistence().findByCompanyId(companyId); 287 } 288 289 /** 290 * Returns a range of all the background tasks where companyId = ?. 291 * 292 * <p> 293 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 294 * </p> 295 * 296 * @param companyId the company ID 297 * @param start the lower bound of the range of background tasks 298 * @param end the upper bound of the range of background tasks (not inclusive) 299 * @return the range of matching background tasks 300 * @throws SystemException if a system exception occurred 301 */ 302 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByCompanyId( 303 long companyId, int start, int end) 304 throws com.liferay.portal.kernel.exception.SystemException { 305 return getPersistence().findByCompanyId(companyId, start, end); 306 } 307 308 /** 309 * Returns an ordered range of all the background tasks where companyId = ?. 310 * 311 * <p> 312 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 313 * </p> 314 * 315 * @param companyId the company ID 316 * @param start the lower bound of the range of background tasks 317 * @param end the upper bound of the range of background tasks (not inclusive) 318 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 319 * @return the ordered range of matching background tasks 320 * @throws SystemException if a system exception occurred 321 */ 322 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByCompanyId( 323 long companyId, int start, int end, 324 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 325 throws com.liferay.portal.kernel.exception.SystemException { 326 return getPersistence() 327 .findByCompanyId(companyId, start, end, orderByComparator); 328 } 329 330 /** 331 * Returns the first background task in the ordered set where companyId = ?. 332 * 333 * @param companyId the company ID 334 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 335 * @return the first matching background task 336 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 337 * @throws SystemException if a system exception occurred 338 */ 339 public static com.liferay.portal.model.BackgroundTask findByCompanyId_First( 340 long companyId, 341 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 342 throws com.liferay.portal.NoSuchBackgroundTaskException, 343 com.liferay.portal.kernel.exception.SystemException { 344 return getPersistence() 345 .findByCompanyId_First(companyId, orderByComparator); 346 } 347 348 /** 349 * Returns the first background task in the ordered set where companyId = ?. 350 * 351 * @param companyId the company ID 352 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 353 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 354 * @throws SystemException if a system exception occurred 355 */ 356 public static com.liferay.portal.model.BackgroundTask fetchByCompanyId_First( 357 long companyId, 358 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 359 throws com.liferay.portal.kernel.exception.SystemException { 360 return getPersistence() 361 .fetchByCompanyId_First(companyId, orderByComparator); 362 } 363 364 /** 365 * Returns the last background task in the ordered set where companyId = ?. 366 * 367 * @param companyId the company ID 368 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 369 * @return the last matching background task 370 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 371 * @throws SystemException if a system exception occurred 372 */ 373 public static com.liferay.portal.model.BackgroundTask findByCompanyId_Last( 374 long companyId, 375 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 376 throws com.liferay.portal.NoSuchBackgroundTaskException, 377 com.liferay.portal.kernel.exception.SystemException { 378 return getPersistence() 379 .findByCompanyId_Last(companyId, orderByComparator); 380 } 381 382 /** 383 * Returns the last background task in the ordered set where companyId = ?. 384 * 385 * @param companyId the company ID 386 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 387 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 388 * @throws SystemException if a system exception occurred 389 */ 390 public static com.liferay.portal.model.BackgroundTask fetchByCompanyId_Last( 391 long companyId, 392 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 393 throws com.liferay.portal.kernel.exception.SystemException { 394 return getPersistence() 395 .fetchByCompanyId_Last(companyId, orderByComparator); 396 } 397 398 /** 399 * Returns the background tasks before and after the current background task in the ordered set where companyId = ?. 400 * 401 * @param backgroundTaskId the primary key of the current background task 402 * @param companyId the company ID 403 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 404 * @return the previous, current, and next background task 405 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 406 * @throws SystemException if a system exception occurred 407 */ 408 public static com.liferay.portal.model.BackgroundTask[] findByCompanyId_PrevAndNext( 409 long backgroundTaskId, long companyId, 410 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 411 throws com.liferay.portal.NoSuchBackgroundTaskException, 412 com.liferay.portal.kernel.exception.SystemException { 413 return getPersistence() 414 .findByCompanyId_PrevAndNext(backgroundTaskId, companyId, 415 orderByComparator); 416 } 417 418 /** 419 * Removes all the background tasks where companyId = ? from the database. 420 * 421 * @param companyId the company ID 422 * @throws SystemException if a system exception occurred 423 */ 424 public static void removeByCompanyId(long companyId) 425 throws com.liferay.portal.kernel.exception.SystemException { 426 getPersistence().removeByCompanyId(companyId); 427 } 428 429 /** 430 * Returns the number of background tasks where companyId = ?. 431 * 432 * @param companyId the company ID 433 * @return the number of matching background tasks 434 * @throws SystemException if a system exception occurred 435 */ 436 public static int countByCompanyId(long companyId) 437 throws com.liferay.portal.kernel.exception.SystemException { 438 return getPersistence().countByCompanyId(companyId); 439 } 440 441 /** 442 * Returns all the background tasks where status = ?. 443 * 444 * @param status the status 445 * @return the matching background tasks 446 * @throws SystemException if a system exception occurred 447 */ 448 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByStatus( 449 int status) throws com.liferay.portal.kernel.exception.SystemException { 450 return getPersistence().findByStatus(status); 451 } 452 453 /** 454 * Returns a range of all the background tasks where status = ?. 455 * 456 * <p> 457 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 458 * </p> 459 * 460 * @param status the status 461 * @param start the lower bound of the range of background tasks 462 * @param end the upper bound of the range of background tasks (not inclusive) 463 * @return the range of matching background tasks 464 * @throws SystemException if a system exception occurred 465 */ 466 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByStatus( 467 int status, int start, int end) 468 throws com.liferay.portal.kernel.exception.SystemException { 469 return getPersistence().findByStatus(status, start, end); 470 } 471 472 /** 473 * Returns an ordered range of all the background tasks where status = ?. 474 * 475 * <p> 476 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 477 * </p> 478 * 479 * @param status the status 480 * @param start the lower bound of the range of background tasks 481 * @param end the upper bound of the range of background tasks (not inclusive) 482 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 483 * @return the ordered range of matching background tasks 484 * @throws SystemException if a system exception occurred 485 */ 486 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByStatus( 487 int status, int start, int end, 488 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 489 throws com.liferay.portal.kernel.exception.SystemException { 490 return getPersistence() 491 .findByStatus(status, start, end, orderByComparator); 492 } 493 494 /** 495 * Returns the first background task in the ordered set where status = ?. 496 * 497 * @param status the status 498 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 499 * @return the first matching background task 500 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 501 * @throws SystemException if a system exception occurred 502 */ 503 public static com.liferay.portal.model.BackgroundTask findByStatus_First( 504 int status, 505 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 506 throws com.liferay.portal.NoSuchBackgroundTaskException, 507 com.liferay.portal.kernel.exception.SystemException { 508 return getPersistence().findByStatus_First(status, orderByComparator); 509 } 510 511 /** 512 * Returns the first background task in the ordered set where status = ?. 513 * 514 * @param status the status 515 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 516 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 517 * @throws SystemException if a system exception occurred 518 */ 519 public static com.liferay.portal.model.BackgroundTask fetchByStatus_First( 520 int status, 521 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 522 throws com.liferay.portal.kernel.exception.SystemException { 523 return getPersistence().fetchByStatus_First(status, orderByComparator); 524 } 525 526 /** 527 * Returns the last background task in the ordered set where status = ?. 528 * 529 * @param status the status 530 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 531 * @return the last matching background task 532 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 533 * @throws SystemException if a system exception occurred 534 */ 535 public static com.liferay.portal.model.BackgroundTask findByStatus_Last( 536 int status, 537 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 538 throws com.liferay.portal.NoSuchBackgroundTaskException, 539 com.liferay.portal.kernel.exception.SystemException { 540 return getPersistence().findByStatus_Last(status, orderByComparator); 541 } 542 543 /** 544 * Returns the last background task in the ordered set where status = ?. 545 * 546 * @param status the status 547 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 548 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 549 * @throws SystemException if a system exception occurred 550 */ 551 public static com.liferay.portal.model.BackgroundTask fetchByStatus_Last( 552 int status, 553 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 554 throws com.liferay.portal.kernel.exception.SystemException { 555 return getPersistence().fetchByStatus_Last(status, orderByComparator); 556 } 557 558 /** 559 * Returns the background tasks before and after the current background task in the ordered set where status = ?. 560 * 561 * @param backgroundTaskId the primary key of the current background task 562 * @param status the status 563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 564 * @return the previous, current, and next background task 565 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 566 * @throws SystemException if a system exception occurred 567 */ 568 public static com.liferay.portal.model.BackgroundTask[] findByStatus_PrevAndNext( 569 long backgroundTaskId, int status, 570 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 571 throws com.liferay.portal.NoSuchBackgroundTaskException, 572 com.liferay.portal.kernel.exception.SystemException { 573 return getPersistence() 574 .findByStatus_PrevAndNext(backgroundTaskId, status, 575 orderByComparator); 576 } 577 578 /** 579 * Removes all the background tasks where status = ? from the database. 580 * 581 * @param status the status 582 * @throws SystemException if a system exception occurred 583 */ 584 public static void removeByStatus(int status) 585 throws com.liferay.portal.kernel.exception.SystemException { 586 getPersistence().removeByStatus(status); 587 } 588 589 /** 590 * Returns the number of background tasks where status = ?. 591 * 592 * @param status the status 593 * @return the number of matching background tasks 594 * @throws SystemException if a system exception occurred 595 */ 596 public static int countByStatus(int status) 597 throws com.liferay.portal.kernel.exception.SystemException { 598 return getPersistence().countByStatus(status); 599 } 600 601 /** 602 * Returns all the background tasks where groupId = ? and taskExecutorClassName = ?. 603 * 604 * @param groupId the group ID 605 * @param taskExecutorClassName the task executor class name 606 * @return the matching background tasks 607 * @throws SystemException if a system exception occurred 608 */ 609 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 610 long groupId, java.lang.String taskExecutorClassName) 611 throws com.liferay.portal.kernel.exception.SystemException { 612 return getPersistence().findByG_T(groupId, taskExecutorClassName); 613 } 614 615 /** 616 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ?. 617 * 618 * <p> 619 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 620 * </p> 621 * 622 * @param groupId the group ID 623 * @param taskExecutorClassName the task executor class name 624 * @param start the lower bound of the range of background tasks 625 * @param end the upper bound of the range of background tasks (not inclusive) 626 * @return the range of matching background tasks 627 * @throws SystemException if a system exception occurred 628 */ 629 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 630 long groupId, java.lang.String taskExecutorClassName, int start, int end) 631 throws com.liferay.portal.kernel.exception.SystemException { 632 return getPersistence() 633 .findByG_T(groupId, taskExecutorClassName, start, end); 634 } 635 636 /** 637 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?. 638 * 639 * <p> 640 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 641 * </p> 642 * 643 * @param groupId the group ID 644 * @param taskExecutorClassName the task executor class name 645 * @param start the lower bound of the range of background tasks 646 * @param end the upper bound of the range of background tasks (not inclusive) 647 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 648 * @return the ordered range of matching background tasks 649 * @throws SystemException if a system exception occurred 650 */ 651 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 652 long groupId, java.lang.String taskExecutorClassName, int start, 653 int end, 654 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 655 throws com.liferay.portal.kernel.exception.SystemException { 656 return getPersistence() 657 .findByG_T(groupId, taskExecutorClassName, start, end, 658 orderByComparator); 659 } 660 661 /** 662 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 663 * 664 * @param groupId the group ID 665 * @param taskExecutorClassName the task executor class name 666 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 667 * @return the first matching background task 668 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 669 * @throws SystemException if a system exception occurred 670 */ 671 public static com.liferay.portal.model.BackgroundTask findByG_T_First( 672 long groupId, java.lang.String taskExecutorClassName, 673 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 674 throws com.liferay.portal.NoSuchBackgroundTaskException, 675 com.liferay.portal.kernel.exception.SystemException { 676 return getPersistence() 677 .findByG_T_First(groupId, taskExecutorClassName, 678 orderByComparator); 679 } 680 681 /** 682 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 683 * 684 * @param groupId the group ID 685 * @param taskExecutorClassName the task executor class name 686 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 687 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 688 * @throws SystemException if a system exception occurred 689 */ 690 public static com.liferay.portal.model.BackgroundTask fetchByG_T_First( 691 long groupId, java.lang.String taskExecutorClassName, 692 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 693 throws com.liferay.portal.kernel.exception.SystemException { 694 return getPersistence() 695 .fetchByG_T_First(groupId, taskExecutorClassName, 696 orderByComparator); 697 } 698 699 /** 700 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 701 * 702 * @param groupId the group ID 703 * @param taskExecutorClassName the task executor class name 704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 705 * @return the last matching background task 706 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 707 * @throws SystemException if a system exception occurred 708 */ 709 public static com.liferay.portal.model.BackgroundTask findByG_T_Last( 710 long groupId, java.lang.String taskExecutorClassName, 711 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 712 throws com.liferay.portal.NoSuchBackgroundTaskException, 713 com.liferay.portal.kernel.exception.SystemException { 714 return getPersistence() 715 .findByG_T_Last(groupId, taskExecutorClassName, 716 orderByComparator); 717 } 718 719 /** 720 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 721 * 722 * @param groupId the group ID 723 * @param taskExecutorClassName the task executor class name 724 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 725 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 726 * @throws SystemException if a system exception occurred 727 */ 728 public static com.liferay.portal.model.BackgroundTask fetchByG_T_Last( 729 long groupId, java.lang.String taskExecutorClassName, 730 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 731 throws com.liferay.portal.kernel.exception.SystemException { 732 return getPersistence() 733 .fetchByG_T_Last(groupId, taskExecutorClassName, 734 orderByComparator); 735 } 736 737 /** 738 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 739 * 740 * @param backgroundTaskId the primary key of the current background task 741 * @param groupId the group ID 742 * @param taskExecutorClassName the task executor class name 743 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 744 * @return the previous, current, and next background task 745 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 746 * @throws SystemException if a system exception occurred 747 */ 748 public static com.liferay.portal.model.BackgroundTask[] findByG_T_PrevAndNext( 749 long backgroundTaskId, long groupId, 750 java.lang.String taskExecutorClassName, 751 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 752 throws com.liferay.portal.NoSuchBackgroundTaskException, 753 com.liferay.portal.kernel.exception.SystemException { 754 return getPersistence() 755 .findByG_T_PrevAndNext(backgroundTaskId, groupId, 756 taskExecutorClassName, orderByComparator); 757 } 758 759 /** 760 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 groupId the group ID 767 * @param taskExecutorClassNames the task executor class names 768 * @return the matching background tasks 769 * @throws SystemException if a system exception occurred 770 */ 771 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 772 long groupId, java.lang.String[] taskExecutorClassNames) 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence().findByG_T(groupId, taskExecutorClassNames); 775 } 776 777 /** 778 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. 779 * 780 * <p> 781 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 782 * </p> 783 * 784 * @param groupId the group ID 785 * @param taskExecutorClassNames the task executor class names 786 * @param start the lower bound of the range of background tasks 787 * @param end the upper bound of the range of background tasks (not inclusive) 788 * @return the range of matching background tasks 789 * @throws SystemException if a system exception occurred 790 */ 791 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 792 long groupId, java.lang.String[] taskExecutorClassNames, int start, 793 int end) throws com.liferay.portal.kernel.exception.SystemException { 794 return getPersistence() 795 .findByG_T(groupId, taskExecutorClassNames, start, end); 796 } 797 798 /** 799 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. 800 * 801 * <p> 802 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 803 * </p> 804 * 805 * @param groupId the group ID 806 * @param taskExecutorClassNames the task executor class names 807 * @param start the lower bound of the range of background tasks 808 * @param end the upper bound of the range of background tasks (not inclusive) 809 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 810 * @return the ordered range of matching background tasks 811 * @throws SystemException if a system exception occurred 812 */ 813 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 814 long groupId, java.lang.String[] taskExecutorClassNames, int start, 815 int end, 816 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 817 throws com.liferay.portal.kernel.exception.SystemException { 818 return getPersistence() 819 .findByG_T(groupId, taskExecutorClassNames, start, end, 820 orderByComparator); 821 } 822 823 /** 824 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? from the database. 825 * 826 * @param groupId the group ID 827 * @param taskExecutorClassName the task executor class name 828 * @throws SystemException if a system exception occurred 829 */ 830 public static void removeByG_T(long groupId, 831 java.lang.String taskExecutorClassName) 832 throws com.liferay.portal.kernel.exception.SystemException { 833 getPersistence().removeByG_T(groupId, taskExecutorClassName); 834 } 835 836 /** 837 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ?. 838 * 839 * @param groupId the group ID 840 * @param taskExecutorClassName the task executor class name 841 * @return the number of matching background tasks 842 * @throws SystemException if a system exception occurred 843 */ 844 public static int countByG_T(long groupId, 845 java.lang.String taskExecutorClassName) 846 throws com.liferay.portal.kernel.exception.SystemException { 847 return getPersistence().countByG_T(groupId, taskExecutorClassName); 848 } 849 850 /** 851 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ?. 852 * 853 * @param groupId the group ID 854 * @param taskExecutorClassNames the task executor class names 855 * @return the number of matching background tasks 856 * @throws SystemException if a system exception occurred 857 */ 858 public static int countByG_T(long groupId, 859 java.lang.String[] taskExecutorClassNames) 860 throws com.liferay.portal.kernel.exception.SystemException { 861 return getPersistence().countByG_T(groupId, taskExecutorClassNames); 862 } 863 864 /** 865 * Returns all the background tasks where groupId = ? and status = ?. 866 * 867 * @param groupId the group ID 868 * @param status the status 869 * @return the matching background tasks 870 * @throws SystemException if a system exception occurred 871 */ 872 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S( 873 long groupId, int status) 874 throws com.liferay.portal.kernel.exception.SystemException { 875 return getPersistence().findByG_S(groupId, status); 876 } 877 878 /** 879 * Returns a range of all the background tasks where groupId = ? and status = ?. 880 * 881 * <p> 882 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 883 * </p> 884 * 885 * @param groupId the group ID 886 * @param status the status 887 * @param start the lower bound of the range of background tasks 888 * @param end the upper bound of the range of background tasks (not inclusive) 889 * @return the range of matching background tasks 890 * @throws SystemException if a system exception occurred 891 */ 892 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S( 893 long groupId, int status, int start, int end) 894 throws com.liferay.portal.kernel.exception.SystemException { 895 return getPersistence().findByG_S(groupId, status, start, end); 896 } 897 898 /** 899 * Returns an ordered range of all the background tasks where groupId = ? and status = ?. 900 * 901 * <p> 902 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 903 * </p> 904 * 905 * @param groupId the group ID 906 * @param status the status 907 * @param start the lower bound of the range of background tasks 908 * @param end the upper bound of the range of background tasks (not inclusive) 909 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 910 * @return the ordered range of matching background tasks 911 * @throws SystemException if a system exception occurred 912 */ 913 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S( 914 long groupId, int status, int start, int end, 915 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 916 throws com.liferay.portal.kernel.exception.SystemException { 917 return getPersistence() 918 .findByG_S(groupId, status, start, end, orderByComparator); 919 } 920 921 /** 922 * Returns the first background task in the ordered set where groupId = ? and status = ?. 923 * 924 * @param groupId the group ID 925 * @param status the status 926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 927 * @return the first matching background task 928 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 929 * @throws SystemException if a system exception occurred 930 */ 931 public static com.liferay.portal.model.BackgroundTask findByG_S_First( 932 long groupId, int status, 933 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 934 throws com.liferay.portal.NoSuchBackgroundTaskException, 935 com.liferay.portal.kernel.exception.SystemException { 936 return getPersistence() 937 .findByG_S_First(groupId, status, orderByComparator); 938 } 939 940 /** 941 * Returns the first background task in the ordered set where groupId = ? and status = ?. 942 * 943 * @param groupId the group ID 944 * @param status the status 945 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 946 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 947 * @throws SystemException if a system exception occurred 948 */ 949 public static com.liferay.portal.model.BackgroundTask fetchByG_S_First( 950 long groupId, int status, 951 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 952 throws com.liferay.portal.kernel.exception.SystemException { 953 return getPersistence() 954 .fetchByG_S_First(groupId, status, orderByComparator); 955 } 956 957 /** 958 * Returns the last background task in the ordered set where groupId = ? and status = ?. 959 * 960 * @param groupId the group ID 961 * @param status the status 962 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 963 * @return the last matching background task 964 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 965 * @throws SystemException if a system exception occurred 966 */ 967 public static com.liferay.portal.model.BackgroundTask findByG_S_Last( 968 long groupId, int status, 969 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 970 throws com.liferay.portal.NoSuchBackgroundTaskException, 971 com.liferay.portal.kernel.exception.SystemException { 972 return getPersistence() 973 .findByG_S_Last(groupId, status, orderByComparator); 974 } 975 976 /** 977 * Returns the last background task in the ordered set where groupId = ? and status = ?. 978 * 979 * @param groupId the group ID 980 * @param status the status 981 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 982 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 983 * @throws SystemException if a system exception occurred 984 */ 985 public static com.liferay.portal.model.BackgroundTask fetchByG_S_Last( 986 long groupId, int status, 987 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 988 throws com.liferay.portal.kernel.exception.SystemException { 989 return getPersistence() 990 .fetchByG_S_Last(groupId, status, orderByComparator); 991 } 992 993 /** 994 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and status = ?. 995 * 996 * @param backgroundTaskId the primary key of the current background task 997 * @param groupId the group ID 998 * @param status the status 999 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1000 * @return the previous, current, and next background task 1001 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1002 * @throws SystemException if a system exception occurred 1003 */ 1004 public static com.liferay.portal.model.BackgroundTask[] findByG_S_PrevAndNext( 1005 long backgroundTaskId, long groupId, int status, 1006 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1007 throws com.liferay.portal.NoSuchBackgroundTaskException, 1008 com.liferay.portal.kernel.exception.SystemException { 1009 return getPersistence() 1010 .findByG_S_PrevAndNext(backgroundTaskId, groupId, status, 1011 orderByComparator); 1012 } 1013 1014 /** 1015 * Removes all the background tasks where groupId = ? and status = ? from the database. 1016 * 1017 * @param groupId the group ID 1018 * @param status the status 1019 * @throws SystemException if a system exception occurred 1020 */ 1021 public static void removeByG_S(long groupId, int status) 1022 throws com.liferay.portal.kernel.exception.SystemException { 1023 getPersistence().removeByG_S(groupId, status); 1024 } 1025 1026 /** 1027 * Returns the number of background tasks where groupId = ? and status = ?. 1028 * 1029 * @param groupId the group ID 1030 * @param status the status 1031 * @return the number of matching background tasks 1032 * @throws SystemException if a system exception occurred 1033 */ 1034 public static int countByG_S(long groupId, int status) 1035 throws com.liferay.portal.kernel.exception.SystemException { 1036 return getPersistence().countByG_S(groupId, status); 1037 } 1038 1039 /** 1040 * Returns all the background tasks where taskExecutorClassName = ? and status = ?. 1041 * 1042 * @param taskExecutorClassName the task executor class name 1043 * @param status the status 1044 * @return the matching background tasks 1045 * @throws SystemException if a system exception occurred 1046 */ 1047 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1048 java.lang.String taskExecutorClassName, int status) 1049 throws com.liferay.portal.kernel.exception.SystemException { 1050 return getPersistence().findByT_S(taskExecutorClassName, status); 1051 } 1052 1053 /** 1054 * Returns a range of all the background tasks where taskExecutorClassName = ? and status = ?. 1055 * 1056 * <p> 1057 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1058 * </p> 1059 * 1060 * @param taskExecutorClassName the task executor class name 1061 * @param status the status 1062 * @param start the lower bound of the range of background tasks 1063 * @param end the upper bound of the range of background tasks (not inclusive) 1064 * @return the range of matching background tasks 1065 * @throws SystemException if a system exception occurred 1066 */ 1067 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1068 java.lang.String taskExecutorClassName, int status, int start, int end) 1069 throws com.liferay.portal.kernel.exception.SystemException { 1070 return getPersistence() 1071 .findByT_S(taskExecutorClassName, status, start, end); 1072 } 1073 1074 /** 1075 * Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?. 1076 * 1077 * <p> 1078 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1079 * </p> 1080 * 1081 * @param taskExecutorClassName the task executor class name 1082 * @param status the status 1083 * @param start the lower bound of the range of background tasks 1084 * @param end the upper bound of the range of background tasks (not inclusive) 1085 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1086 * @return the ordered range of matching background tasks 1087 * @throws SystemException if a system exception occurred 1088 */ 1089 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1090 java.lang.String taskExecutorClassName, int status, int start, int end, 1091 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1092 throws com.liferay.portal.kernel.exception.SystemException { 1093 return getPersistence() 1094 .findByT_S(taskExecutorClassName, status, start, end, 1095 orderByComparator); 1096 } 1097 1098 /** 1099 * Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. 1100 * 1101 * @param taskExecutorClassName the task executor class name 1102 * @param status the status 1103 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1104 * @return the first matching background task 1105 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1106 * @throws SystemException if a system exception occurred 1107 */ 1108 public static com.liferay.portal.model.BackgroundTask findByT_S_First( 1109 java.lang.String taskExecutorClassName, int status, 1110 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1111 throws com.liferay.portal.NoSuchBackgroundTaskException, 1112 com.liferay.portal.kernel.exception.SystemException { 1113 return getPersistence() 1114 .findByT_S_First(taskExecutorClassName, status, 1115 orderByComparator); 1116 } 1117 1118 /** 1119 * Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. 1120 * 1121 * @param taskExecutorClassName the task executor class name 1122 * @param status the status 1123 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1124 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1125 * @throws SystemException if a system exception occurred 1126 */ 1127 public static com.liferay.portal.model.BackgroundTask fetchByT_S_First( 1128 java.lang.String taskExecutorClassName, int status, 1129 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1130 throws com.liferay.portal.kernel.exception.SystemException { 1131 return getPersistence() 1132 .fetchByT_S_First(taskExecutorClassName, status, 1133 orderByComparator); 1134 } 1135 1136 /** 1137 * Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. 1138 * 1139 * @param taskExecutorClassName the task executor class name 1140 * @param status the status 1141 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1142 * @return the last matching background task 1143 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1144 * @throws SystemException if a system exception occurred 1145 */ 1146 public static com.liferay.portal.model.BackgroundTask findByT_S_Last( 1147 java.lang.String taskExecutorClassName, int status, 1148 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1149 throws com.liferay.portal.NoSuchBackgroundTaskException, 1150 com.liferay.portal.kernel.exception.SystemException { 1151 return getPersistence() 1152 .findByT_S_Last(taskExecutorClassName, status, 1153 orderByComparator); 1154 } 1155 1156 /** 1157 * Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. 1158 * 1159 * @param taskExecutorClassName the task executor class name 1160 * @param status the status 1161 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1162 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1163 * @throws SystemException if a system exception occurred 1164 */ 1165 public static com.liferay.portal.model.BackgroundTask fetchByT_S_Last( 1166 java.lang.String taskExecutorClassName, int status, 1167 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1168 throws com.liferay.portal.kernel.exception.SystemException { 1169 return getPersistence() 1170 .fetchByT_S_Last(taskExecutorClassName, status, 1171 orderByComparator); 1172 } 1173 1174 /** 1175 * Returns the background tasks before and after the current background task in the ordered set where taskExecutorClassName = ? and status = ?. 1176 * 1177 * @param backgroundTaskId the primary key of the current background task 1178 * @param taskExecutorClassName the task executor class name 1179 * @param status the status 1180 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1181 * @return the previous, current, and next background task 1182 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1183 * @throws SystemException if a system exception occurred 1184 */ 1185 public static com.liferay.portal.model.BackgroundTask[] findByT_S_PrevAndNext( 1186 long backgroundTaskId, java.lang.String taskExecutorClassName, 1187 int status, 1188 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1189 throws com.liferay.portal.NoSuchBackgroundTaskException, 1190 com.liferay.portal.kernel.exception.SystemException { 1191 return getPersistence() 1192 .findByT_S_PrevAndNext(backgroundTaskId, 1193 taskExecutorClassName, status, orderByComparator); 1194 } 1195 1196 /** 1197 * Returns all the background tasks where taskExecutorClassName = any ? and status = ?. 1198 * 1199 * <p> 1200 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1201 * </p> 1202 * 1203 * @param taskExecutorClassNames the task executor class names 1204 * @param status the status 1205 * @return the matching background tasks 1206 * @throws SystemException if a system exception occurred 1207 */ 1208 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1209 java.lang.String[] taskExecutorClassNames, int status) 1210 throws com.liferay.portal.kernel.exception.SystemException { 1211 return getPersistence().findByT_S(taskExecutorClassNames, status); 1212 } 1213 1214 /** 1215 * Returns a range of all the background tasks where taskExecutorClassName = any ? and status = ?. 1216 * 1217 * <p> 1218 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1219 * </p> 1220 * 1221 * @param taskExecutorClassNames the task executor class names 1222 * @param status the status 1223 * @param start the lower bound of the range of background tasks 1224 * @param end the upper bound of the range of background tasks (not inclusive) 1225 * @return the range of matching background tasks 1226 * @throws SystemException if a system exception occurred 1227 */ 1228 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1229 java.lang.String[] taskExecutorClassNames, int status, int start, 1230 int end) throws com.liferay.portal.kernel.exception.SystemException { 1231 return getPersistence() 1232 .findByT_S(taskExecutorClassNames, status, start, end); 1233 } 1234 1235 /** 1236 * Returns an ordered range of all the background tasks where taskExecutorClassName = any ? and status = ?. 1237 * 1238 * <p> 1239 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1240 * </p> 1241 * 1242 * @param taskExecutorClassNames the task executor class names 1243 * @param status the status 1244 * @param start the lower bound of the range of background tasks 1245 * @param end the upper bound of the range of background tasks (not inclusive) 1246 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1247 * @return the ordered range of matching background tasks 1248 * @throws SystemException if a system exception occurred 1249 */ 1250 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1251 java.lang.String[] taskExecutorClassNames, int status, int start, 1252 int end, 1253 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1254 throws com.liferay.portal.kernel.exception.SystemException { 1255 return getPersistence() 1256 .findByT_S(taskExecutorClassNames, status, start, end, 1257 orderByComparator); 1258 } 1259 1260 /** 1261 * Removes all the background tasks where taskExecutorClassName = ? and status = ? from the database. 1262 * 1263 * @param taskExecutorClassName the task executor class name 1264 * @param status the status 1265 * @throws SystemException if a system exception occurred 1266 */ 1267 public static void removeByT_S(java.lang.String taskExecutorClassName, 1268 int status) throws com.liferay.portal.kernel.exception.SystemException { 1269 getPersistence().removeByT_S(taskExecutorClassName, status); 1270 } 1271 1272 /** 1273 * Returns the number of background tasks where taskExecutorClassName = ? and status = ?. 1274 * 1275 * @param taskExecutorClassName the task executor class name 1276 * @param status the status 1277 * @return the number of matching background tasks 1278 * @throws SystemException if a system exception occurred 1279 */ 1280 public static int countByT_S(java.lang.String taskExecutorClassName, 1281 int status) throws com.liferay.portal.kernel.exception.SystemException { 1282 return getPersistence().countByT_S(taskExecutorClassName, status); 1283 } 1284 1285 /** 1286 * Returns the number of background tasks where taskExecutorClassName = any ? and status = ?. 1287 * 1288 * @param taskExecutorClassNames the task executor class names 1289 * @param status the status 1290 * @return the number of matching background tasks 1291 * @throws SystemException if a system exception occurred 1292 */ 1293 public static int countByT_S(java.lang.String[] taskExecutorClassNames, 1294 int status) throws com.liferay.portal.kernel.exception.SystemException { 1295 return getPersistence().countByT_S(taskExecutorClassNames, status); 1296 } 1297 1298 /** 1299 * Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1300 * 1301 * @param groupId the group ID 1302 * @param name the name 1303 * @param taskExecutorClassName the task executor class name 1304 * @return the matching background tasks 1305 * @throws SystemException if a system exception occurred 1306 */ 1307 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T( 1308 long groupId, java.lang.String name, 1309 java.lang.String taskExecutorClassName) 1310 throws com.liferay.portal.kernel.exception.SystemException { 1311 return getPersistence().findByG_N_T(groupId, name, taskExecutorClassName); 1312 } 1313 1314 /** 1315 * Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1316 * 1317 * <p> 1318 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1319 * </p> 1320 * 1321 * @param groupId the group ID 1322 * @param name the name 1323 * @param taskExecutorClassName the task executor class name 1324 * @param start the lower bound of the range of background tasks 1325 * @param end the upper bound of the range of background tasks (not inclusive) 1326 * @return the range of matching background tasks 1327 * @throws SystemException if a system exception occurred 1328 */ 1329 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T( 1330 long groupId, java.lang.String name, 1331 java.lang.String taskExecutorClassName, int start, int end) 1332 throws com.liferay.portal.kernel.exception.SystemException { 1333 return getPersistence() 1334 .findByG_N_T(groupId, name, taskExecutorClassName, start, end); 1335 } 1336 1337 /** 1338 * Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1339 * 1340 * <p> 1341 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1342 * </p> 1343 * 1344 * @param groupId the group ID 1345 * @param name the name 1346 * @param taskExecutorClassName the task executor class name 1347 * @param start the lower bound of the range of background tasks 1348 * @param end the upper bound of the range of background tasks (not inclusive) 1349 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1350 * @return the ordered range of matching background tasks 1351 * @throws SystemException if a system exception occurred 1352 */ 1353 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T( 1354 long groupId, java.lang.String name, 1355 java.lang.String taskExecutorClassName, int start, int end, 1356 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1357 throws com.liferay.portal.kernel.exception.SystemException { 1358 return getPersistence() 1359 .findByG_N_T(groupId, name, taskExecutorClassName, start, 1360 end, orderByComparator); 1361 } 1362 1363 /** 1364 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1365 * 1366 * @param groupId the group ID 1367 * @param name the name 1368 * @param taskExecutorClassName the task executor class name 1369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1370 * @return the first matching background task 1371 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1372 * @throws SystemException if a system exception occurred 1373 */ 1374 public static com.liferay.portal.model.BackgroundTask findByG_N_T_First( 1375 long groupId, java.lang.String name, 1376 java.lang.String taskExecutorClassName, 1377 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1378 throws com.liferay.portal.NoSuchBackgroundTaskException, 1379 com.liferay.portal.kernel.exception.SystemException { 1380 return getPersistence() 1381 .findByG_N_T_First(groupId, name, taskExecutorClassName, 1382 orderByComparator); 1383 } 1384 1385 /** 1386 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1387 * 1388 * @param groupId the group ID 1389 * @param name the name 1390 * @param taskExecutorClassName the task executor class name 1391 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1392 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1393 * @throws SystemException if a system exception occurred 1394 */ 1395 public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_First( 1396 long groupId, java.lang.String name, 1397 java.lang.String taskExecutorClassName, 1398 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1399 throws com.liferay.portal.kernel.exception.SystemException { 1400 return getPersistence() 1401 .fetchByG_N_T_First(groupId, name, taskExecutorClassName, 1402 orderByComparator); 1403 } 1404 1405 /** 1406 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1407 * 1408 * @param groupId the group ID 1409 * @param name the name 1410 * @param taskExecutorClassName the task executor class name 1411 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1412 * @return the last matching background task 1413 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1414 * @throws SystemException if a system exception occurred 1415 */ 1416 public static com.liferay.portal.model.BackgroundTask findByG_N_T_Last( 1417 long groupId, java.lang.String name, 1418 java.lang.String taskExecutorClassName, 1419 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1420 throws com.liferay.portal.NoSuchBackgroundTaskException, 1421 com.liferay.portal.kernel.exception.SystemException { 1422 return getPersistence() 1423 .findByG_N_T_Last(groupId, name, taskExecutorClassName, 1424 orderByComparator); 1425 } 1426 1427 /** 1428 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1429 * 1430 * @param groupId the group ID 1431 * @param name the name 1432 * @param taskExecutorClassName the task executor class name 1433 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1434 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1435 * @throws SystemException if a system exception occurred 1436 */ 1437 public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_Last( 1438 long groupId, java.lang.String name, 1439 java.lang.String taskExecutorClassName, 1440 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1441 throws com.liferay.portal.kernel.exception.SystemException { 1442 return getPersistence() 1443 .fetchByG_N_T_Last(groupId, name, taskExecutorClassName, 1444 orderByComparator); 1445 } 1446 1447 /** 1448 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1449 * 1450 * @param backgroundTaskId the primary key of the current background task 1451 * @param groupId the group ID 1452 * @param name the name 1453 * @param taskExecutorClassName the task executor class name 1454 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1455 * @return the previous, current, and next background task 1456 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1457 * @throws SystemException if a system exception occurred 1458 */ 1459 public static com.liferay.portal.model.BackgroundTask[] findByG_N_T_PrevAndNext( 1460 long backgroundTaskId, long groupId, java.lang.String name, 1461 java.lang.String taskExecutorClassName, 1462 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1463 throws com.liferay.portal.NoSuchBackgroundTaskException, 1464 com.liferay.portal.kernel.exception.SystemException { 1465 return getPersistence() 1466 .findByG_N_T_PrevAndNext(backgroundTaskId, groupId, name, 1467 taskExecutorClassName, orderByComparator); 1468 } 1469 1470 /** 1471 * Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? from the database. 1472 * 1473 * @param groupId the group ID 1474 * @param name the name 1475 * @param taskExecutorClassName the task executor class name 1476 * @throws SystemException if a system exception occurred 1477 */ 1478 public static void removeByG_N_T(long groupId, java.lang.String name, 1479 java.lang.String taskExecutorClassName) 1480 throws com.liferay.portal.kernel.exception.SystemException { 1481 getPersistence().removeByG_N_T(groupId, name, taskExecutorClassName); 1482 } 1483 1484 /** 1485 * Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1486 * 1487 * @param groupId the group ID 1488 * @param name the name 1489 * @param taskExecutorClassName the task executor class name 1490 * @return the number of matching background tasks 1491 * @throws SystemException if a system exception occurred 1492 */ 1493 public static int countByG_N_T(long groupId, java.lang.String name, 1494 java.lang.String taskExecutorClassName) 1495 throws com.liferay.portal.kernel.exception.SystemException { 1496 return getPersistence() 1497 .countByG_N_T(groupId, name, taskExecutorClassName); 1498 } 1499 1500 /** 1501 * Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1502 * 1503 * @param groupId the group ID 1504 * @param taskExecutorClassName the task executor class name 1505 * @param completed the completed 1506 * @return the matching background tasks 1507 * @throws SystemException if a system exception occurred 1508 */ 1509 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1510 long groupId, java.lang.String taskExecutorClassName, boolean completed) 1511 throws com.liferay.portal.kernel.exception.SystemException { 1512 return getPersistence() 1513 .findByG_T_C(groupId, taskExecutorClassName, completed); 1514 } 1515 1516 /** 1517 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 groupId the group ID 1524 * @param taskExecutorClassName the task executor class name 1525 * @param completed the completed 1526 * @param start the lower bound of the range of background tasks 1527 * @param end the upper bound of the range of background tasks (not inclusive) 1528 * @return the range of matching background tasks 1529 * @throws SystemException if a system exception occurred 1530 */ 1531 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1532 long groupId, java.lang.String taskExecutorClassName, 1533 boolean completed, int start, int end) 1534 throws com.liferay.portal.kernel.exception.SystemException { 1535 return getPersistence() 1536 .findByG_T_C(groupId, taskExecutorClassName, completed, 1537 start, end); 1538 } 1539 1540 /** 1541 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1542 * 1543 * <p> 1544 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1545 * </p> 1546 * 1547 * @param groupId the group ID 1548 * @param taskExecutorClassName the task executor class name 1549 * @param completed the completed 1550 * @param start the lower bound of the range of background tasks 1551 * @param end the upper bound of the range of background tasks (not inclusive) 1552 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1553 * @return the ordered range of matching background tasks 1554 * @throws SystemException if a system exception occurred 1555 */ 1556 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1557 long groupId, java.lang.String taskExecutorClassName, 1558 boolean completed, int start, int end, 1559 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1560 throws com.liferay.portal.kernel.exception.SystemException { 1561 return getPersistence() 1562 .findByG_T_C(groupId, taskExecutorClassName, completed, 1563 start, end, orderByComparator); 1564 } 1565 1566 /** 1567 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1568 * 1569 * @param groupId the group ID 1570 * @param taskExecutorClassName the task executor class name 1571 * @param completed the completed 1572 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1573 * @return the first matching background task 1574 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1575 * @throws SystemException if a system exception occurred 1576 */ 1577 public static com.liferay.portal.model.BackgroundTask findByG_T_C_First( 1578 long groupId, java.lang.String taskExecutorClassName, 1579 boolean completed, 1580 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1581 throws com.liferay.portal.NoSuchBackgroundTaskException, 1582 com.liferay.portal.kernel.exception.SystemException { 1583 return getPersistence() 1584 .findByG_T_C_First(groupId, taskExecutorClassName, 1585 completed, orderByComparator); 1586 } 1587 1588 /** 1589 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1590 * 1591 * @param groupId the group ID 1592 * @param taskExecutorClassName the task executor class name 1593 * @param completed the completed 1594 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1595 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1596 * @throws SystemException if a system exception occurred 1597 */ 1598 public static com.liferay.portal.model.BackgroundTask fetchByG_T_C_First( 1599 long groupId, java.lang.String taskExecutorClassName, 1600 boolean completed, 1601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1602 throws com.liferay.portal.kernel.exception.SystemException { 1603 return getPersistence() 1604 .fetchByG_T_C_First(groupId, taskExecutorClassName, 1605 completed, orderByComparator); 1606 } 1607 1608 /** 1609 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1610 * 1611 * @param groupId the group ID 1612 * @param taskExecutorClassName the task executor class name 1613 * @param completed the completed 1614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1615 * @return the last matching background task 1616 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1617 * @throws SystemException if a system exception occurred 1618 */ 1619 public static com.liferay.portal.model.BackgroundTask findByG_T_C_Last( 1620 long groupId, java.lang.String taskExecutorClassName, 1621 boolean completed, 1622 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1623 throws com.liferay.portal.NoSuchBackgroundTaskException, 1624 com.liferay.portal.kernel.exception.SystemException { 1625 return getPersistence() 1626 .findByG_T_C_Last(groupId, taskExecutorClassName, completed, 1627 orderByComparator); 1628 } 1629 1630 /** 1631 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1632 * 1633 * @param groupId the group ID 1634 * @param taskExecutorClassName the task executor class name 1635 * @param completed the completed 1636 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1637 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1638 * @throws SystemException if a system exception occurred 1639 */ 1640 public static com.liferay.portal.model.BackgroundTask fetchByG_T_C_Last( 1641 long groupId, java.lang.String taskExecutorClassName, 1642 boolean completed, 1643 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1644 throws com.liferay.portal.kernel.exception.SystemException { 1645 return getPersistence() 1646 .fetchByG_T_C_Last(groupId, taskExecutorClassName, 1647 completed, orderByComparator); 1648 } 1649 1650 /** 1651 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1652 * 1653 * @param backgroundTaskId the primary key of the current background task 1654 * @param groupId the group ID 1655 * @param taskExecutorClassName the task executor class name 1656 * @param completed the completed 1657 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1658 * @return the previous, current, and next background task 1659 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1660 * @throws SystemException if a system exception occurred 1661 */ 1662 public static com.liferay.portal.model.BackgroundTask[] findByG_T_C_PrevAndNext( 1663 long backgroundTaskId, long groupId, 1664 java.lang.String taskExecutorClassName, boolean completed, 1665 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1666 throws com.liferay.portal.NoSuchBackgroundTaskException, 1667 com.liferay.portal.kernel.exception.SystemException { 1668 return getPersistence() 1669 .findByG_T_C_PrevAndNext(backgroundTaskId, groupId, 1670 taskExecutorClassName, completed, orderByComparator); 1671 } 1672 1673 /** 1674 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1675 * 1676 * <p> 1677 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1678 * </p> 1679 * 1680 * @param groupId the group ID 1681 * @param taskExecutorClassNames the task executor class names 1682 * @param completed the completed 1683 * @return the matching background tasks 1684 * @throws SystemException if a system exception occurred 1685 */ 1686 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1687 long groupId, java.lang.String[] taskExecutorClassNames, 1688 boolean completed) 1689 throws com.liferay.portal.kernel.exception.SystemException { 1690 return getPersistence() 1691 .findByG_T_C(groupId, taskExecutorClassNames, completed); 1692 } 1693 1694 /** 1695 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1696 * 1697 * <p> 1698 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1699 * </p> 1700 * 1701 * @param groupId the group ID 1702 * @param taskExecutorClassNames the task executor class names 1703 * @param completed the completed 1704 * @param start the lower bound of the range of background tasks 1705 * @param end the upper bound of the range of background tasks (not inclusive) 1706 * @return the range of matching background tasks 1707 * @throws SystemException if a system exception occurred 1708 */ 1709 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1710 long groupId, java.lang.String[] taskExecutorClassNames, 1711 boolean completed, int start, int end) 1712 throws com.liferay.portal.kernel.exception.SystemException { 1713 return getPersistence() 1714 .findByG_T_C(groupId, taskExecutorClassNames, completed, 1715 start, end); 1716 } 1717 1718 /** 1719 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1720 * 1721 * <p> 1722 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1723 * </p> 1724 * 1725 * @param groupId the group ID 1726 * @param taskExecutorClassNames the task executor class names 1727 * @param completed the completed 1728 * @param start the lower bound of the range of background tasks 1729 * @param end the upper bound of the range of background tasks (not inclusive) 1730 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1731 * @return the ordered range of matching background tasks 1732 * @throws SystemException if a system exception occurred 1733 */ 1734 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1735 long groupId, java.lang.String[] taskExecutorClassNames, 1736 boolean completed, int start, int end, 1737 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1738 throws com.liferay.portal.kernel.exception.SystemException { 1739 return getPersistence() 1740 .findByG_T_C(groupId, taskExecutorClassNames, completed, 1741 start, end, orderByComparator); 1742 } 1743 1744 /** 1745 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ? from the database. 1746 * 1747 * @param groupId the group ID 1748 * @param taskExecutorClassName the task executor class name 1749 * @param completed the completed 1750 * @throws SystemException if a system exception occurred 1751 */ 1752 public static void removeByG_T_C(long groupId, 1753 java.lang.String taskExecutorClassName, boolean completed) 1754 throws com.liferay.portal.kernel.exception.SystemException { 1755 getPersistence().removeByG_T_C(groupId, taskExecutorClassName, completed); 1756 } 1757 1758 /** 1759 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1760 * 1761 * @param groupId the group ID 1762 * @param taskExecutorClassName the task executor class name 1763 * @param completed the completed 1764 * @return the number of matching background tasks 1765 * @throws SystemException if a system exception occurred 1766 */ 1767 public static int countByG_T_C(long groupId, 1768 java.lang.String taskExecutorClassName, boolean completed) 1769 throws com.liferay.portal.kernel.exception.SystemException { 1770 return getPersistence() 1771 .countByG_T_C(groupId, taskExecutorClassName, completed); 1772 } 1773 1774 /** 1775 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1776 * 1777 * @param groupId the group ID 1778 * @param taskExecutorClassNames the task executor class names 1779 * @param completed the completed 1780 * @return the number of matching background tasks 1781 * @throws SystemException if a system exception occurred 1782 */ 1783 public static int countByG_T_C(long groupId, 1784 java.lang.String[] taskExecutorClassNames, boolean completed) 1785 throws com.liferay.portal.kernel.exception.SystemException { 1786 return getPersistence() 1787 .countByG_T_C(groupId, taskExecutorClassNames, completed); 1788 } 1789 1790 /** 1791 * Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1792 * 1793 * @param groupId the group ID 1794 * @param taskExecutorClassName the task executor class name 1795 * @param status the status 1796 * @return the matching background tasks 1797 * @throws SystemException if a system exception occurred 1798 */ 1799 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1800 long groupId, java.lang.String taskExecutorClassName, int status) 1801 throws com.liferay.portal.kernel.exception.SystemException { 1802 return getPersistence() 1803 .findByG_T_S(groupId, taskExecutorClassName, status); 1804 } 1805 1806 /** 1807 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1808 * 1809 * <p> 1810 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1811 * </p> 1812 * 1813 * @param groupId the group ID 1814 * @param taskExecutorClassName the task executor class name 1815 * @param status the status 1816 * @param start the lower bound of the range of background tasks 1817 * @param end the upper bound of the range of background tasks (not inclusive) 1818 * @return the range of matching background tasks 1819 * @throws SystemException if a system exception occurred 1820 */ 1821 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1822 long groupId, java.lang.String taskExecutorClassName, int status, 1823 int start, int end) 1824 throws com.liferay.portal.kernel.exception.SystemException { 1825 return getPersistence() 1826 .findByG_T_S(groupId, taskExecutorClassName, status, start, 1827 end); 1828 } 1829 1830 /** 1831 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1832 * 1833 * <p> 1834 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1835 * </p> 1836 * 1837 * @param groupId the group ID 1838 * @param taskExecutorClassName the task executor class name 1839 * @param status the status 1840 * @param start the lower bound of the range of background tasks 1841 * @param end the upper bound of the range of background tasks (not inclusive) 1842 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1843 * @return the ordered range of matching background tasks 1844 * @throws SystemException if a system exception occurred 1845 */ 1846 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1847 long groupId, java.lang.String taskExecutorClassName, int status, 1848 int start, int end, 1849 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1850 throws com.liferay.portal.kernel.exception.SystemException { 1851 return getPersistence() 1852 .findByG_T_S(groupId, taskExecutorClassName, status, start, 1853 end, orderByComparator); 1854 } 1855 1856 /** 1857 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1858 * 1859 * @param groupId the group ID 1860 * @param taskExecutorClassName the task executor class name 1861 * @param status the status 1862 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1863 * @return the first matching background task 1864 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1865 * @throws SystemException if a system exception occurred 1866 */ 1867 public static com.liferay.portal.model.BackgroundTask findByG_T_S_First( 1868 long groupId, java.lang.String taskExecutorClassName, int status, 1869 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1870 throws com.liferay.portal.NoSuchBackgroundTaskException, 1871 com.liferay.portal.kernel.exception.SystemException { 1872 return getPersistence() 1873 .findByG_T_S_First(groupId, taskExecutorClassName, status, 1874 orderByComparator); 1875 } 1876 1877 /** 1878 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1879 * 1880 * @param groupId the group ID 1881 * @param taskExecutorClassName the task executor class name 1882 * @param status the status 1883 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1884 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1885 * @throws SystemException if a system exception occurred 1886 */ 1887 public static com.liferay.portal.model.BackgroundTask fetchByG_T_S_First( 1888 long groupId, java.lang.String taskExecutorClassName, int status, 1889 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1890 throws com.liferay.portal.kernel.exception.SystemException { 1891 return getPersistence() 1892 .fetchByG_T_S_First(groupId, taskExecutorClassName, status, 1893 orderByComparator); 1894 } 1895 1896 /** 1897 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1898 * 1899 * @param groupId the group ID 1900 * @param taskExecutorClassName the task executor class name 1901 * @param status the status 1902 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1903 * @return the last matching background task 1904 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1905 * @throws SystemException if a system exception occurred 1906 */ 1907 public static com.liferay.portal.model.BackgroundTask findByG_T_S_Last( 1908 long groupId, java.lang.String taskExecutorClassName, int status, 1909 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1910 throws com.liferay.portal.NoSuchBackgroundTaskException, 1911 com.liferay.portal.kernel.exception.SystemException { 1912 return getPersistence() 1913 .findByG_T_S_Last(groupId, taskExecutorClassName, status, 1914 orderByComparator); 1915 } 1916 1917 /** 1918 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1919 * 1920 * @param groupId the group ID 1921 * @param taskExecutorClassName the task executor class name 1922 * @param status the status 1923 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1924 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1925 * @throws SystemException if a system exception occurred 1926 */ 1927 public static com.liferay.portal.model.BackgroundTask fetchByG_T_S_Last( 1928 long groupId, java.lang.String taskExecutorClassName, int status, 1929 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1930 throws com.liferay.portal.kernel.exception.SystemException { 1931 return getPersistence() 1932 .fetchByG_T_S_Last(groupId, taskExecutorClassName, status, 1933 orderByComparator); 1934 } 1935 1936 /** 1937 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1938 * 1939 * @param backgroundTaskId the primary key of the current background task 1940 * @param groupId the group ID 1941 * @param taskExecutorClassName the task executor class name 1942 * @param status the status 1943 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1944 * @return the previous, current, and next background task 1945 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1946 * @throws SystemException if a system exception occurred 1947 */ 1948 public static com.liferay.portal.model.BackgroundTask[] findByG_T_S_PrevAndNext( 1949 long backgroundTaskId, long groupId, 1950 java.lang.String taskExecutorClassName, int status, 1951 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1952 throws com.liferay.portal.NoSuchBackgroundTaskException, 1953 com.liferay.portal.kernel.exception.SystemException { 1954 return getPersistence() 1955 .findByG_T_S_PrevAndNext(backgroundTaskId, groupId, 1956 taskExecutorClassName, status, orderByComparator); 1957 } 1958 1959 /** 1960 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 1961 * 1962 * <p> 1963 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1964 * </p> 1965 * 1966 * @param groupId the group ID 1967 * @param taskExecutorClassNames the task executor class names 1968 * @param status the status 1969 * @return the matching background tasks 1970 * @throws SystemException if a system exception occurred 1971 */ 1972 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1973 long groupId, java.lang.String[] taskExecutorClassNames, int status) 1974 throws com.liferay.portal.kernel.exception.SystemException { 1975 return getPersistence() 1976 .findByG_T_S(groupId, taskExecutorClassNames, status); 1977 } 1978 1979 /** 1980 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 1981 * 1982 * <p> 1983 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1984 * </p> 1985 * 1986 * @param groupId the group ID 1987 * @param taskExecutorClassNames the task executor class names 1988 * @param status the status 1989 * @param start the lower bound of the range of background tasks 1990 * @param end the upper bound of the range of background tasks (not inclusive) 1991 * @return the range of matching background tasks 1992 * @throws SystemException if a system exception occurred 1993 */ 1994 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1995 long groupId, java.lang.String[] taskExecutorClassNames, int status, 1996 int start, int end) 1997 throws com.liferay.portal.kernel.exception.SystemException { 1998 return getPersistence() 1999 .findByG_T_S(groupId, taskExecutorClassNames, status, start, 2000 end); 2001 } 2002 2003 /** 2004 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 2005 * 2006 * <p> 2007 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2008 * </p> 2009 * 2010 * @param groupId the group ID 2011 * @param taskExecutorClassNames the task executor class names 2012 * @param status the status 2013 * @param start the lower bound of the range of background tasks 2014 * @param end the upper bound of the range of background tasks (not inclusive) 2015 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2016 * @return the ordered range of matching background tasks 2017 * @throws SystemException if a system exception occurred 2018 */ 2019 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 2020 long groupId, java.lang.String[] taskExecutorClassNames, int status, 2021 int start, int end, 2022 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2023 throws com.liferay.portal.kernel.exception.SystemException { 2024 return getPersistence() 2025 .findByG_T_S(groupId, taskExecutorClassNames, status, start, 2026 end, orderByComparator); 2027 } 2028 2029 /** 2030 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ? from the database. 2031 * 2032 * @param groupId the group ID 2033 * @param taskExecutorClassName the task executor class name 2034 * @param status the status 2035 * @throws SystemException if a system exception occurred 2036 */ 2037 public static void removeByG_T_S(long groupId, 2038 java.lang.String taskExecutorClassName, int status) 2039 throws com.liferay.portal.kernel.exception.SystemException { 2040 getPersistence().removeByG_T_S(groupId, taskExecutorClassName, status); 2041 } 2042 2043 /** 2044 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 2045 * 2046 * @param groupId the group ID 2047 * @param taskExecutorClassName the task executor class name 2048 * @param status the status 2049 * @return the number of matching background tasks 2050 * @throws SystemException if a system exception occurred 2051 */ 2052 public static int countByG_T_S(long groupId, 2053 java.lang.String taskExecutorClassName, int status) 2054 throws com.liferay.portal.kernel.exception.SystemException { 2055 return getPersistence() 2056 .countByG_T_S(groupId, taskExecutorClassName, status); 2057 } 2058 2059 /** 2060 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 2061 * 2062 * @param groupId the group ID 2063 * @param taskExecutorClassNames the task executor class names 2064 * @param status the status 2065 * @return the number of matching background tasks 2066 * @throws SystemException if a system exception occurred 2067 */ 2068 public static int countByG_T_S(long groupId, 2069 java.lang.String[] taskExecutorClassNames, int status) 2070 throws com.liferay.portal.kernel.exception.SystemException { 2071 return getPersistence() 2072 .countByG_T_S(groupId, taskExecutorClassNames, status); 2073 } 2074 2075 /** 2076 * Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2077 * 2078 * @param groupId the group ID 2079 * @param name the name 2080 * @param taskExecutorClassName the task executor class name 2081 * @param completed the completed 2082 * @return the matching background tasks 2083 * @throws SystemException if a system exception occurred 2084 */ 2085 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C( 2086 long groupId, java.lang.String name, 2087 java.lang.String taskExecutorClassName, boolean completed) 2088 throws com.liferay.portal.kernel.exception.SystemException { 2089 return getPersistence() 2090 .findByG_N_T_C(groupId, name, taskExecutorClassName, 2091 completed); 2092 } 2093 2094 /** 2095 * Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2096 * 2097 * <p> 2098 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2099 * </p> 2100 * 2101 * @param groupId the group ID 2102 * @param name the name 2103 * @param taskExecutorClassName the task executor class name 2104 * @param completed the completed 2105 * @param start the lower bound of the range of background tasks 2106 * @param end the upper bound of the range of background tasks (not inclusive) 2107 * @return the range of matching background tasks 2108 * @throws SystemException if a system exception occurred 2109 */ 2110 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C( 2111 long groupId, java.lang.String name, 2112 java.lang.String taskExecutorClassName, boolean completed, int start, 2113 int end) throws com.liferay.portal.kernel.exception.SystemException { 2114 return getPersistence() 2115 .findByG_N_T_C(groupId, name, taskExecutorClassName, 2116 completed, start, end); 2117 } 2118 2119 /** 2120 * Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2121 * 2122 * <p> 2123 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2124 * </p> 2125 * 2126 * @param groupId the group ID 2127 * @param name the name 2128 * @param taskExecutorClassName the task executor class name 2129 * @param completed the completed 2130 * @param start the lower bound of the range of background tasks 2131 * @param end the upper bound of the range of background tasks (not inclusive) 2132 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2133 * @return the ordered range of matching background tasks 2134 * @throws SystemException if a system exception occurred 2135 */ 2136 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C( 2137 long groupId, java.lang.String name, 2138 java.lang.String taskExecutorClassName, boolean completed, int start, 2139 int end, 2140 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2141 throws com.liferay.portal.kernel.exception.SystemException { 2142 return getPersistence() 2143 .findByG_N_T_C(groupId, name, taskExecutorClassName, 2144 completed, start, end, orderByComparator); 2145 } 2146 2147 /** 2148 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2149 * 2150 * @param groupId the group ID 2151 * @param name the name 2152 * @param taskExecutorClassName the task executor class name 2153 * @param completed the completed 2154 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2155 * @return the first matching background task 2156 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 2157 * @throws SystemException if a system exception occurred 2158 */ 2159 public static com.liferay.portal.model.BackgroundTask findByG_N_T_C_First( 2160 long groupId, java.lang.String name, 2161 java.lang.String taskExecutorClassName, boolean completed, 2162 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2163 throws com.liferay.portal.NoSuchBackgroundTaskException, 2164 com.liferay.portal.kernel.exception.SystemException { 2165 return getPersistence() 2166 .findByG_N_T_C_First(groupId, name, taskExecutorClassName, 2167 completed, orderByComparator); 2168 } 2169 2170 /** 2171 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2172 * 2173 * @param groupId the group ID 2174 * @param name the name 2175 * @param taskExecutorClassName the task executor class name 2176 * @param completed the completed 2177 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2178 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 2179 * @throws SystemException if a system exception occurred 2180 */ 2181 public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_C_First( 2182 long groupId, java.lang.String name, 2183 java.lang.String taskExecutorClassName, boolean completed, 2184 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2185 throws com.liferay.portal.kernel.exception.SystemException { 2186 return getPersistence() 2187 .fetchByG_N_T_C_First(groupId, name, taskExecutorClassName, 2188 completed, orderByComparator); 2189 } 2190 2191 /** 2192 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2193 * 2194 * @param groupId the group ID 2195 * @param name the name 2196 * @param taskExecutorClassName the task executor class name 2197 * @param completed the completed 2198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2199 * @return the last matching background task 2200 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 2201 * @throws SystemException if a system exception occurred 2202 */ 2203 public static com.liferay.portal.model.BackgroundTask findByG_N_T_C_Last( 2204 long groupId, java.lang.String name, 2205 java.lang.String taskExecutorClassName, boolean completed, 2206 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2207 throws com.liferay.portal.NoSuchBackgroundTaskException, 2208 com.liferay.portal.kernel.exception.SystemException { 2209 return getPersistence() 2210 .findByG_N_T_C_Last(groupId, name, taskExecutorClassName, 2211 completed, orderByComparator); 2212 } 2213 2214 /** 2215 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2216 * 2217 * @param groupId the group ID 2218 * @param name the name 2219 * @param taskExecutorClassName the task executor class name 2220 * @param completed the completed 2221 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2222 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 2223 * @throws SystemException if a system exception occurred 2224 */ 2225 public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_C_Last( 2226 long groupId, java.lang.String name, 2227 java.lang.String taskExecutorClassName, boolean completed, 2228 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2229 throws com.liferay.portal.kernel.exception.SystemException { 2230 return getPersistence() 2231 .fetchByG_N_T_C_Last(groupId, name, taskExecutorClassName, 2232 completed, orderByComparator); 2233 } 2234 2235 /** 2236 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2237 * 2238 * @param backgroundTaskId the primary key of the current background task 2239 * @param groupId the group ID 2240 * @param name the name 2241 * @param taskExecutorClassName the task executor class name 2242 * @param completed the completed 2243 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2244 * @return the previous, current, and next background task 2245 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 2246 * @throws SystemException if a system exception occurred 2247 */ 2248 public static com.liferay.portal.model.BackgroundTask[] findByG_N_T_C_PrevAndNext( 2249 long backgroundTaskId, long groupId, java.lang.String name, 2250 java.lang.String taskExecutorClassName, boolean completed, 2251 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2252 throws com.liferay.portal.NoSuchBackgroundTaskException, 2253 com.liferay.portal.kernel.exception.SystemException { 2254 return getPersistence() 2255 .findByG_N_T_C_PrevAndNext(backgroundTaskId, groupId, name, 2256 taskExecutorClassName, completed, orderByComparator); 2257 } 2258 2259 /** 2260 * Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ? from the database. 2261 * 2262 * @param groupId the group ID 2263 * @param name the name 2264 * @param taskExecutorClassName the task executor class name 2265 * @param completed the completed 2266 * @throws SystemException if a system exception occurred 2267 */ 2268 public static void removeByG_N_T_C(long groupId, java.lang.String name, 2269 java.lang.String taskExecutorClassName, boolean completed) 2270 throws com.liferay.portal.kernel.exception.SystemException { 2271 getPersistence() 2272 .removeByG_N_T_C(groupId, name, taskExecutorClassName, completed); 2273 } 2274 2275 /** 2276 * Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2277 * 2278 * @param groupId the group ID 2279 * @param name the name 2280 * @param taskExecutorClassName the task executor class name 2281 * @param completed the completed 2282 * @return the number of matching background tasks 2283 * @throws SystemException if a system exception occurred 2284 */ 2285 public static int countByG_N_T_C(long groupId, java.lang.String name, 2286 java.lang.String taskExecutorClassName, boolean completed) 2287 throws com.liferay.portal.kernel.exception.SystemException { 2288 return getPersistence() 2289 .countByG_N_T_C(groupId, name, taskExecutorClassName, 2290 completed); 2291 } 2292 2293 /** 2294 * Caches the background task in the entity cache if it is enabled. 2295 * 2296 * @param backgroundTask the background task 2297 */ 2298 public static void cacheResult( 2299 com.liferay.portal.model.BackgroundTask backgroundTask) { 2300 getPersistence().cacheResult(backgroundTask); 2301 } 2302 2303 /** 2304 * Caches the background tasks in the entity cache if it is enabled. 2305 * 2306 * @param backgroundTasks the background tasks 2307 */ 2308 public static void cacheResult( 2309 java.util.List<com.liferay.portal.model.BackgroundTask> backgroundTasks) { 2310 getPersistence().cacheResult(backgroundTasks); 2311 } 2312 2313 /** 2314 * Creates a new background task with the primary key. Does not add the background task to the database. 2315 * 2316 * @param backgroundTaskId the primary key for the new background task 2317 * @return the new background task 2318 */ 2319 public static com.liferay.portal.model.BackgroundTask create( 2320 long backgroundTaskId) { 2321 return getPersistence().create(backgroundTaskId); 2322 } 2323 2324 /** 2325 * Removes the background task with the primary key from the database. Also notifies the appropriate model listeners. 2326 * 2327 * @param backgroundTaskId the primary key of the background task 2328 * @return the background task that was removed 2329 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 2330 * @throws SystemException if a system exception occurred 2331 */ 2332 public static com.liferay.portal.model.BackgroundTask remove( 2333 long backgroundTaskId) 2334 throws com.liferay.portal.NoSuchBackgroundTaskException, 2335 com.liferay.portal.kernel.exception.SystemException { 2336 return getPersistence().remove(backgroundTaskId); 2337 } 2338 2339 public static com.liferay.portal.model.BackgroundTask updateImpl( 2340 com.liferay.portal.model.BackgroundTask backgroundTask) 2341 throws com.liferay.portal.kernel.exception.SystemException { 2342 return getPersistence().updateImpl(backgroundTask); 2343 } 2344 2345 /** 2346 * Returns the background task with the primary key or throws a {@link com.liferay.portal.NoSuchBackgroundTaskException} if it could not be found. 2347 * 2348 * @param backgroundTaskId the primary key of the background task 2349 * @return the background task 2350 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 2351 * @throws SystemException if a system exception occurred 2352 */ 2353 public static com.liferay.portal.model.BackgroundTask findByPrimaryKey( 2354 long backgroundTaskId) 2355 throws com.liferay.portal.NoSuchBackgroundTaskException, 2356 com.liferay.portal.kernel.exception.SystemException { 2357 return getPersistence().findByPrimaryKey(backgroundTaskId); 2358 } 2359 2360 /** 2361 * Returns the background task with the primary key or returns <code>null</code> if it could not be found. 2362 * 2363 * @param backgroundTaskId the primary key of the background task 2364 * @return the background task, or <code>null</code> if a background task with the primary key could not be found 2365 * @throws SystemException if a system exception occurred 2366 */ 2367 public static com.liferay.portal.model.BackgroundTask fetchByPrimaryKey( 2368 long backgroundTaskId) 2369 throws com.liferay.portal.kernel.exception.SystemException { 2370 return getPersistence().fetchByPrimaryKey(backgroundTaskId); 2371 } 2372 2373 /** 2374 * Returns all the background tasks. 2375 * 2376 * @return the background tasks 2377 * @throws SystemException if a system exception occurred 2378 */ 2379 public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll() 2380 throws com.liferay.portal.kernel.exception.SystemException { 2381 return getPersistence().findAll(); 2382 } 2383 2384 /** 2385 * Returns a range of all the background tasks. 2386 * 2387 * <p> 2388 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2389 * </p> 2390 * 2391 * @param start the lower bound of the range of background tasks 2392 * @param end the upper bound of the range of background tasks (not inclusive) 2393 * @return the range of background tasks 2394 * @throws SystemException if a system exception occurred 2395 */ 2396 public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll( 2397 int start, int end) 2398 throws com.liferay.portal.kernel.exception.SystemException { 2399 return getPersistence().findAll(start, end); 2400 } 2401 2402 /** 2403 * Returns an ordered range of all the background tasks. 2404 * 2405 * <p> 2406 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2407 * </p> 2408 * 2409 * @param start the lower bound of the range of background tasks 2410 * @param end the upper bound of the range of background tasks (not inclusive) 2411 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2412 * @return the ordered range of background tasks 2413 * @throws SystemException if a system exception occurred 2414 */ 2415 public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll( 2416 int start, int end, 2417 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2418 throws com.liferay.portal.kernel.exception.SystemException { 2419 return getPersistence().findAll(start, end, orderByComparator); 2420 } 2421 2422 /** 2423 * Removes all the background tasks from the database. 2424 * 2425 * @throws SystemException if a system exception occurred 2426 */ 2427 public static void removeAll() 2428 throws com.liferay.portal.kernel.exception.SystemException { 2429 getPersistence().removeAll(); 2430 } 2431 2432 /** 2433 * Returns the number of background tasks. 2434 * 2435 * @return the number of background tasks 2436 * @throws SystemException if a system exception occurred 2437 */ 2438 public static int countAll() 2439 throws com.liferay.portal.kernel.exception.SystemException { 2440 return getPersistence().countAll(); 2441 } 2442 2443 public static BackgroundTaskPersistence getPersistence() { 2444 if (_persistence == null) { 2445 _persistence = (BackgroundTaskPersistence)PortalBeanLocatorUtil.locate(BackgroundTaskPersistence.class.getName()); 2446 2447 ReferenceRegistry.registerReference(BackgroundTaskUtil.class, 2448 "_persistence"); 2449 } 2450 2451 return _persistence; 2452 } 2453 2454 /** 2455 * @deprecated As of 6.2.0 2456 */ 2457 public void setPersistence(BackgroundTaskPersistence persistence) { 2458 } 2459 2460 private static BackgroundTaskPersistence _persistence; 2461 }