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.model.BackgroundTask; 020 021 /** 022 * The persistence interface for the background task service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see com.liferay.portal.service.persistence.impl.BackgroundTaskPersistenceImpl 030 * @see BackgroundTaskUtil 031 * @generated 032 */ 033 @ProviderType 034 public interface BackgroundTaskPersistence extends BasePersistence<BackgroundTask> { 035 /* 036 * NOTE FOR DEVELOPERS: 037 * 038 * Never modify or reference this interface directly. Always use {@link BackgroundTaskUtil} to access the background task persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 039 */ 040 041 /** 042 * Returns all the background tasks where groupId = ?. 043 * 044 * @param groupId the group ID 045 * @return the matching background tasks 046 */ 047 public java.util.List<BackgroundTask> findByGroupId(long groupId); 048 049 /** 050 * Returns a range of all the background tasks where groupId = ?. 051 * 052 * <p> 053 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 054 * </p> 055 * 056 * @param groupId the group ID 057 * @param start the lower bound of the range of background tasks 058 * @param end the upper bound of the range of background tasks (not inclusive) 059 * @return the range of matching background tasks 060 */ 061 public java.util.List<BackgroundTask> findByGroupId(long groupId, 062 int start, int end); 063 064 /** 065 * Returns an ordered range of all the background tasks where groupId = ?. 066 * 067 * <p> 068 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 069 * </p> 070 * 071 * @param groupId the group ID 072 * @param start the lower bound of the range of background tasks 073 * @param end the upper bound of the range of background tasks (not inclusive) 074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 075 * @return the ordered range of matching background tasks 076 */ 077 public java.util.List<BackgroundTask> findByGroupId(long groupId, 078 int start, int end, 079 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 080 081 /** 082 * Returns the first background task in the ordered set where groupId = ?. 083 * 084 * @param groupId the group ID 085 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 086 * @return the first matching background task 087 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 088 */ 089 public BackgroundTask findByGroupId_First(long groupId, 090 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 091 throws com.liferay.portal.NoSuchBackgroundTaskException; 092 093 /** 094 * Returns the first background task in the ordered set where groupId = ?. 095 * 096 * @param groupId the group ID 097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 098 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 099 */ 100 public BackgroundTask fetchByGroupId_First(long groupId, 101 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 102 103 /** 104 * Returns the last background task in the ordered set where groupId = ?. 105 * 106 * @param groupId the group ID 107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 108 * @return the last matching background task 109 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 110 */ 111 public BackgroundTask findByGroupId_Last(long groupId, 112 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 113 throws com.liferay.portal.NoSuchBackgroundTaskException; 114 115 /** 116 * Returns the last background task in the ordered set where groupId = ?. 117 * 118 * @param groupId the group ID 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 121 */ 122 public BackgroundTask fetchByGroupId_Last(long groupId, 123 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 124 125 /** 126 * Returns the background tasks before and after the current background task in the ordered set where groupId = ?. 127 * 128 * @param backgroundTaskId the primary key of the current background task 129 * @param groupId the group ID 130 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 131 * @return the previous, current, and next background task 132 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 133 */ 134 public BackgroundTask[] findByGroupId_PrevAndNext(long backgroundTaskId, 135 long groupId, 136 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 137 throws com.liferay.portal.NoSuchBackgroundTaskException; 138 139 /** 140 * Removes all the background tasks where groupId = ? from the database. 141 * 142 * @param groupId the group ID 143 */ 144 public void removeByGroupId(long groupId); 145 146 /** 147 * Returns the number of background tasks where groupId = ?. 148 * 149 * @param groupId the group ID 150 * @return the number of matching background tasks 151 */ 152 public int countByGroupId(long groupId); 153 154 /** 155 * Returns all the background tasks where companyId = ?. 156 * 157 * @param companyId the company ID 158 * @return the matching background tasks 159 */ 160 public java.util.List<BackgroundTask> findByCompanyId(long companyId); 161 162 /** 163 * Returns a range of all the background tasks where companyId = ?. 164 * 165 * <p> 166 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 167 * </p> 168 * 169 * @param companyId the company ID 170 * @param start the lower bound of the range of background tasks 171 * @param end the upper bound of the range of background tasks (not inclusive) 172 * @return the range of matching background tasks 173 */ 174 public java.util.List<BackgroundTask> findByCompanyId(long companyId, 175 int start, int end); 176 177 /** 178 * Returns an ordered range of all the background tasks where companyId = ?. 179 * 180 * <p> 181 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 182 * </p> 183 * 184 * @param companyId the company ID 185 * @param start the lower bound of the range of background tasks 186 * @param end the upper bound of the range of background tasks (not inclusive) 187 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 188 * @return the ordered range of matching background tasks 189 */ 190 public java.util.List<BackgroundTask> findByCompanyId(long companyId, 191 int start, int end, 192 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 193 194 /** 195 * Returns the first background task in the ordered set where companyId = ?. 196 * 197 * @param companyId the company ID 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the first matching background task 200 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 201 */ 202 public BackgroundTask findByCompanyId_First(long companyId, 203 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 204 throws com.liferay.portal.NoSuchBackgroundTaskException; 205 206 /** 207 * Returns the first background task in the ordered set where companyId = ?. 208 * 209 * @param companyId the company ID 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 212 */ 213 public BackgroundTask fetchByCompanyId_First(long companyId, 214 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 215 216 /** 217 * Returns the last background task in the ordered set where companyId = ?. 218 * 219 * @param companyId the company ID 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the last matching background task 222 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 223 */ 224 public BackgroundTask findByCompanyId_Last(long companyId, 225 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 226 throws com.liferay.portal.NoSuchBackgroundTaskException; 227 228 /** 229 * Returns the last background task in the ordered set where companyId = ?. 230 * 231 * @param companyId the company ID 232 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 233 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 234 */ 235 public BackgroundTask fetchByCompanyId_Last(long companyId, 236 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 237 238 /** 239 * Returns the background tasks before and after the current background task in the ordered set where companyId = ?. 240 * 241 * @param backgroundTaskId the primary key of the current background task 242 * @param companyId the company ID 243 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 244 * @return the previous, current, and next background task 245 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 246 */ 247 public BackgroundTask[] findByCompanyId_PrevAndNext(long backgroundTaskId, 248 long companyId, 249 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 250 throws com.liferay.portal.NoSuchBackgroundTaskException; 251 252 /** 253 * Removes all the background tasks where companyId = ? from the database. 254 * 255 * @param companyId the company ID 256 */ 257 public void removeByCompanyId(long companyId); 258 259 /** 260 * Returns the number of background tasks where companyId = ?. 261 * 262 * @param companyId the company ID 263 * @return the number of matching background tasks 264 */ 265 public int countByCompanyId(long companyId); 266 267 /** 268 * Returns all the background tasks where status = ?. 269 * 270 * @param status the status 271 * @return the matching background tasks 272 */ 273 public java.util.List<BackgroundTask> findByStatus(int status); 274 275 /** 276 * Returns a range of all the background tasks where status = ?. 277 * 278 * <p> 279 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 280 * </p> 281 * 282 * @param status the status 283 * @param start the lower bound of the range of background tasks 284 * @param end the upper bound of the range of background tasks (not inclusive) 285 * @return the range of matching background tasks 286 */ 287 public java.util.List<BackgroundTask> findByStatus(int status, int start, 288 int end); 289 290 /** 291 * Returns an ordered range of all the background tasks where status = ?. 292 * 293 * <p> 294 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 295 * </p> 296 * 297 * @param status the status 298 * @param start the lower bound of the range of background tasks 299 * @param end the upper bound of the range of background tasks (not inclusive) 300 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 301 * @return the ordered range of matching background tasks 302 */ 303 public java.util.List<BackgroundTask> findByStatus(int status, int start, 304 int end, 305 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 306 307 /** 308 * Returns the first background task in the ordered set where status = ?. 309 * 310 * @param status the status 311 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 312 * @return the first matching background task 313 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 314 */ 315 public BackgroundTask findByStatus_First(int status, 316 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 317 throws com.liferay.portal.NoSuchBackgroundTaskException; 318 319 /** 320 * Returns the first background task in the ordered set where status = ?. 321 * 322 * @param status the status 323 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 324 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 325 */ 326 public BackgroundTask fetchByStatus_First(int status, 327 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 328 329 /** 330 * Returns the last background task in the ordered set where status = ?. 331 * 332 * @param status the status 333 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 334 * @return the last matching background task 335 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 336 */ 337 public BackgroundTask findByStatus_Last(int status, 338 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 339 throws com.liferay.portal.NoSuchBackgroundTaskException; 340 341 /** 342 * Returns the last background task in the ordered set where status = ?. 343 * 344 * @param status the status 345 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 346 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 347 */ 348 public BackgroundTask fetchByStatus_Last(int status, 349 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 350 351 /** 352 * Returns the background tasks before and after the current background task in the ordered set where status = ?. 353 * 354 * @param backgroundTaskId the primary key of the current background task 355 * @param status the status 356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 357 * @return the previous, current, and next background task 358 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 359 */ 360 public BackgroundTask[] findByStatus_PrevAndNext(long backgroundTaskId, 361 int status, 362 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 363 throws com.liferay.portal.NoSuchBackgroundTaskException; 364 365 /** 366 * Removes all the background tasks where status = ? from the database. 367 * 368 * @param status the status 369 */ 370 public void removeByStatus(int status); 371 372 /** 373 * Returns the number of background tasks where status = ?. 374 * 375 * @param status the status 376 * @return the number of matching background tasks 377 */ 378 public int countByStatus(int status); 379 380 /** 381 * Returns all the background tasks where groupId = ? and taskExecutorClassName = ?. 382 * 383 * @param groupId the group ID 384 * @param taskExecutorClassName the task executor class name 385 * @return the matching background tasks 386 */ 387 public java.util.List<BackgroundTask> findByG_T(long groupId, 388 java.lang.String taskExecutorClassName); 389 390 /** 391 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ?. 392 * 393 * <p> 394 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 395 * </p> 396 * 397 * @param groupId the group ID 398 * @param taskExecutorClassName the task executor class name 399 * @param start the lower bound of the range of background tasks 400 * @param end the upper bound of the range of background tasks (not inclusive) 401 * @return the range of matching background tasks 402 */ 403 public java.util.List<BackgroundTask> findByG_T(long groupId, 404 java.lang.String taskExecutorClassName, int start, int end); 405 406 /** 407 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ?. 408 * 409 * <p> 410 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 411 * </p> 412 * 413 * @param groupId the group ID 414 * @param taskExecutorClassName the task executor class name 415 * @param start the lower bound of the range of background tasks 416 * @param end the upper bound of the range of background tasks (not inclusive) 417 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 418 * @return the ordered range of matching background tasks 419 */ 420 public java.util.List<BackgroundTask> findByG_T(long groupId, 421 java.lang.String taskExecutorClassName, int start, int end, 422 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 423 424 /** 425 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 426 * 427 * @param groupId the group ID 428 * @param taskExecutorClassName the task executor class name 429 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 430 * @return the first matching background task 431 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 432 */ 433 public BackgroundTask findByG_T_First(long groupId, 434 java.lang.String taskExecutorClassName, 435 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 436 throws com.liferay.portal.NoSuchBackgroundTaskException; 437 438 /** 439 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 440 * 441 * @param groupId the group ID 442 * @param taskExecutorClassName the task executor class name 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 445 */ 446 public BackgroundTask fetchByG_T_First(long groupId, 447 java.lang.String taskExecutorClassName, 448 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 449 450 /** 451 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 452 * 453 * @param groupId the group ID 454 * @param taskExecutorClassName the task executor class name 455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 456 * @return the last matching background task 457 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 458 */ 459 public BackgroundTask findByG_T_Last(long groupId, 460 java.lang.String taskExecutorClassName, 461 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 462 throws com.liferay.portal.NoSuchBackgroundTaskException; 463 464 /** 465 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 466 * 467 * @param groupId the group ID 468 * @param taskExecutorClassName the task executor class name 469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 470 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 471 */ 472 public BackgroundTask fetchByG_T_Last(long groupId, 473 java.lang.String taskExecutorClassName, 474 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 475 476 /** 477 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ?. 478 * 479 * @param backgroundTaskId the primary key of the current background task 480 * @param groupId the group ID 481 * @param taskExecutorClassName the task executor class name 482 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 483 * @return the previous, current, and next background task 484 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 485 */ 486 public BackgroundTask[] findByG_T_PrevAndNext(long backgroundTaskId, 487 long groupId, java.lang.String taskExecutorClassName, 488 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 489 throws com.liferay.portal.NoSuchBackgroundTaskException; 490 491 /** 492 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ?. 493 * 494 * <p> 495 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 496 * </p> 497 * 498 * @param groupId the group ID 499 * @param taskExecutorClassNames the task executor class names 500 * @return the matching background tasks 501 */ 502 public java.util.List<BackgroundTask> findByG_T(long groupId, 503 java.lang.String[] taskExecutorClassNames); 504 505 /** 506 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. 507 * 508 * <p> 509 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 510 * </p> 511 * 512 * @param groupId the group ID 513 * @param taskExecutorClassNames the task executor class names 514 * @param start the lower bound of the range of background tasks 515 * @param end the upper bound of the range of background tasks (not inclusive) 516 * @return the range of matching background tasks 517 */ 518 public java.util.List<BackgroundTask> findByG_T(long groupId, 519 java.lang.String[] taskExecutorClassNames, int start, int end); 520 521 /** 522 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ?. 523 * 524 * <p> 525 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 526 * </p> 527 * 528 * @param groupId the group ID 529 * @param taskExecutorClassNames the task executor class names 530 * @param start the lower bound of the range of background tasks 531 * @param end the upper bound of the range of background tasks (not inclusive) 532 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 533 * @return the ordered range of matching background tasks 534 */ 535 public java.util.List<BackgroundTask> findByG_T(long groupId, 536 java.lang.String[] taskExecutorClassNames, int start, int end, 537 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 538 539 /** 540 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? from the database. 541 * 542 * @param groupId the group ID 543 * @param taskExecutorClassName the task executor class name 544 */ 545 public void removeByG_T(long groupId, java.lang.String taskExecutorClassName); 546 547 /** 548 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ?. 549 * 550 * @param groupId the group ID 551 * @param taskExecutorClassName the task executor class name 552 * @return the number of matching background tasks 553 */ 554 public int countByG_T(long groupId, java.lang.String taskExecutorClassName); 555 556 /** 557 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ?. 558 * 559 * @param groupId the group ID 560 * @param taskExecutorClassNames the task executor class names 561 * @return the number of matching background tasks 562 */ 563 public int countByG_T(long groupId, 564 java.lang.String[] taskExecutorClassNames); 565 566 /** 567 * Returns all the background tasks where groupId = ? and status = ?. 568 * 569 * @param groupId the group ID 570 * @param status the status 571 * @return the matching background tasks 572 */ 573 public java.util.List<BackgroundTask> findByG_S(long groupId, int status); 574 575 /** 576 * Returns a range of all the background tasks where groupId = ? and status = ?. 577 * 578 * <p> 579 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 580 * </p> 581 * 582 * @param groupId the group ID 583 * @param status the status 584 * @param start the lower bound of the range of background tasks 585 * @param end the upper bound of the range of background tasks (not inclusive) 586 * @return the range of matching background tasks 587 */ 588 public java.util.List<BackgroundTask> findByG_S(long groupId, int status, 589 int start, int end); 590 591 /** 592 * Returns an ordered range of all the background tasks where groupId = ? and status = ?. 593 * 594 * <p> 595 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 596 * </p> 597 * 598 * @param groupId the group ID 599 * @param status the status 600 * @param start the lower bound of the range of background tasks 601 * @param end the upper bound of the range of background tasks (not inclusive) 602 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 603 * @return the ordered range of matching background tasks 604 */ 605 public java.util.List<BackgroundTask> findByG_S(long groupId, int status, 606 int start, int end, 607 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 608 609 /** 610 * Returns the first background task in the ordered set where groupId = ? and status = ?. 611 * 612 * @param groupId the group ID 613 * @param status the status 614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 615 * @return the first matching background task 616 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 617 */ 618 public BackgroundTask findByG_S_First(long groupId, int status, 619 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 620 throws com.liferay.portal.NoSuchBackgroundTaskException; 621 622 /** 623 * Returns the first background task in the ordered set where groupId = ? and status = ?. 624 * 625 * @param groupId the group ID 626 * @param status the status 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 629 */ 630 public BackgroundTask fetchByG_S_First(long groupId, int status, 631 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 632 633 /** 634 * Returns the last background task in the ordered set where groupId = ? and status = ?. 635 * 636 * @param groupId the group ID 637 * @param status the status 638 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 639 * @return the last matching background task 640 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 641 */ 642 public BackgroundTask findByG_S_Last(long groupId, int status, 643 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 644 throws com.liferay.portal.NoSuchBackgroundTaskException; 645 646 /** 647 * Returns the last background task in the ordered set where groupId = ? and status = ?. 648 * 649 * @param groupId the group ID 650 * @param status the status 651 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 652 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 653 */ 654 public BackgroundTask fetchByG_S_Last(long groupId, int status, 655 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 656 657 /** 658 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and status = ?. 659 * 660 * @param backgroundTaskId the primary key of the current background task 661 * @param groupId the group ID 662 * @param status the status 663 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 664 * @return the previous, current, and next background task 665 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 666 */ 667 public BackgroundTask[] findByG_S_PrevAndNext(long backgroundTaskId, 668 long groupId, int status, 669 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 670 throws com.liferay.portal.NoSuchBackgroundTaskException; 671 672 /** 673 * Removes all the background tasks where groupId = ? and status = ? from the database. 674 * 675 * @param groupId the group ID 676 * @param status the status 677 */ 678 public void removeByG_S(long groupId, int status); 679 680 /** 681 * Returns the number of background tasks where groupId = ? and status = ?. 682 * 683 * @param groupId the group ID 684 * @param status the status 685 * @return the number of matching background tasks 686 */ 687 public int countByG_S(long groupId, int status); 688 689 /** 690 * Returns all the background tasks where taskExecutorClassName = ? and status = ?. 691 * 692 * @param taskExecutorClassName the task executor class name 693 * @param status the status 694 * @return the matching background tasks 695 */ 696 public java.util.List<BackgroundTask> findByT_S( 697 java.lang.String taskExecutorClassName, int status); 698 699 /** 700 * Returns a range of all the background tasks where taskExecutorClassName = ? and status = ?. 701 * 702 * <p> 703 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 704 * </p> 705 * 706 * @param taskExecutorClassName the task executor class name 707 * @param status the status 708 * @param start the lower bound of the range of background tasks 709 * @param end the upper bound of the range of background tasks (not inclusive) 710 * @return the range of matching background tasks 711 */ 712 public java.util.List<BackgroundTask> findByT_S( 713 java.lang.String taskExecutorClassName, int status, int start, int end); 714 715 /** 716 * Returns an ordered range of all the background tasks where taskExecutorClassName = ? and status = ?. 717 * 718 * <p> 719 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 720 * </p> 721 * 722 * @param taskExecutorClassName the task executor class name 723 * @param status the status 724 * @param start the lower bound of the range of background tasks 725 * @param end the upper bound of the range of background tasks (not inclusive) 726 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 727 * @return the ordered range of matching background tasks 728 */ 729 public java.util.List<BackgroundTask> findByT_S( 730 java.lang.String taskExecutorClassName, int status, int start, int end, 731 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 732 733 /** 734 * Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. 735 * 736 * @param taskExecutorClassName the task executor class name 737 * @param status the status 738 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 739 * @return the first matching background task 740 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 741 */ 742 public BackgroundTask findByT_S_First( 743 java.lang.String taskExecutorClassName, int status, 744 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 745 throws com.liferay.portal.NoSuchBackgroundTaskException; 746 747 /** 748 * Returns the first background task in the ordered set where taskExecutorClassName = ? and status = ?. 749 * 750 * @param taskExecutorClassName the task executor class name 751 * @param status the status 752 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 753 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 754 */ 755 public BackgroundTask fetchByT_S_First( 756 java.lang.String taskExecutorClassName, int status, 757 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 758 759 /** 760 * Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. 761 * 762 * @param taskExecutorClassName the task executor class name 763 * @param status the status 764 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 765 * @return the last matching background task 766 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 767 */ 768 public BackgroundTask findByT_S_Last( 769 java.lang.String taskExecutorClassName, int status, 770 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 771 throws com.liferay.portal.NoSuchBackgroundTaskException; 772 773 /** 774 * Returns the last background task in the ordered set where taskExecutorClassName = ? and status = ?. 775 * 776 * @param taskExecutorClassName the task executor class name 777 * @param status the status 778 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 779 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 780 */ 781 public BackgroundTask fetchByT_S_Last( 782 java.lang.String taskExecutorClassName, int status, 783 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 784 785 /** 786 * Returns the background tasks before and after the current background task in the ordered set where taskExecutorClassName = ? and status = ?. 787 * 788 * @param backgroundTaskId the primary key of the current background task 789 * @param taskExecutorClassName the task executor class name 790 * @param status the status 791 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 792 * @return the previous, current, and next background task 793 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 794 */ 795 public BackgroundTask[] findByT_S_PrevAndNext(long backgroundTaskId, 796 java.lang.String taskExecutorClassName, int status, 797 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 798 throws com.liferay.portal.NoSuchBackgroundTaskException; 799 800 /** 801 * Returns all the background tasks where taskExecutorClassName = any ? and status = ?. 802 * 803 * <p> 804 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 805 * </p> 806 * 807 * @param taskExecutorClassNames the task executor class names 808 * @param status the status 809 * @return the matching background tasks 810 */ 811 public java.util.List<BackgroundTask> findByT_S( 812 java.lang.String[] taskExecutorClassNames, int status); 813 814 /** 815 * Returns a range of all the background tasks where taskExecutorClassName = any ? and status = ?. 816 * 817 * <p> 818 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 819 * </p> 820 * 821 * @param taskExecutorClassNames the task executor class names 822 * @param status the status 823 * @param start the lower bound of the range of background tasks 824 * @param end the upper bound of the range of background tasks (not inclusive) 825 * @return the range of matching background tasks 826 */ 827 public java.util.List<BackgroundTask> findByT_S( 828 java.lang.String[] taskExecutorClassNames, int status, int start, 829 int end); 830 831 /** 832 * Returns an ordered range of all the background tasks where taskExecutorClassName = any ? and status = ?. 833 * 834 * <p> 835 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 836 * </p> 837 * 838 * @param taskExecutorClassNames the task executor class names 839 * @param status the status 840 * @param start the lower bound of the range of background tasks 841 * @param end the upper bound of the range of background tasks (not inclusive) 842 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 843 * @return the ordered range of matching background tasks 844 */ 845 public java.util.List<BackgroundTask> findByT_S( 846 java.lang.String[] taskExecutorClassNames, int status, int start, 847 int end, 848 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 849 850 /** 851 * Removes all the background tasks where taskExecutorClassName = ? and status = ? from the database. 852 * 853 * @param taskExecutorClassName the task executor class name 854 * @param status the status 855 */ 856 public void removeByT_S(java.lang.String taskExecutorClassName, int status); 857 858 /** 859 * Returns the number of background tasks where taskExecutorClassName = ? and status = ?. 860 * 861 * @param taskExecutorClassName the task executor class name 862 * @param status the status 863 * @return the number of matching background tasks 864 */ 865 public int countByT_S(java.lang.String taskExecutorClassName, int status); 866 867 /** 868 * Returns the number of background tasks where taskExecutorClassName = any ? and status = ?. 869 * 870 * @param taskExecutorClassNames the task executor class names 871 * @param status the status 872 * @return the number of matching background tasks 873 */ 874 public int countByT_S(java.lang.String[] taskExecutorClassNames, int status); 875 876 /** 877 * Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 878 * 879 * @param groupId the group ID 880 * @param name the name 881 * @param taskExecutorClassName the task executor class name 882 * @return the matching background tasks 883 */ 884 public java.util.List<BackgroundTask> findByG_N_T(long groupId, 885 java.lang.String name, java.lang.String taskExecutorClassName); 886 887 /** 888 * Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 889 * 890 * <p> 891 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 892 * </p> 893 * 894 * @param groupId the group ID 895 * @param name the name 896 * @param taskExecutorClassName the task executor class name 897 * @param start the lower bound of the range of background tasks 898 * @param end the upper bound of the range of background tasks (not inclusive) 899 * @return the range of matching background tasks 900 */ 901 public java.util.List<BackgroundTask> findByG_N_T(long groupId, 902 java.lang.String name, java.lang.String taskExecutorClassName, 903 int start, int end); 904 905 /** 906 * Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 907 * 908 * <p> 909 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 910 * </p> 911 * 912 * @param groupId the group ID 913 * @param name the name 914 * @param taskExecutorClassName the task executor class name 915 * @param start the lower bound of the range of background tasks 916 * @param end the upper bound of the range of background tasks (not inclusive) 917 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 918 * @return the ordered range of matching background tasks 919 */ 920 public java.util.List<BackgroundTask> findByG_N_T(long groupId, 921 java.lang.String name, java.lang.String taskExecutorClassName, 922 int start, int end, 923 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 924 925 /** 926 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 927 * 928 * @param groupId the group ID 929 * @param name the name 930 * @param taskExecutorClassName the task executor class name 931 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 932 * @return the first matching background task 933 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 934 */ 935 public BackgroundTask findByG_N_T_First(long groupId, 936 java.lang.String name, java.lang.String taskExecutorClassName, 937 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 938 throws com.liferay.portal.NoSuchBackgroundTaskException; 939 940 /** 941 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 942 * 943 * @param groupId the group ID 944 * @param name the name 945 * @param taskExecutorClassName the task executor class name 946 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 947 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 948 */ 949 public BackgroundTask fetchByG_N_T_First(long groupId, 950 java.lang.String name, java.lang.String taskExecutorClassName, 951 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 952 953 /** 954 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 955 * 956 * @param groupId the group ID 957 * @param name the name 958 * @param taskExecutorClassName the task executor class name 959 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 960 * @return the last matching background task 961 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 962 */ 963 public BackgroundTask findByG_N_T_Last(long groupId, java.lang.String name, 964 java.lang.String taskExecutorClassName, 965 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 966 throws com.liferay.portal.NoSuchBackgroundTaskException; 967 968 /** 969 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 970 * 971 * @param groupId the group ID 972 * @param name the name 973 * @param taskExecutorClassName the task executor class name 974 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 975 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 976 */ 977 public BackgroundTask fetchByG_N_T_Last(long groupId, 978 java.lang.String name, java.lang.String taskExecutorClassName, 979 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 980 981 /** 982 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ?. 983 * 984 * @param backgroundTaskId the primary key of the current background task 985 * @param groupId the group ID 986 * @param name the name 987 * @param taskExecutorClassName the task executor class name 988 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 989 * @return the previous, current, and next background task 990 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 991 */ 992 public BackgroundTask[] findByG_N_T_PrevAndNext(long backgroundTaskId, 993 long groupId, java.lang.String name, 994 java.lang.String taskExecutorClassName, 995 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 996 throws com.liferay.portal.NoSuchBackgroundTaskException; 997 998 /** 999 * Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? from the database. 1000 * 1001 * @param groupId the group ID 1002 * @param name the name 1003 * @param taskExecutorClassName the task executor class name 1004 */ 1005 public void removeByG_N_T(long groupId, java.lang.String name, 1006 java.lang.String taskExecutorClassName); 1007 1008 /** 1009 * Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ?. 1010 * 1011 * @param groupId the group ID 1012 * @param name the name 1013 * @param taskExecutorClassName the task executor class name 1014 * @return the number of matching background tasks 1015 */ 1016 public int countByG_N_T(long groupId, java.lang.String name, 1017 java.lang.String taskExecutorClassName); 1018 1019 /** 1020 * Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1021 * 1022 * @param groupId the group ID 1023 * @param taskExecutorClassName the task executor class name 1024 * @param completed the completed 1025 * @return the matching background tasks 1026 */ 1027 public java.util.List<BackgroundTask> findByG_T_C(long groupId, 1028 java.lang.String taskExecutorClassName, boolean completed); 1029 1030 /** 1031 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1032 * 1033 * <p> 1034 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1035 * </p> 1036 * 1037 * @param groupId the group ID 1038 * @param taskExecutorClassName the task executor class name 1039 * @param completed the completed 1040 * @param start the lower bound of the range of background tasks 1041 * @param end the upper bound of the range of background tasks (not inclusive) 1042 * @return the range of matching background tasks 1043 */ 1044 public java.util.List<BackgroundTask> findByG_T_C(long groupId, 1045 java.lang.String taskExecutorClassName, boolean completed, int start, 1046 int end); 1047 1048 /** 1049 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1050 * 1051 * <p> 1052 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1053 * </p> 1054 * 1055 * @param groupId the group ID 1056 * @param taskExecutorClassName the task executor class name 1057 * @param completed the completed 1058 * @param start the lower bound of the range of background tasks 1059 * @param end the upper bound of the range of background tasks (not inclusive) 1060 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1061 * @return the ordered range of matching background tasks 1062 */ 1063 public java.util.List<BackgroundTask> findByG_T_C(long groupId, 1064 java.lang.String taskExecutorClassName, boolean completed, int start, 1065 int end, 1066 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1067 1068 /** 1069 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1070 * 1071 * @param groupId the group ID 1072 * @param taskExecutorClassName the task executor class name 1073 * @param completed the completed 1074 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1075 * @return the first matching background task 1076 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 1077 */ 1078 public BackgroundTask findByG_T_C_First(long groupId, 1079 java.lang.String taskExecutorClassName, boolean completed, 1080 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1081 throws com.liferay.portal.NoSuchBackgroundTaskException; 1082 1083 /** 1084 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1085 * 1086 * @param groupId the group ID 1087 * @param taskExecutorClassName the task executor class name 1088 * @param completed the completed 1089 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1090 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1091 */ 1092 public BackgroundTask fetchByG_T_C_First(long groupId, 1093 java.lang.String taskExecutorClassName, boolean completed, 1094 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1095 1096 /** 1097 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1098 * 1099 * @param groupId the group ID 1100 * @param taskExecutorClassName the task executor class name 1101 * @param completed the completed 1102 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1103 * @return the last matching background task 1104 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 1105 */ 1106 public BackgroundTask findByG_T_C_Last(long groupId, 1107 java.lang.String taskExecutorClassName, boolean completed, 1108 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1109 throws com.liferay.portal.NoSuchBackgroundTaskException; 1110 1111 /** 1112 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1113 * 1114 * @param groupId the group ID 1115 * @param taskExecutorClassName the task executor class name 1116 * @param completed the completed 1117 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1118 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1119 */ 1120 public BackgroundTask fetchByG_T_C_Last(long groupId, 1121 java.lang.String taskExecutorClassName, boolean completed, 1122 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1123 1124 /** 1125 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and completed = ?. 1126 * 1127 * @param backgroundTaskId the primary key of the current background task 1128 * @param groupId the group ID 1129 * @param taskExecutorClassName the task executor class name 1130 * @param completed the completed 1131 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1132 * @return the previous, current, and next background task 1133 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 1134 */ 1135 public BackgroundTask[] findByG_T_C_PrevAndNext(long backgroundTaskId, 1136 long groupId, java.lang.String taskExecutorClassName, 1137 boolean completed, 1138 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1139 throws com.liferay.portal.NoSuchBackgroundTaskException; 1140 1141 /** 1142 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1143 * 1144 * <p> 1145 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1146 * </p> 1147 * 1148 * @param groupId the group ID 1149 * @param taskExecutorClassNames the task executor class names 1150 * @param completed the completed 1151 * @return the matching background tasks 1152 */ 1153 public java.util.List<BackgroundTask> findByG_T_C(long groupId, 1154 java.lang.String[] taskExecutorClassNames, boolean completed); 1155 1156 /** 1157 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1158 * 1159 * <p> 1160 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BackgroundTaskModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1161 * </p> 1162 * 1163 * @param groupId the group ID 1164 * @param taskExecutorClassNames the task executor class names 1165 * @param completed the completed 1166 * @param start the lower bound of the range of background tasks 1167 * @param end the upper bound of the range of background tasks (not inclusive) 1168 * @return the range of matching background tasks 1169 */ 1170 public java.util.List<BackgroundTask> findByG_T_C(long groupId, 1171 java.lang.String[] taskExecutorClassNames, boolean completed, 1172 int start, int end); 1173 1174 /** 1175 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1176 * 1177 * <p> 1178 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1179 * </p> 1180 * 1181 * @param groupId the group ID 1182 * @param taskExecutorClassNames the task executor class names 1183 * @param completed the completed 1184 * @param start the lower bound of the range of background tasks 1185 * @param end the upper bound of the range of background tasks (not inclusive) 1186 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1187 * @return the ordered range of matching background tasks 1188 */ 1189 public java.util.List<BackgroundTask> findByG_T_C(long groupId, 1190 java.lang.String[] taskExecutorClassNames, boolean completed, 1191 int start, int end, 1192 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1193 1194 /** 1195 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and completed = ? from the database. 1196 * 1197 * @param groupId the group ID 1198 * @param taskExecutorClassName the task executor class name 1199 * @param completed the completed 1200 */ 1201 public void removeByG_T_C(long groupId, 1202 java.lang.String taskExecutorClassName, boolean completed); 1203 1204 /** 1205 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and completed = ?. 1206 * 1207 * @param groupId the group ID 1208 * @param taskExecutorClassName the task executor class name 1209 * @param completed the completed 1210 * @return the number of matching background tasks 1211 */ 1212 public int countByG_T_C(long groupId, 1213 java.lang.String taskExecutorClassName, boolean completed); 1214 1215 /** 1216 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and completed = ?. 1217 * 1218 * @param groupId the group ID 1219 * @param taskExecutorClassNames the task executor class names 1220 * @param completed the completed 1221 * @return the number of matching background tasks 1222 */ 1223 public int countByG_T_C(long groupId, 1224 java.lang.String[] taskExecutorClassNames, boolean completed); 1225 1226 /** 1227 * Returns all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1228 * 1229 * @param groupId the group ID 1230 * @param taskExecutorClassName the task executor class name 1231 * @param status the status 1232 * @return the matching background tasks 1233 */ 1234 public java.util.List<BackgroundTask> findByG_T_S(long groupId, 1235 java.lang.String taskExecutorClassName, int status); 1236 1237 /** 1238 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1239 * 1240 * <p> 1241 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1242 * </p> 1243 * 1244 * @param groupId the group ID 1245 * @param taskExecutorClassName the task executor class name 1246 * @param status the status 1247 * @param start the lower bound of the range of background tasks 1248 * @param end the upper bound of the range of background tasks (not inclusive) 1249 * @return the range of matching background tasks 1250 */ 1251 public java.util.List<BackgroundTask> findByG_T_S(long groupId, 1252 java.lang.String taskExecutorClassName, int status, int start, int end); 1253 1254 /** 1255 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1256 * 1257 * <p> 1258 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1259 * </p> 1260 * 1261 * @param groupId the group ID 1262 * @param taskExecutorClassName the task executor class name 1263 * @param status the status 1264 * @param start the lower bound of the range of background tasks 1265 * @param end the upper bound of the range of background tasks (not inclusive) 1266 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1267 * @return the ordered range of matching background tasks 1268 */ 1269 public java.util.List<BackgroundTask> findByG_T_S(long groupId, 1270 java.lang.String taskExecutorClassName, int status, int start, int end, 1271 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1272 1273 /** 1274 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1275 * 1276 * @param groupId the group ID 1277 * @param taskExecutorClassName the task executor class name 1278 * @param status the status 1279 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1280 * @return the first matching background task 1281 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 1282 */ 1283 public BackgroundTask findByG_T_S_First(long groupId, 1284 java.lang.String taskExecutorClassName, int status, 1285 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1286 throws com.liferay.portal.NoSuchBackgroundTaskException; 1287 1288 /** 1289 * Returns the first background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1290 * 1291 * @param groupId the group ID 1292 * @param taskExecutorClassName the task executor class name 1293 * @param status the status 1294 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1295 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1296 */ 1297 public BackgroundTask fetchByG_T_S_First(long groupId, 1298 java.lang.String taskExecutorClassName, int status, 1299 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1300 1301 /** 1302 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1303 * 1304 * @param groupId the group ID 1305 * @param taskExecutorClassName the task executor class name 1306 * @param status the status 1307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1308 * @return the last matching background task 1309 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 1310 */ 1311 public BackgroundTask findByG_T_S_Last(long groupId, 1312 java.lang.String taskExecutorClassName, int status, 1313 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1314 throws com.liferay.portal.NoSuchBackgroundTaskException; 1315 1316 /** 1317 * Returns the last background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1318 * 1319 * @param groupId the group ID 1320 * @param taskExecutorClassName the task executor class name 1321 * @param status the status 1322 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1323 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1324 */ 1325 public BackgroundTask fetchByG_T_S_Last(long groupId, 1326 java.lang.String taskExecutorClassName, int status, 1327 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1328 1329 /** 1330 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and taskExecutorClassName = ? and status = ?. 1331 * 1332 * @param backgroundTaskId the primary key of the current background task 1333 * @param groupId the group ID 1334 * @param taskExecutorClassName the task executor class name 1335 * @param status the status 1336 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1337 * @return the previous, current, and next background task 1338 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 1339 */ 1340 public BackgroundTask[] findByG_T_S_PrevAndNext(long backgroundTaskId, 1341 long groupId, java.lang.String taskExecutorClassName, int status, 1342 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1343 throws com.liferay.portal.NoSuchBackgroundTaskException; 1344 1345 /** 1346 * Returns all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 1347 * 1348 * <p> 1349 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1350 * </p> 1351 * 1352 * @param groupId the group ID 1353 * @param taskExecutorClassNames the task executor class names 1354 * @param status the status 1355 * @return the matching background tasks 1356 */ 1357 public java.util.List<BackgroundTask> findByG_T_S(long groupId, 1358 java.lang.String[] taskExecutorClassNames, int status); 1359 1360 /** 1361 * Returns a range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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 taskExecutorClassNames the task executor class names 1369 * @param status the status 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 java.util.List<BackgroundTask> findByG_T_S(long groupId, 1375 java.lang.String[] taskExecutorClassNames, int status, int start, 1376 int end); 1377 1378 /** 1379 * Returns an ordered range of all the background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 1380 * 1381 * <p> 1382 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1383 * </p> 1384 * 1385 * @param groupId the group ID 1386 * @param taskExecutorClassNames the task executor class names 1387 * @param status the status 1388 * @param start the lower bound of the range of background tasks 1389 * @param end the upper bound of the range of background tasks (not inclusive) 1390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1391 * @return the ordered range of matching background tasks 1392 */ 1393 public java.util.List<BackgroundTask> findByG_T_S(long groupId, 1394 java.lang.String[] taskExecutorClassNames, int status, int start, 1395 int end, 1396 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1397 1398 /** 1399 * Removes all the background tasks where groupId = ? and taskExecutorClassName = ? and status = ? from the database. 1400 * 1401 * @param groupId the group ID 1402 * @param taskExecutorClassName the task executor class name 1403 * @param status the status 1404 */ 1405 public void removeByG_T_S(long groupId, 1406 java.lang.String taskExecutorClassName, int status); 1407 1408 /** 1409 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = ? and status = ?. 1410 * 1411 * @param groupId the group ID 1412 * @param taskExecutorClassName the task executor class name 1413 * @param status the status 1414 * @return the number of matching background tasks 1415 */ 1416 public int countByG_T_S(long groupId, 1417 java.lang.String taskExecutorClassName, int status); 1418 1419 /** 1420 * Returns the number of background tasks where groupId = ? and taskExecutorClassName = any ? and status = ?. 1421 * 1422 * @param groupId the group ID 1423 * @param taskExecutorClassNames the task executor class names 1424 * @param status the status 1425 * @return the number of matching background tasks 1426 */ 1427 public int countByG_T_S(long groupId, 1428 java.lang.String[] taskExecutorClassNames, int status); 1429 1430 /** 1431 * Returns all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1432 * 1433 * @param groupId the group ID 1434 * @param name the name 1435 * @param taskExecutorClassName the task executor class name 1436 * @param completed the completed 1437 * @return the matching background tasks 1438 */ 1439 public java.util.List<BackgroundTask> findByG_N_T_C(long groupId, 1440 java.lang.String name, java.lang.String taskExecutorClassName, 1441 boolean completed); 1442 1443 /** 1444 * Returns a range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1445 * 1446 * <p> 1447 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1448 * </p> 1449 * 1450 * @param groupId the group ID 1451 * @param name the name 1452 * @param taskExecutorClassName the task executor class name 1453 * @param completed the completed 1454 * @param start the lower bound of the range of background tasks 1455 * @param end the upper bound of the range of background tasks (not inclusive) 1456 * @return the range of matching background tasks 1457 */ 1458 public java.util.List<BackgroundTask> findByG_N_T_C(long groupId, 1459 java.lang.String name, java.lang.String taskExecutorClassName, 1460 boolean completed, int start, int end); 1461 1462 /** 1463 * Returns an ordered range of all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1464 * 1465 * <p> 1466 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1467 * </p> 1468 * 1469 * @param groupId the group ID 1470 * @param name the name 1471 * @param taskExecutorClassName the task executor class name 1472 * @param completed the completed 1473 * @param start the lower bound of the range of background tasks 1474 * @param end the upper bound of the range of background tasks (not inclusive) 1475 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1476 * @return the ordered range of matching background tasks 1477 */ 1478 public java.util.List<BackgroundTask> findByG_N_T_C(long groupId, 1479 java.lang.String name, java.lang.String taskExecutorClassName, 1480 boolean completed, int start, int end, 1481 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1482 1483 /** 1484 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1485 * 1486 * @param groupId the group ID 1487 * @param name the name 1488 * @param taskExecutorClassName the task executor class name 1489 * @param completed the completed 1490 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1491 * @return the first matching background task 1492 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 1493 */ 1494 public BackgroundTask findByG_N_T_C_First(long groupId, 1495 java.lang.String name, java.lang.String taskExecutorClassName, 1496 boolean completed, 1497 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1498 throws com.liferay.portal.NoSuchBackgroundTaskException; 1499 1500 /** 1501 * Returns the first background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1502 * 1503 * @param groupId the group ID 1504 * @param name the name 1505 * @param taskExecutorClassName the task executor class name 1506 * @param completed the completed 1507 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1508 * @return the first matching background task, or <code>null</code> if a matching background task could not be found 1509 */ 1510 public BackgroundTask fetchByG_N_T_C_First(long groupId, 1511 java.lang.String name, java.lang.String taskExecutorClassName, 1512 boolean completed, 1513 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1514 1515 /** 1516 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1517 * 1518 * @param groupId the group ID 1519 * @param name the name 1520 * @param taskExecutorClassName the task executor class name 1521 * @param completed the completed 1522 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1523 * @return the last matching background task 1524 * @throws NoSuchBackgroundTaskException if a matching background task could not be found 1525 */ 1526 public BackgroundTask findByG_N_T_C_Last(long groupId, 1527 java.lang.String name, java.lang.String taskExecutorClassName, 1528 boolean completed, 1529 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1530 throws com.liferay.portal.NoSuchBackgroundTaskException; 1531 1532 /** 1533 * Returns the last background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1534 * 1535 * @param groupId the group ID 1536 * @param name the name 1537 * @param taskExecutorClassName the task executor class name 1538 * @param completed the completed 1539 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1540 * @return the last matching background task, or <code>null</code> if a matching background task could not be found 1541 */ 1542 public BackgroundTask fetchByG_N_T_C_Last(long groupId, 1543 java.lang.String name, java.lang.String taskExecutorClassName, 1544 boolean completed, 1545 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1546 1547 /** 1548 * Returns the background tasks before and after the current background task in the ordered set where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1549 * 1550 * @param backgroundTaskId the primary key of the current background task 1551 * @param groupId the group ID 1552 * @param name the name 1553 * @param taskExecutorClassName the task executor class name 1554 * @param completed the completed 1555 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1556 * @return the previous, current, and next background task 1557 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 1558 */ 1559 public BackgroundTask[] findByG_N_T_C_PrevAndNext(long backgroundTaskId, 1560 long groupId, java.lang.String name, 1561 java.lang.String taskExecutorClassName, boolean completed, 1562 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator) 1563 throws com.liferay.portal.NoSuchBackgroundTaskException; 1564 1565 /** 1566 * Removes all the background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ? from the database. 1567 * 1568 * @param groupId the group ID 1569 * @param name the name 1570 * @param taskExecutorClassName the task executor class name 1571 * @param completed the completed 1572 */ 1573 public void removeByG_N_T_C(long groupId, java.lang.String name, 1574 java.lang.String taskExecutorClassName, boolean completed); 1575 1576 /** 1577 * Returns the number of background tasks where groupId = ? and name = ? and taskExecutorClassName = ? and completed = ?. 1578 * 1579 * @param groupId the group ID 1580 * @param name the name 1581 * @param taskExecutorClassName the task executor class name 1582 * @param completed the completed 1583 * @return the number of matching background tasks 1584 */ 1585 public int countByG_N_T_C(long groupId, java.lang.String name, 1586 java.lang.String taskExecutorClassName, boolean completed); 1587 1588 /** 1589 * Caches the background task in the entity cache if it is enabled. 1590 * 1591 * @param backgroundTask the background task 1592 */ 1593 public void cacheResult(BackgroundTask backgroundTask); 1594 1595 /** 1596 * Caches the background tasks in the entity cache if it is enabled. 1597 * 1598 * @param backgroundTasks the background tasks 1599 */ 1600 public void cacheResult(java.util.List<BackgroundTask> backgroundTasks); 1601 1602 /** 1603 * Creates a new background task with the primary key. Does not add the background task to the database. 1604 * 1605 * @param backgroundTaskId the primary key for the new background task 1606 * @return the new background task 1607 */ 1608 public BackgroundTask create(long backgroundTaskId); 1609 1610 /** 1611 * Removes the background task with the primary key from the database. Also notifies the appropriate model listeners. 1612 * 1613 * @param backgroundTaskId the primary key of the background task 1614 * @return the background task that was removed 1615 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 1616 */ 1617 public BackgroundTask remove(long backgroundTaskId) 1618 throws com.liferay.portal.NoSuchBackgroundTaskException; 1619 1620 public BackgroundTask updateImpl(BackgroundTask backgroundTask); 1621 1622 /** 1623 * Returns the background task with the primary key or throws a {@link NoSuchBackgroundTaskException} if it could not be found. 1624 * 1625 * @param backgroundTaskId the primary key of the background task 1626 * @return the background task 1627 * @throws NoSuchBackgroundTaskException if a background task with the primary key could not be found 1628 */ 1629 public BackgroundTask findByPrimaryKey(long backgroundTaskId) 1630 throws com.liferay.portal.NoSuchBackgroundTaskException; 1631 1632 /** 1633 * Returns the background task with the primary key or returns <code>null</code> if it could not be found. 1634 * 1635 * @param backgroundTaskId the primary key of the background task 1636 * @return the background task, or <code>null</code> if a background task with the primary key could not be found 1637 */ 1638 public BackgroundTask fetchByPrimaryKey(long backgroundTaskId); 1639 1640 @Override 1641 public java.util.Map<java.io.Serializable, BackgroundTask> fetchByPrimaryKeys( 1642 java.util.Set<java.io.Serializable> primaryKeys); 1643 1644 /** 1645 * Returns all the background tasks. 1646 * 1647 * @return the background tasks 1648 */ 1649 public java.util.List<BackgroundTask> findAll(); 1650 1651 /** 1652 * Returns a range of all the background tasks. 1653 * 1654 * <p> 1655 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1656 * </p> 1657 * 1658 * @param start the lower bound of the range of background tasks 1659 * @param end the upper bound of the range of background tasks (not inclusive) 1660 * @return the range of background tasks 1661 */ 1662 public java.util.List<BackgroundTask> findAll(int start, int end); 1663 1664 /** 1665 * Returns an ordered range of all the background tasks. 1666 * 1667 * <p> 1668 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link 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. 1669 * </p> 1670 * 1671 * @param start the lower bound of the range of background tasks 1672 * @param end the upper bound of the range of background tasks (not inclusive) 1673 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1674 * @return the ordered range of background tasks 1675 */ 1676 public java.util.List<BackgroundTask> findAll(int start, int end, 1677 com.liferay.portal.kernel.util.OrderByComparator<BackgroundTask> orderByComparator); 1678 1679 /** 1680 * Removes all the background tasks from the database. 1681 */ 1682 public void removeAll(); 1683 1684 /** 1685 * Returns the number of background tasks. 1686 * 1687 * @return the number of background tasks 1688 */ 1689 public int countAll(); 1690 }