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