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