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 static 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 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ?. 758 * 759 * <p> 760 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 761 * </p> 762 * 763 * @param groupId the group ID 764 * @param taskExecutorClassNames the task executor class names 765 * @return the matching background tasks 766 * @throws SystemException if a system exception occurred 767 */ 768 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 769 long groupId, java.lang.String[] taskExecutorClassNames) 770 throws com.liferay.portal.kernel.exception.SystemException { 771 return getPersistence().findByG_T(groupId, taskExecutorClassNames); 772 } 773 774 /** 775 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. 776 * 777 * <p> 778 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 779 * </p> 780 * 781 * @param groupId the group ID 782 * @param taskExecutorClassNames the task executor class names 783 * @param start the lower bound of the range of background tasks 784 * @param end the upper bound of the range of background tasks (not inclusive) 785 * @return the range of matching background tasks 786 * @throws SystemException if a system exception occurred 787 */ 788 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 789 long groupId, java.lang.String[] taskExecutorClassNames, int start, 790 int end) throws com.liferay.portal.kernel.exception.SystemException { 791 return getPersistence() 792 .findByG_T(groupId, taskExecutorClassNames, start, end); 793 } 794 795 /** 796 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. 797 * 798 * <p> 799 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 800 * </p> 801 * 802 * @param groupId the group ID 803 * @param taskExecutorClassNames the task executor class names 804 * @param start the lower bound of the range of background tasks 805 * @param end the upper bound of the range of background tasks (not inclusive) 806 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 807 * @return the ordered range of matching background tasks 808 * @throws SystemException if a system exception occurred 809 */ 810 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T( 811 long groupId, java.lang.String[] taskExecutorClassNames, int start, 812 int end, 813 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 814 throws com.liferay.portal.kernel.exception.SystemException { 815 return getPersistence() 816 .findByG_T(groupId, taskExecutorClassNames, start, end, 817 orderByComparator); 818 } 819 820 /** 821 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? from the database. 822 * 823 * @param groupId the group ID 824 * @param taskExecutorClassName the task executor class name 825 * @throws SystemException if a system exception occurred 826 */ 827 public static void removeByG_T(long groupId, 828 java.lang.String taskExecutorClassName) 829 throws com.liferay.portal.kernel.exception.SystemException { 830 getPersistence().removeByG_T(groupId, taskExecutorClassName); 831 } 832 833 /** 834 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ?. 835 * 836 * @param groupId the group ID 837 * @param taskExecutorClassName the task executor class name 838 * @return the number of matching background tasks 839 * @throws SystemException if a system exception occurred 840 */ 841 public static int countByG_T(long groupId, 842 java.lang.String taskExecutorClassName) 843 throws com.liferay.portal.kernel.exception.SystemException { 844 return getPersistence().countByG_T(groupId, taskExecutorClassName); 845 } 846 847 /** 848 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ?. 849 * 850 * @param groupId the group ID 851 * @param taskExecutorClassNames the task executor class names 852 * @return the number of matching background tasks 853 * @throws SystemException if a system exception occurred 854 */ 855 public static int countByG_T(long groupId, 856 java.lang.String[] taskExecutorClassNames) 857 throws com.liferay.portal.kernel.exception.SystemException { 858 return getPersistence().countByG_T(groupId, taskExecutorClassNames); 859 } 860 861 /** 862 * Returns all the background tasks where groupId = ? and status = ?. 863 * 864 * @param groupId the group ID 865 * @param status the status 866 * @return the matching background tasks 867 * @throws SystemException if a system exception occurred 868 */ 869 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S( 870 long groupId, int status) 871 throws com.liferay.portal.kernel.exception.SystemException { 872 return getPersistence().findByG_S(groupId, status); 873 } 874 875 /** 876 * Returns a range of all the background tasks where groupId = ? and status = ?. 877 * 878 * <p> 879 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 880 * </p> 881 * 882 * @param groupId the group ID 883 * @param status the status 884 * @param start the lower bound of the range of background tasks 885 * @param end the upper bound of the range of background tasks (not inclusive) 886 * @return the range of matching background tasks 887 * @throws SystemException if a system exception occurred 888 */ 889 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S( 890 long groupId, int status, int start, int end) 891 throws com.liferay.portal.kernel.exception.SystemException { 892 return getPersistence().findByG_S(groupId, status, start, end); 893 } 894 895 /** 896 * Returns an ordered range of all the background tasks where groupId = ? and status = ?. 897 * 898 * <p> 899 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 900 * </p> 901 * 902 * @param groupId the group ID 903 * @param status the status 904 * @param start the lower bound of the range of background tasks 905 * @param end the upper bound of the range of background tasks (not inclusive) 906 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 907 * @return the ordered range of matching background tasks 908 * @throws SystemException if a system exception occurred 909 */ 910 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_S( 911 long groupId, int status, int start, int end, 912 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 913 throws com.liferay.portal.kernel.exception.SystemException { 914 return getPersistence() 915 .findByG_S(groupId, status, start, end, orderByComparator); 916 } 917 918 /** 919 * Returns the first background task in the ordered set where groupId = ? and status = ?. 920 * 921 * @param groupId the group ID 922 * @param status the status 923 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 924 * @return the first matching background task 925 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 926 * @throws SystemException if a system exception occurred 927 */ 928 public static com.liferay.portal.model.BackgroundTask findByG_S_First( 929 long groupId, int status, 930 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 931 throws com.liferay.portal.NoSuchBackgroundTaskException, 932 com.liferay.portal.kernel.exception.SystemException { 933 return getPersistence() 934 .findByG_S_First(groupId, status, orderByComparator); 935 } 936 937 /** 938 * Returns the first background task in the ordered set where groupId = ? and status = ?. 939 * 940 * @param groupId the group ID 941 * @param status the status 942 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 943 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 944 * @throws SystemException if a system exception occurred 945 */ 946 public static com.liferay.portal.model.BackgroundTask fetchByG_S_First( 947 long groupId, int status, 948 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 949 throws com.liferay.portal.kernel.exception.SystemException { 950 return getPersistence() 951 .fetchByG_S_First(groupId, status, orderByComparator); 952 } 953 954 /** 955 * Returns the last background task in the ordered set where groupId = ? and status = ?. 956 * 957 * @param groupId the group ID 958 * @param status the status 959 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 960 * @return the last matching background task 961 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 962 * @throws SystemException if a system exception occurred 963 */ 964 public static com.liferay.portal.model.BackgroundTask findByG_S_Last( 965 long groupId, int status, 966 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 967 throws com.liferay.portal.NoSuchBackgroundTaskException, 968 com.liferay.portal.kernel.exception.SystemException { 969 return getPersistence() 970 .findByG_S_Last(groupId, status, orderByComparator); 971 } 972 973 /** 974 * Returns the last background task in the ordered set where groupId = ? and status = ?. 975 * 976 * @param groupId the group ID 977 * @param status the status 978 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 979 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 980 * @throws SystemException if a system exception occurred 981 */ 982 public static com.liferay.portal.model.BackgroundTask fetchByG_S_Last( 983 long groupId, int status, 984 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 985 throws com.liferay.portal.kernel.exception.SystemException { 986 return getPersistence() 987 .fetchByG_S_Last(groupId, status, orderByComparator); 988 } 989 990 /** 991 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and status = ?. 992 * 993 * @param backgroundTaskId the primary key of the current background task 994 * @param groupId the group ID 995 * @param status the status 996 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 997 * @return the previous, current, and next background task 998 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 999 * @throws SystemException if a system exception occurred 1000 */ 1001 public static com.liferay.portal.model.BackgroundTask[] findByG_S_PrevAndNext( 1002 long backgroundTaskId, long groupId, int status, 1003 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1004 throws com.liferay.portal.NoSuchBackgroundTaskException, 1005 com.liferay.portal.kernel.exception.SystemException { 1006 return getPersistence() 1007 .findByG_S_PrevAndNext(backgroundTaskId, groupId, status, 1008 orderByComparator); 1009 } 1010 1011 /** 1012 * Removes all the background tasks where groupId = ? and status = ? from the database. 1013 * 1014 * @param groupId the group ID 1015 * @param status the status 1016 * @throws SystemException if a system exception occurred 1017 */ 1018 public static void removeByG_S(long groupId, int status) 1019 throws com.liferay.portal.kernel.exception.SystemException { 1020 getPersistence().removeByG_S(groupId, status); 1021 } 1022 1023 /** 1024 * Returns the number of background tasks where groupId = ? and status = ?. 1025 * 1026 * @param groupId the group ID 1027 * @param status the status 1028 * @return the number of matching background tasks 1029 * @throws SystemException if a system exception occurred 1030 */ 1031 public static int countByG_S(long groupId, int status) 1032 throws com.liferay.portal.kernel.exception.SystemException { 1033 return getPersistence().countByG_S(groupId, status); 1034 } 1035 1036 /** 1037 * Returns all the background tasks where taskExecutorClassName = ? and status = ?. 1038 * 1039 * @param taskExecutorClassName the task executor class name 1040 * @param status the status 1041 * @return the matching background tasks 1042 * @throws SystemException if a system exception occurred 1043 */ 1044 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1045 java.lang.String taskExecutorClassName, int status) 1046 throws com.liferay.portal.kernel.exception.SystemException { 1047 return getPersistence().findByT_S(taskExecutorClassName, status); 1048 } 1049 1050 /** 1051 * Returns a range of all the background tasks where taskExecutorClassName = ? and status = ?. 1052 * 1053 * <p> 1054 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1055 * </p> 1056 * 1057 * @param taskExecutorClassName the task executor class name 1058 * @param status the status 1059 * @param start the lower bound of the range of background tasks 1060 * @param end the upper bound of the range of background tasks (not inclusive) 1061 * @return the range of matching background tasks 1062 * @throws SystemException if a system exception occurred 1063 */ 1064 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1065 java.lang.String taskExecutorClassName, int status, int start, int end) 1066 throws com.liferay.portal.kernel.exception.SystemException { 1067 return getPersistence() 1068 .findByT_S(taskExecutorClassName, status, start, end); 1069 } 1070 1071 /** 1072 * Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?. 1073 * 1074 * <p> 1075 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1076 * </p> 1077 * 1078 * @param taskExecutorClassName the task executor class name 1079 * @param status the status 1080 * @param start the lower bound of the range of background tasks 1081 * @param end the upper bound of the range of background tasks (not inclusive) 1082 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1083 * @return the ordered range of matching background tasks 1084 * @throws SystemException if a system exception occurred 1085 */ 1086 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1087 java.lang.String taskExecutorClassName, int status, int start, int end, 1088 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1089 throws com.liferay.portal.kernel.exception.SystemException { 1090 return getPersistence() 1091 .findByT_S(taskExecutorClassName, status, start, end, 1092 orderByComparator); 1093 } 1094 1095 /** 1096 * Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. 1097 * 1098 * @param taskExecutorClassName the task executor class name 1099 * @param status the status 1100 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1101 * @return the first matching background task 1102 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1103 * @throws SystemException if a system exception occurred 1104 */ 1105 public static com.liferay.portal.model.BackgroundTask findByT_S_First( 1106 java.lang.String taskExecutorClassName, 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_First(taskExecutorClassName, status, 1112 orderByComparator); 1113 } 1114 1115 /** 1116 * Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. 1117 * 1118 * @param taskExecutorClassName the task executor class name 1119 * @param status the status 1120 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1121 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1122 * @throws SystemException if a system exception occurred 1123 */ 1124 public static com.liferay.portal.model.BackgroundTask fetchByT_S_First( 1125 java.lang.String taskExecutorClassName, int status, 1126 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1127 throws com.liferay.portal.kernel.exception.SystemException { 1128 return getPersistence() 1129 .fetchByT_S_First(taskExecutorClassName, status, 1130 orderByComparator); 1131 } 1132 1133 /** 1134 * Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. 1135 * 1136 * @param taskExecutorClassName the task executor class name 1137 * @param status the status 1138 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1139 * @return the last matching background task 1140 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1141 * @throws SystemException if a system exception occurred 1142 */ 1143 public static com.liferay.portal.model.BackgroundTask findByT_S_Last( 1144 java.lang.String taskExecutorClassName, int status, 1145 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1146 throws com.liferay.portal.NoSuchBackgroundTaskException, 1147 com.liferay.portal.kernel.exception.SystemException { 1148 return getPersistence() 1149 .findByT_S_Last(taskExecutorClassName, status, 1150 orderByComparator); 1151 } 1152 1153 /** 1154 * Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. 1155 * 1156 * @param taskExecutorClassName the task executor class name 1157 * @param status the status 1158 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1159 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1160 * @throws SystemException if a system exception occurred 1161 */ 1162 public static com.liferay.portal.model.BackgroundTask fetchByT_S_Last( 1163 java.lang.String taskExecutorClassName, int status, 1164 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1165 throws com.liferay.portal.kernel.exception.SystemException { 1166 return getPersistence() 1167 .fetchByT_S_Last(taskExecutorClassName, status, 1168 orderByComparator); 1169 } 1170 1171 /** 1172 * Returns the background tasks before and after the current background task in the ordered set where taskExecutorClassName = ? and status = ?. 1173 * 1174 * @param backgroundTaskId the primary key of the current background task 1175 * @param taskExecutorClassName the task executor class name 1176 * @param status the status 1177 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1178 * @return the previous, current, and next background task 1179 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1180 * @throws SystemException if a system exception occurred 1181 */ 1182 public static com.liferay.portal.model.BackgroundTask[] findByT_S_PrevAndNext( 1183 long backgroundTaskId, java.lang.String taskExecutorClassName, 1184 int status, 1185 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1186 throws com.liferay.portal.NoSuchBackgroundTaskException, 1187 com.liferay.portal.kernel.exception.SystemException { 1188 return getPersistence() 1189 .findByT_S_PrevAndNext(backgroundTaskId, 1190 taskExecutorClassName, status, orderByComparator); 1191 } 1192 1193 /** 1194 * Returns all the background tasks where taskExecutorClassName = any ? and status = ?. 1195 * 1196 * <p> 1197 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1198 * </p> 1199 * 1200 * @param taskExecutorClassNames the task executor class names 1201 * @param status the status 1202 * @return the matching background tasks 1203 * @throws SystemException if a system exception occurred 1204 */ 1205 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1206 java.lang.String[] taskExecutorClassNames, int status) 1207 throws com.liferay.portal.kernel.exception.SystemException { 1208 return getPersistence().findByT_S(taskExecutorClassNames, status); 1209 } 1210 1211 /** 1212 * Returns a range of all the background tasks where taskExecutorClassName = any ? and status = ?. 1213 * 1214 * <p> 1215 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1216 * </p> 1217 * 1218 * @param taskExecutorClassNames the task executor class names 1219 * @param status the status 1220 * @param start the lower bound of the range of background tasks 1221 * @param end the upper bound of the range of background tasks (not inclusive) 1222 * @return the range of matching background tasks 1223 * @throws SystemException if a system exception occurred 1224 */ 1225 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1226 java.lang.String[] taskExecutorClassNames, int status, int start, 1227 int end) throws com.liferay.portal.kernel.exception.SystemException { 1228 return getPersistence() 1229 .findByT_S(taskExecutorClassNames, status, start, end); 1230 } 1231 1232 /** 1233 * Returns an ordered range of all the background tasks where taskExecutorClassName = any ? and status = ?. 1234 * 1235 * <p> 1236 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1237 * </p> 1238 * 1239 * @param taskExecutorClassNames the task executor class names 1240 * @param status the status 1241 * @param start the lower bound of the range of background tasks 1242 * @param end the upper bound of the range of background tasks (not inclusive) 1243 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1244 * @return the ordered range of matching background tasks 1245 * @throws SystemException if a system exception occurred 1246 */ 1247 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByT_S( 1248 java.lang.String[] taskExecutorClassNames, int status, int start, 1249 int end, 1250 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1251 throws com.liferay.portal.kernel.exception.SystemException { 1252 return getPersistence() 1253 .findByT_S(taskExecutorClassNames, status, start, end, 1254 orderByComparator); 1255 } 1256 1257 /** 1258 * Removes all the background tasks where taskExecutorClassName = ? and status = ? from the database. 1259 * 1260 * @param taskExecutorClassName the task executor class name 1261 * @param status the status 1262 * @throws SystemException if a system exception occurred 1263 */ 1264 public static void removeByT_S(java.lang.String taskExecutorClassName, 1265 int status) throws com.liferay.portal.kernel.exception.SystemException { 1266 getPersistence().removeByT_S(taskExecutorClassName, status); 1267 } 1268 1269 /** 1270 * Returns the number of background tasks where taskExecutorClassName = ? and status = ?. 1271 * 1272 * @param taskExecutorClassName the task executor class name 1273 * @param status the status 1274 * @return the number of matching background tasks 1275 * @throws SystemException if a system exception occurred 1276 */ 1277 public static int countByT_S(java.lang.String taskExecutorClassName, 1278 int status) throws com.liferay.portal.kernel.exception.SystemException { 1279 return getPersistence().countByT_S(taskExecutorClassName, status); 1280 } 1281 1282 /** 1283 * Returns the number of background tasks where taskExecutorClassName = any ? and status = ?. 1284 * 1285 * @param taskExecutorClassNames the task executor class names 1286 * @param status the status 1287 * @return the number of matching background tasks 1288 * @throws SystemException if a system exception occurred 1289 */ 1290 public static int countByT_S(java.lang.String[] taskExecutorClassNames, 1291 int status) throws com.liferay.portal.kernel.exception.SystemException { 1292 return getPersistence().countByT_S(taskExecutorClassNames, status); 1293 } 1294 1295 /** 1296 * Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1297 * 1298 * @param groupId the group ID 1299 * @param name the name 1300 * @param taskExecutorClassName the task executor class name 1301 * @return the matching background tasks 1302 * @throws SystemException if a system exception occurred 1303 */ 1304 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T( 1305 long groupId, java.lang.String name, 1306 java.lang.String taskExecutorClassName) 1307 throws com.liferay.portal.kernel.exception.SystemException { 1308 return getPersistence().findByG_N_T(groupId, name, taskExecutorClassName); 1309 } 1310 1311 /** 1312 * Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1313 * 1314 * <p> 1315 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1316 * </p> 1317 * 1318 * @param groupId the group ID 1319 * @param name the name 1320 * @param taskExecutorClassName the task executor class name 1321 * @param start the lower bound of the range of background tasks 1322 * @param end the upper bound of the range of background tasks (not inclusive) 1323 * @return the range of matching background tasks 1324 * @throws SystemException if a system exception occurred 1325 */ 1326 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T( 1327 long groupId, java.lang.String name, 1328 java.lang.String taskExecutorClassName, int start, int end) 1329 throws com.liferay.portal.kernel.exception.SystemException { 1330 return getPersistence() 1331 .findByG_N_T(groupId, name, taskExecutorClassName, start, end); 1332 } 1333 1334 /** 1335 * Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1336 * 1337 * <p> 1338 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1339 * </p> 1340 * 1341 * @param groupId the group ID 1342 * @param name the name 1343 * @param taskExecutorClassName the task executor class name 1344 * @param start the lower bound of the range of background tasks 1345 * @param end the upper bound of the range of background tasks (not inclusive) 1346 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1347 * @return the ordered range of matching background tasks 1348 * @throws SystemException if a system exception occurred 1349 */ 1350 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T( 1351 long groupId, java.lang.String name, 1352 java.lang.String taskExecutorClassName, int start, int end, 1353 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1354 throws com.liferay.portal.kernel.exception.SystemException { 1355 return getPersistence() 1356 .findByG_N_T(groupId, name, taskExecutorClassName, start, 1357 end, orderByComparator); 1358 } 1359 1360 /** 1361 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1362 * 1363 * @param groupId the group ID 1364 * @param name the name 1365 * @param taskExecutorClassName the task executor class name 1366 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1367 * @return the first matching background task 1368 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1369 * @throws SystemException if a system exception occurred 1370 */ 1371 public static com.liferay.portal.model.BackgroundTask findByG_N_T_First( 1372 long groupId, java.lang.String name, 1373 java.lang.String taskExecutorClassName, 1374 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1375 throws com.liferay.portal.NoSuchBackgroundTaskException, 1376 com.liferay.portal.kernel.exception.SystemException { 1377 return getPersistence() 1378 .findByG_N_T_First(groupId, name, taskExecutorClassName, 1379 orderByComparator); 1380 } 1381 1382 /** 1383 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1384 * 1385 * @param groupId the group ID 1386 * @param name the name 1387 * @param taskExecutorClassName the task executor class name 1388 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1389 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1390 * @throws SystemException if a system exception occurred 1391 */ 1392 public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_First( 1393 long groupId, java.lang.String name, 1394 java.lang.String taskExecutorClassName, 1395 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1396 throws com.liferay.portal.kernel.exception.SystemException { 1397 return getPersistence() 1398 .fetchByG_N_T_First(groupId, name, taskExecutorClassName, 1399 orderByComparator); 1400 } 1401 1402 /** 1403 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1404 * 1405 * @param groupId the group ID 1406 * @param name the name 1407 * @param taskExecutorClassName the task executor class name 1408 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1409 * @return the last matching background task 1410 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1411 * @throws SystemException if a system exception occurred 1412 */ 1413 public static com.liferay.portal.model.BackgroundTask findByG_N_T_Last( 1414 long groupId, java.lang.String name, 1415 java.lang.String taskExecutorClassName, 1416 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1417 throws com.liferay.portal.NoSuchBackgroundTaskException, 1418 com.liferay.portal.kernel.exception.SystemException { 1419 return getPersistence() 1420 .findByG_N_T_Last(groupId, name, taskExecutorClassName, 1421 orderByComparator); 1422 } 1423 1424 /** 1425 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1426 * 1427 * @param groupId the group ID 1428 * @param name the name 1429 * @param taskExecutorClassName the task executor class name 1430 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1431 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1432 * @throws SystemException if a system exception occurred 1433 */ 1434 public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_Last( 1435 long groupId, java.lang.String name, 1436 java.lang.String taskExecutorClassName, 1437 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1438 throws com.liferay.portal.kernel.exception.SystemException { 1439 return getPersistence() 1440 .fetchByG_N_T_Last(groupId, name, taskExecutorClassName, 1441 orderByComparator); 1442 } 1443 1444 /** 1445 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 1446 * 1447 * @param backgroundTaskId the primary key of the current background task 1448 * @param groupId the group ID 1449 * @param name the name 1450 * @param taskExecutorClassName the task executor class name 1451 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1452 * @return the previous, current, and next background task 1453 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1454 * @throws SystemException if a system exception occurred 1455 */ 1456 public static com.liferay.portal.model.BackgroundTask[] findByG_N_T_PrevAndNext( 1457 long backgroundTaskId, long groupId, java.lang.String name, 1458 java.lang.String taskExecutorClassName, 1459 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1460 throws com.liferay.portal.NoSuchBackgroundTaskException, 1461 com.liferay.portal.kernel.exception.SystemException { 1462 return getPersistence() 1463 .findByG_N_T_PrevAndNext(backgroundTaskId, groupId, name, 1464 taskExecutorClassName, orderByComparator); 1465 } 1466 1467 /** 1468 * Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? from the database. 1469 * 1470 * @param groupId the group ID 1471 * @param name the name 1472 * @param taskExecutorClassName the task executor class name 1473 * @throws SystemException if a system exception occurred 1474 */ 1475 public static void removeByG_N_T(long groupId, java.lang.String name, 1476 java.lang.String taskExecutorClassName) 1477 throws com.liferay.portal.kernel.exception.SystemException { 1478 getPersistence().removeByG_N_T(groupId, name, taskExecutorClassName); 1479 } 1480 1481 /** 1482 * Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1483 * 1484 * @param groupId the group ID 1485 * @param name the name 1486 * @param taskExecutorClassName the task executor class name 1487 * @return the number of matching background tasks 1488 * @throws SystemException if a system exception occurred 1489 */ 1490 public static int countByG_N_T(long groupId, java.lang.String name, 1491 java.lang.String taskExecutorClassName) 1492 throws com.liferay.portal.kernel.exception.SystemException { 1493 return getPersistence() 1494 .countByG_N_T(groupId, name, taskExecutorClassName); 1495 } 1496 1497 /** 1498 * Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1499 * 1500 * @param groupId the group ID 1501 * @param taskExecutorClassName the task executor class name 1502 * @param completed the completed 1503 * @return the matching background tasks 1504 * @throws SystemException if a system exception occurred 1505 */ 1506 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1507 long groupId, java.lang.String taskExecutorClassName, boolean completed) 1508 throws com.liferay.portal.kernel.exception.SystemException { 1509 return getPersistence() 1510 .findByG_T_C(groupId, taskExecutorClassName, completed); 1511 } 1512 1513 /** 1514 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1515 * 1516 * <p> 1517 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1518 * </p> 1519 * 1520 * @param groupId the group ID 1521 * @param taskExecutorClassName the task executor class name 1522 * @param completed the completed 1523 * @param start the lower bound of the range of background tasks 1524 * @param end the upper bound of the range of background tasks (not inclusive) 1525 * @return the range of matching background tasks 1526 * @throws SystemException if a system exception occurred 1527 */ 1528 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1529 long groupId, java.lang.String taskExecutorClassName, 1530 boolean completed, int start, int end) 1531 throws com.liferay.portal.kernel.exception.SystemException { 1532 return getPersistence() 1533 .findByG_T_C(groupId, taskExecutorClassName, completed, 1534 start, end); 1535 } 1536 1537 /** 1538 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1539 * 1540 * <p> 1541 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.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. 1542 * </p> 1543 * 1544 * @param groupId the group ID 1545 * @param taskExecutorClassName the task executor class name 1546 * @param completed the completed 1547 * @param start the lower bound of the range of background tasks 1548 * @param end the upper bound of the range of background tasks (not inclusive) 1549 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1550 * @return the ordered range of matching background tasks 1551 * @throws SystemException if a system exception occurred 1552 */ 1553 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1554 long groupId, java.lang.String taskExecutorClassName, 1555 boolean completed, int start, int end, 1556 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1557 throws com.liferay.portal.kernel.exception.SystemException { 1558 return getPersistence() 1559 .findByG_T_C(groupId, taskExecutorClassName, completed, 1560 start, end, orderByComparator); 1561 } 1562 1563 /** 1564 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1565 * 1566 * @param groupId the group ID 1567 * @param taskExecutorClassName the task executor class name 1568 * @param completed the completed 1569 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1570 * @return the first matching background task 1571 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1572 * @throws SystemException if a system exception occurred 1573 */ 1574 public static com.liferay.portal.model.BackgroundTask findByG_T_C_First( 1575 long groupId, java.lang.String taskExecutorClassName, 1576 boolean completed, 1577 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1578 throws com.liferay.portal.NoSuchBackgroundTaskException, 1579 com.liferay.portal.kernel.exception.SystemException { 1580 return getPersistence() 1581 .findByG_T_C_First(groupId, taskExecutorClassName, 1582 completed, orderByComparator); 1583 } 1584 1585 /** 1586 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1587 * 1588 * @param groupId the group ID 1589 * @param taskExecutorClassName the task executor class name 1590 * @param completed the completed 1591 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1592 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1593 * @throws SystemException if a system exception occurred 1594 */ 1595 public static com.liferay.portal.model.BackgroundTask fetchByG_T_C_First( 1596 long groupId, java.lang.String taskExecutorClassName, 1597 boolean completed, 1598 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1599 throws com.liferay.portal.kernel.exception.SystemException { 1600 return getPersistence() 1601 .fetchByG_T_C_First(groupId, taskExecutorClassName, 1602 completed, orderByComparator); 1603 } 1604 1605 /** 1606 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1607 * 1608 * @param groupId the group ID 1609 * @param taskExecutorClassName the task executor class name 1610 * @param completed the completed 1611 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1612 * @return the last matching background task 1613 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1614 * @throws SystemException if a system exception occurred 1615 */ 1616 public static com.liferay.portal.model.BackgroundTask findByG_T_C_Last( 1617 long groupId, java.lang.String taskExecutorClassName, 1618 boolean completed, 1619 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1620 throws com.liferay.portal.NoSuchBackgroundTaskException, 1621 com.liferay.portal.kernel.exception.SystemException { 1622 return getPersistence() 1623 .findByG_T_C_Last(groupId, taskExecutorClassName, completed, 1624 orderByComparator); 1625 } 1626 1627 /** 1628 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1629 * 1630 * @param groupId the group ID 1631 * @param taskExecutorClassName the task executor class name 1632 * @param completed the completed 1633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1634 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1635 * @throws SystemException if a system exception occurred 1636 */ 1637 public static com.liferay.portal.model.BackgroundTask fetchByG_T_C_Last( 1638 long groupId, java.lang.String taskExecutorClassName, 1639 boolean completed, 1640 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1641 throws com.liferay.portal.kernel.exception.SystemException { 1642 return getPersistence() 1643 .fetchByG_T_C_Last(groupId, taskExecutorClassName, 1644 completed, orderByComparator); 1645 } 1646 1647 /** 1648 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1649 * 1650 * @param backgroundTaskId the primary key of the current background task 1651 * @param groupId the group ID 1652 * @param taskExecutorClassName the task executor class name 1653 * @param completed the completed 1654 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1655 * @return the previous, current, and next background task 1656 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1657 * @throws SystemException if a system exception occurred 1658 */ 1659 public static com.liferay.portal.model.BackgroundTask[] findByG_T_C_PrevAndNext( 1660 long backgroundTaskId, long groupId, 1661 java.lang.String taskExecutorClassName, boolean completed, 1662 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1663 throws com.liferay.portal.NoSuchBackgroundTaskException, 1664 com.liferay.portal.kernel.exception.SystemException { 1665 return getPersistence() 1666 .findByG_T_C_PrevAndNext(backgroundTaskId, groupId, 1667 taskExecutorClassName, completed, orderByComparator); 1668 } 1669 1670 /** 1671 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1672 * 1673 * <p> 1674 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1675 * </p> 1676 * 1677 * @param groupId the group ID 1678 * @param taskExecutorClassNames the task executor class names 1679 * @param completed the completed 1680 * @return the matching background tasks 1681 * @throws SystemException if a system exception occurred 1682 */ 1683 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1684 long groupId, java.lang.String[] taskExecutorClassNames, 1685 boolean completed) 1686 throws com.liferay.portal.kernel.exception.SystemException { 1687 return getPersistence() 1688 .findByG_T_C(groupId, taskExecutorClassNames, completed); 1689 } 1690 1691 /** 1692 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1693 * 1694 * <p> 1695 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1696 * </p> 1697 * 1698 * @param groupId the group ID 1699 * @param taskExecutorClassNames the task executor class names 1700 * @param completed the completed 1701 * @param start the lower bound of the range of background tasks 1702 * @param end the upper bound of the range of background tasks (not inclusive) 1703 * @return the range of matching background tasks 1704 * @throws SystemException if a system exception occurred 1705 */ 1706 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1707 long groupId, java.lang.String[] taskExecutorClassNames, 1708 boolean completed, int start, int end) 1709 throws com.liferay.portal.kernel.exception.SystemException { 1710 return getPersistence() 1711 .findByG_T_C(groupId, taskExecutorClassNames, completed, 1712 start, end); 1713 } 1714 1715 /** 1716 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1717 * 1718 * <p> 1719 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1720 * </p> 1721 * 1722 * @param groupId the group ID 1723 * @param taskExecutorClassNames the task executor class names 1724 * @param completed the completed 1725 * @param start the lower bound of the range of background tasks 1726 * @param end the upper bound of the range of background tasks (not inclusive) 1727 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1728 * @return the ordered range of matching background tasks 1729 * @throws SystemException if a system exception occurred 1730 */ 1731 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_C( 1732 long groupId, java.lang.String[] taskExecutorClassNames, 1733 boolean completed, int start, int end, 1734 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1735 throws com.liferay.portal.kernel.exception.SystemException { 1736 return getPersistence() 1737 .findByG_T_C(groupId, taskExecutorClassNames, completed, 1738 start, end, orderByComparator); 1739 } 1740 1741 /** 1742 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ? from the database. 1743 * 1744 * @param groupId the group ID 1745 * @param taskExecutorClassName the task executor class name 1746 * @param completed the completed 1747 * @throws SystemException if a system exception occurred 1748 */ 1749 public static void removeByG_T_C(long groupId, 1750 java.lang.String taskExecutorClassName, boolean completed) 1751 throws com.liferay.portal.kernel.exception.SystemException { 1752 getPersistence().removeByG_T_C(groupId, taskExecutorClassName, completed); 1753 } 1754 1755 /** 1756 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1757 * 1758 * @param groupId the group ID 1759 * @param taskExecutorClassName the task executor class name 1760 * @param completed the completed 1761 * @return the number of matching background tasks 1762 * @throws SystemException if a system exception occurred 1763 */ 1764 public static int countByG_T_C(long groupId, 1765 java.lang.String taskExecutorClassName, boolean completed) 1766 throws com.liferay.portal.kernel.exception.SystemException { 1767 return getPersistence() 1768 .countByG_T_C(groupId, taskExecutorClassName, completed); 1769 } 1770 1771 /** 1772 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1773 * 1774 * @param groupId the group ID 1775 * @param taskExecutorClassNames the task executor class names 1776 * @param completed the completed 1777 * @return the number of matching background tasks 1778 * @throws SystemException if a system exception occurred 1779 */ 1780 public static int countByG_T_C(long groupId, 1781 java.lang.String[] taskExecutorClassNames, boolean completed) 1782 throws com.liferay.portal.kernel.exception.SystemException { 1783 return getPersistence() 1784 .countByG_T_C(groupId, taskExecutorClassNames, completed); 1785 } 1786 1787 /** 1788 * Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1789 * 1790 * @param groupId the group ID 1791 * @param taskExecutorClassName the task executor class name 1792 * @param status the status 1793 * @return the matching background tasks 1794 * @throws SystemException if a system exception occurred 1795 */ 1796 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1797 long groupId, java.lang.String taskExecutorClassName, int status) 1798 throws com.liferay.portal.kernel.exception.SystemException { 1799 return getPersistence() 1800 .findByG_T_S(groupId, taskExecutorClassName, status); 1801 } 1802 1803 /** 1804 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1805 * 1806 * <p> 1807 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1808 * </p> 1809 * 1810 * @param groupId the group ID 1811 * @param taskExecutorClassName the task executor class name 1812 * @param status the status 1813 * @param start the lower bound of the range of background tasks 1814 * @param end the upper bound of the range of background tasks (not inclusive) 1815 * @return the range of matching background tasks 1816 * @throws SystemException if a system exception occurred 1817 */ 1818 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1819 long groupId, java.lang.String taskExecutorClassName, int status, 1820 int start, int end) 1821 throws com.liferay.portal.kernel.exception.SystemException { 1822 return getPersistence() 1823 .findByG_T_S(groupId, taskExecutorClassName, status, start, 1824 end); 1825 } 1826 1827 /** 1828 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1829 * 1830 * <p> 1831 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1832 * </p> 1833 * 1834 * @param groupId the group ID 1835 * @param taskExecutorClassName the task executor class name 1836 * @param status the status 1837 * @param start the lower bound of the range of background tasks 1838 * @param end the upper bound of the range of background tasks (not inclusive) 1839 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1840 * @return the ordered range of matching background tasks 1841 * @throws SystemException if a system exception occurred 1842 */ 1843 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1844 long groupId, java.lang.String taskExecutorClassName, int status, 1845 int start, int end, 1846 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1847 throws com.liferay.portal.kernel.exception.SystemException { 1848 return getPersistence() 1849 .findByG_T_S(groupId, taskExecutorClassName, status, start, 1850 end, orderByComparator); 1851 } 1852 1853 /** 1854 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1855 * 1856 * @param groupId the group ID 1857 * @param taskExecutorClassName the task executor class name 1858 * @param status the status 1859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1860 * @return the first matching background task 1861 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1862 * @throws SystemException if a system exception occurred 1863 */ 1864 public static com.liferay.portal.model.BackgroundTask findByG_T_S_First( 1865 long groupId, java.lang.String taskExecutorClassName, int status, 1866 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1867 throws com.liferay.portal.NoSuchBackgroundTaskException, 1868 com.liferay.portal.kernel.exception.SystemException { 1869 return getPersistence() 1870 .findByG_T_S_First(groupId, taskExecutorClassName, status, 1871 orderByComparator); 1872 } 1873 1874 /** 1875 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1876 * 1877 * @param groupId the group ID 1878 * @param taskExecutorClassName the task executor class name 1879 * @param status the status 1880 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1881 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1882 * @throws SystemException if a system exception occurred 1883 */ 1884 public static com.liferay.portal.model.BackgroundTask fetchByG_T_S_First( 1885 long groupId, java.lang.String taskExecutorClassName, int status, 1886 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1887 throws com.liferay.portal.kernel.exception.SystemException { 1888 return getPersistence() 1889 .fetchByG_T_S_First(groupId, taskExecutorClassName, status, 1890 orderByComparator); 1891 } 1892 1893 /** 1894 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1895 * 1896 * @param groupId the group ID 1897 * @param taskExecutorClassName the task executor class name 1898 * @param status the status 1899 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1900 * @return the last matching background task 1901 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 1902 * @throws SystemException if a system exception occurred 1903 */ 1904 public static com.liferay.portal.model.BackgroundTask findByG_T_S_Last( 1905 long groupId, java.lang.String taskExecutorClassName, int status, 1906 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1907 throws com.liferay.portal.NoSuchBackgroundTaskException, 1908 com.liferay.portal.kernel.exception.SystemException { 1909 return getPersistence() 1910 .findByG_T_S_Last(groupId, taskExecutorClassName, status, 1911 orderByComparator); 1912 } 1913 1914 /** 1915 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1916 * 1917 * @param groupId the group ID 1918 * @param taskExecutorClassName the task executor class name 1919 * @param status the status 1920 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1921 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1922 * @throws SystemException if a system exception occurred 1923 */ 1924 public static com.liferay.portal.model.BackgroundTask fetchByG_T_S_Last( 1925 long groupId, java.lang.String taskExecutorClassName, int status, 1926 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1927 throws com.liferay.portal.kernel.exception.SystemException { 1928 return getPersistence() 1929 .fetchByG_T_S_Last(groupId, taskExecutorClassName, status, 1930 orderByComparator); 1931 } 1932 1933 /** 1934 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1935 * 1936 * @param backgroundTaskId the primary key of the current background task 1937 * @param groupId the group ID 1938 * @param taskExecutorClassName the task executor class name 1939 * @param status the status 1940 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1941 * @return the previous, current, and next background task 1942 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 1943 * @throws SystemException if a system exception occurred 1944 */ 1945 public static com.liferay.portal.model.BackgroundTask[] findByG_T_S_PrevAndNext( 1946 long backgroundTaskId, long groupId, 1947 java.lang.String taskExecutorClassName, int status, 1948 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1949 throws com.liferay.portal.NoSuchBackgroundTaskException, 1950 com.liferay.portal.kernel.exception.SystemException { 1951 return getPersistence() 1952 .findByG_T_S_PrevAndNext(backgroundTaskId, groupId, 1953 taskExecutorClassName, status, orderByComparator); 1954 } 1955 1956 /** 1957 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 1958 * 1959 * <p> 1960 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1961 * </p> 1962 * 1963 * @param groupId the group ID 1964 * @param taskExecutorClassNames the task executor class names 1965 * @param status the status 1966 * @return the matching background tasks 1967 * @throws SystemException if a system exception occurred 1968 */ 1969 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1970 long groupId, java.lang.String[] taskExecutorClassNames, int status) 1971 throws com.liferay.portal.kernel.exception.SystemException { 1972 return getPersistence() 1973 .findByG_T_S(groupId, taskExecutorClassNames, status); 1974 } 1975 1976 /** 1977 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 1978 * 1979 * <p> 1980 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1981 * </p> 1982 * 1983 * @param groupId the group ID 1984 * @param taskExecutorClassNames the task executor class names 1985 * @param status the status 1986 * @param start the lower bound of the range of background tasks 1987 * @param end the upper bound of the range of background tasks (not inclusive) 1988 * @return the range of matching background tasks 1989 * @throws SystemException if a system exception occurred 1990 */ 1991 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 1992 long groupId, java.lang.String[] taskExecutorClassNames, int status, 1993 int start, int end) 1994 throws com.liferay.portal.kernel.exception.SystemException { 1995 return getPersistence() 1996 .findByG_T_S(groupId, taskExecutorClassNames, status, start, 1997 end); 1998 } 1999 2000 /** 2001 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 2002 * 2003 * <p> 2004 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2005 * </p> 2006 * 2007 * @param groupId the group ID 2008 * @param taskExecutorClassNames the task executor class names 2009 * @param status the status 2010 * @param start the lower bound of the range of background tasks 2011 * @param end the upper bound of the range of background tasks (not inclusive) 2012 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2013 * @return the ordered range of matching background tasks 2014 * @throws SystemException if a system exception occurred 2015 */ 2016 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_T_S( 2017 long groupId, java.lang.String[] taskExecutorClassNames, int status, 2018 int start, int end, 2019 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2020 throws com.liferay.portal.kernel.exception.SystemException { 2021 return getPersistence() 2022 .findByG_T_S(groupId, taskExecutorClassNames, status, start, 2023 end, orderByComparator); 2024 } 2025 2026 /** 2027 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ? from the database. 2028 * 2029 * @param groupId the group ID 2030 * @param taskExecutorClassName the task executor class name 2031 * @param status the status 2032 * @throws SystemException if a system exception occurred 2033 */ 2034 public static void removeByG_T_S(long groupId, 2035 java.lang.String taskExecutorClassName, int status) 2036 throws com.liferay.portal.kernel.exception.SystemException { 2037 getPersistence().removeByG_T_S(groupId, taskExecutorClassName, status); 2038 } 2039 2040 /** 2041 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 2042 * 2043 * @param groupId the group ID 2044 * @param taskExecutorClassName the task executor class name 2045 * @param status the status 2046 * @return the number of matching background tasks 2047 * @throws SystemException if a system exception occurred 2048 */ 2049 public static int countByG_T_S(long groupId, 2050 java.lang.String taskExecutorClassName, int status) 2051 throws com.liferay.portal.kernel.exception.SystemException { 2052 return getPersistence() 2053 .countByG_T_S(groupId, taskExecutorClassName, status); 2054 } 2055 2056 /** 2057 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 2058 * 2059 * @param groupId the group ID 2060 * @param taskExecutorClassNames the task executor class names 2061 * @param status the status 2062 * @return the number of matching background tasks 2063 * @throws SystemException if a system exception occurred 2064 */ 2065 public static int countByG_T_S(long groupId, 2066 java.lang.String[] taskExecutorClassNames, int status) 2067 throws com.liferay.portal.kernel.exception.SystemException { 2068 return getPersistence() 2069 .countByG_T_S(groupId, taskExecutorClassNames, status); 2070 } 2071 2072 /** 2073 * Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2074 * 2075 * @param groupId the group ID 2076 * @param name the name 2077 * @param taskExecutorClassName the task executor class name 2078 * @param completed the completed 2079 * @return the matching background tasks 2080 * @throws SystemException if a system exception occurred 2081 */ 2082 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C( 2083 long groupId, java.lang.String name, 2084 java.lang.String taskExecutorClassName, boolean completed) 2085 throws com.liferay.portal.kernel.exception.SystemException { 2086 return getPersistence() 2087 .findByG_N_T_C(groupId, name, taskExecutorClassName, 2088 completed); 2089 } 2090 2091 /** 2092 * Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2093 * 2094 * <p> 2095 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2096 * </p> 2097 * 2098 * @param groupId the group ID 2099 * @param name the name 2100 * @param taskExecutorClassName the task executor class name 2101 * @param completed the completed 2102 * @param start the lower bound of the range of background tasks 2103 * @param end the upper bound of the range of background tasks (not inclusive) 2104 * @return the range of matching background tasks 2105 * @throws SystemException if a system exception occurred 2106 */ 2107 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C( 2108 long groupId, java.lang.String name, 2109 java.lang.String taskExecutorClassName, boolean completed, int start, 2110 int end) throws com.liferay.portal.kernel.exception.SystemException { 2111 return getPersistence() 2112 .findByG_N_T_C(groupId, name, taskExecutorClassName, 2113 completed, start, end); 2114 } 2115 2116 /** 2117 * Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2118 * 2119 * <p> 2120 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2121 * </p> 2122 * 2123 * @param groupId the group ID 2124 * @param name the name 2125 * @param taskExecutorClassName the task executor class name 2126 * @param completed the completed 2127 * @param start the lower bound of the range of background tasks 2128 * @param end the upper bound of the range of background tasks (not inclusive) 2129 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2130 * @return the ordered range of matching background tasks 2131 * @throws SystemException if a system exception occurred 2132 */ 2133 public static java.util.List<com.liferay.portal.model.BackgroundTask> findByG_N_T_C( 2134 long groupId, java.lang.String name, 2135 java.lang.String taskExecutorClassName, boolean completed, int start, 2136 int end, 2137 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2138 throws com.liferay.portal.kernel.exception.SystemException { 2139 return getPersistence() 2140 .findByG_N_T_C(groupId, name, taskExecutorClassName, 2141 completed, start, end, orderByComparator); 2142 } 2143 2144 /** 2145 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2146 * 2147 * @param groupId the group ID 2148 * @param name the name 2149 * @param taskExecutorClassName the task executor class name 2150 * @param completed the completed 2151 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2152 * @return the first matching background task 2153 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 2154 * @throws SystemException if a system exception occurred 2155 */ 2156 public static com.liferay.portal.model.BackgroundTask findByG_N_T_C_First( 2157 long groupId, java.lang.String name, 2158 java.lang.String taskExecutorClassName, boolean completed, 2159 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2160 throws com.liferay.portal.NoSuchBackgroundTaskException, 2161 com.liferay.portal.kernel.exception.SystemException { 2162 return getPersistence() 2163 .findByG_N_T_C_First(groupId, name, taskExecutorClassName, 2164 completed, orderByComparator); 2165 } 2166 2167 /** 2168 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2169 * 2170 * @param groupId the group ID 2171 * @param name the name 2172 * @param taskExecutorClassName the task executor class name 2173 * @param completed the completed 2174 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2175 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 2176 * @throws SystemException if a system exception occurred 2177 */ 2178 public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_C_First( 2179 long groupId, java.lang.String name, 2180 java.lang.String taskExecutorClassName, boolean completed, 2181 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2182 throws com.liferay.portal.kernel.exception.SystemException { 2183 return getPersistence() 2184 .fetchByG_N_T_C_First(groupId, name, taskExecutorClassName, 2185 completed, orderByComparator); 2186 } 2187 2188 /** 2189 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2190 * 2191 * @param groupId the group ID 2192 * @param name the name 2193 * @param taskExecutorClassName the task executor class name 2194 * @param completed the completed 2195 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2196 * @return the last matching background task 2197 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a matching background task could not be found 2198 * @throws SystemException if a system exception occurred 2199 */ 2200 public static com.liferay.portal.model.BackgroundTask findByG_N_T_C_Last( 2201 long groupId, java.lang.String name, 2202 java.lang.String taskExecutorClassName, boolean completed, 2203 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2204 throws com.liferay.portal.NoSuchBackgroundTaskException, 2205 com.liferay.portal.kernel.exception.SystemException { 2206 return getPersistence() 2207 .findByG_N_T_C_Last(groupId, name, taskExecutorClassName, 2208 completed, orderByComparator); 2209 } 2210 2211 /** 2212 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2213 * 2214 * @param groupId the group ID 2215 * @param name the name 2216 * @param taskExecutorClassName the task executor class name 2217 * @param completed the completed 2218 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2219 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 2220 * @throws SystemException if a system exception occurred 2221 */ 2222 public static com.liferay.portal.model.BackgroundTask fetchByG_N_T_C_Last( 2223 long groupId, java.lang.String name, 2224 java.lang.String taskExecutorClassName, boolean completed, 2225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2226 throws com.liferay.portal.kernel.exception.SystemException { 2227 return getPersistence() 2228 .fetchByG_N_T_C_Last(groupId, name, taskExecutorClassName, 2229 completed, orderByComparator); 2230 } 2231 2232 /** 2233 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2234 * 2235 * @param backgroundTaskId the primary key of the current background task 2236 * @param groupId the group ID 2237 * @param name the name 2238 * @param taskExecutorClassName the task executor class name 2239 * @param completed the completed 2240 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2241 * @return the previous, current, and next background task 2242 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 2243 * @throws SystemException if a system exception occurred 2244 */ 2245 public static com.liferay.portal.model.BackgroundTask[] findByG_N_T_C_PrevAndNext( 2246 long backgroundTaskId, long groupId, java.lang.String name, 2247 java.lang.String taskExecutorClassName, boolean completed, 2248 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2249 throws com.liferay.portal.NoSuchBackgroundTaskException, 2250 com.liferay.portal.kernel.exception.SystemException { 2251 return getPersistence() 2252 .findByG_N_T_C_PrevAndNext(backgroundTaskId, groupId, name, 2253 taskExecutorClassName, completed, orderByComparator); 2254 } 2255 2256 /** 2257 * Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ? from the database. 2258 * 2259 * @param groupId the group ID 2260 * @param name the name 2261 * @param taskExecutorClassName the task executor class name 2262 * @param completed the completed 2263 * @throws SystemException if a system exception occurred 2264 */ 2265 public static void removeByG_N_T_C(long groupId, java.lang.String name, 2266 java.lang.String taskExecutorClassName, boolean completed) 2267 throws com.liferay.portal.kernel.exception.SystemException { 2268 getPersistence() 2269 .removeByG_N_T_C(groupId, name, taskExecutorClassName, completed); 2270 } 2271 2272 /** 2273 * Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 2274 * 2275 * @param groupId the group ID 2276 * @param name the name 2277 * @param taskExecutorClassName the task executor class name 2278 * @param completed the completed 2279 * @return the number of matching background tasks 2280 * @throws SystemException if a system exception occurred 2281 */ 2282 public static int countByG_N_T_C(long groupId, java.lang.String name, 2283 java.lang.String taskExecutorClassName, boolean completed) 2284 throws com.liferay.portal.kernel.exception.SystemException { 2285 return getPersistence() 2286 .countByG_N_T_C(groupId, name, taskExecutorClassName, 2287 completed); 2288 } 2289 2290 /** 2291 * Caches the background task in the entity cache if it is enabled. 2292 * 2293 * @param backgroundTask the background task 2294 */ 2295 public static void cacheResult( 2296 com.liferay.portal.model.BackgroundTask backgroundTask) { 2297 getPersistence().cacheResult(backgroundTask); 2298 } 2299 2300 /** 2301 * Caches the background tasks in the entity cache if it is enabled. 2302 * 2303 * @param backgroundTasks the background tasks 2304 */ 2305 public static void cacheResult( 2306 java.util.List<com.liferay.portal.model.BackgroundTask> backgroundTasks) { 2307 getPersistence().cacheResult(backgroundTasks); 2308 } 2309 2310 /** 2311 * Creates a new background task with the primary key. Does not add the background task to the database. 2312 * 2313 * @param backgroundTaskId the primary key for the new background task 2314 * @return the new background task 2315 */ 2316 public static com.liferay.portal.model.BackgroundTask create( 2317 long backgroundTaskId) { 2318 return getPersistence().create(backgroundTaskId); 2319 } 2320 2321 /** 2322 * Removes the background task with the primary key from the database. Also notifies the appropriate model listeners. 2323 * 2324 * @param backgroundTaskId the primary key of the background task 2325 * @return the background task that was removed 2326 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 2327 * @throws SystemException if a system exception occurred 2328 */ 2329 public static com.liferay.portal.model.BackgroundTask remove( 2330 long backgroundTaskId) 2331 throws com.liferay.portal.NoSuchBackgroundTaskException, 2332 com.liferay.portal.kernel.exception.SystemException { 2333 return getPersistence().remove(backgroundTaskId); 2334 } 2335 2336 public static com.liferay.portal.model.BackgroundTask updateImpl( 2337 com.liferay.portal.model.BackgroundTask backgroundTask) 2338 throws com.liferay.portal.kernel.exception.SystemException { 2339 return getPersistence().updateImpl(backgroundTask); 2340 } 2341 2342 /** 2343 * Returns the background task with the primary key or throws a {@link com.liferay.portal.NoSuchBackgroundTaskException} if it could not be found. 2344 * 2345 * @param backgroundTaskId the primary key of the background task 2346 * @return the background task 2347 * @throws com.liferay.portal.NoSuchBackgroundTaskException if a background task with the primary key could not be found 2348 * @throws SystemException if a system exception occurred 2349 */ 2350 public static com.liferay.portal.model.BackgroundTask findByPrimaryKey( 2351 long backgroundTaskId) 2352 throws com.liferay.portal.NoSuchBackgroundTaskException, 2353 com.liferay.portal.kernel.exception.SystemException { 2354 return getPersistence().findByPrimaryKey(backgroundTaskId); 2355 } 2356 2357 /** 2358 * Returns the background task with the primary key or returns <code>null</code> if it could not be found. 2359 * 2360 * @param backgroundTaskId the primary key of the background task 2361 * @return the background task, or <code>null</code> if a background task with the primary key could not be found 2362 * @throws SystemException if a system exception occurred 2363 */ 2364 public static com.liferay.portal.model.BackgroundTask fetchByPrimaryKey( 2365 long backgroundTaskId) 2366 throws com.liferay.portal.kernel.exception.SystemException { 2367 return getPersistence().fetchByPrimaryKey(backgroundTaskId); 2368 } 2369 2370 /** 2371 * Returns all the background tasks. 2372 * 2373 * @return the background tasks 2374 * @throws SystemException if a system exception occurred 2375 */ 2376 public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll() 2377 throws com.liferay.portal.kernel.exception.SystemException { 2378 return getPersistence().findAll(); 2379 } 2380 2381 /** 2382 * Returns a range of all the background tasks. 2383 * 2384 * <p> 2385 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2386 * </p> 2387 * 2388 * @param start the lower bound of the range of background tasks 2389 * @param end the upper bound of the range of background tasks (not inclusive) 2390 * @return the range of background tasks 2391 * @throws SystemException if a system exception occurred 2392 */ 2393 public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll( 2394 int start, int end) 2395 throws com.liferay.portal.kernel.exception.SystemException { 2396 return getPersistence().findAll(start, end); 2397 } 2398 2399 /** 2400 * Returns an ordered range of all the background tasks. 2401 * 2402 * <p> 2403 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2404 * </p> 2405 * 2406 * @param start the lower bound of the range of background tasks 2407 * @param end the upper bound of the range of background tasks (not inclusive) 2408 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2409 * @return the ordered range of background tasks 2410 * @throws SystemException if a system exception occurred 2411 */ 2412 public static java.util.List<com.liferay.portal.model.BackgroundTask> findAll( 2413 int start, int end, 2414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2415 throws com.liferay.portal.kernel.exception.SystemException { 2416 return getPersistence().findAll(start, end, orderByComparator); 2417 } 2418 2419 /** 2420 * Removes all the background tasks from the database. 2421 * 2422 * @throws SystemException if a system exception occurred 2423 */ 2424 public static void removeAll() 2425 throws com.liferay.portal.kernel.exception.SystemException { 2426 getPersistence().removeAll(); 2427 } 2428 2429 /** 2430 * Returns the number of background tasks. 2431 * 2432 * @return the number of background tasks 2433 * @throws SystemException if a system exception occurred 2434 */ 2435 public static int countAll() 2436 throws com.liferay.portal.kernel.exception.SystemException { 2437 return getPersistence().countAll(); 2438 } 2439 2440 public static BackgroundTaskPersistence getPersistence() { 2441 if (_persistence == null) { 2442 _persistence = (BackgroundTaskPersistence)PortalBeanLocatorUtil.locate(BackgroundTaskPersistence.class.getName()); 2443 2444 ReferenceRegistry.registerReference(BackgroundTaskUtil.class, 2445 "_persistence"); 2446 } 2447 2448 return _persistence; 2449 } 2450 2451 /** 2452 * @deprecated As of 6.2.0 2453 */ 2454 public void setPersistence(BackgroundTaskPersistence persistence) { 2455 } 2456 2457 private static BackgroundTaskPersistence _persistence; 2458 }